@jsenv/core 41.4.17 → 41.4.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "41.4.17",
+  "version": "41.4.19",
   "type": "module",
   "description": "Tool to develop, test and build js projects",
   "repository": {
@@ -72,13 +72,13 @@
     "test:snapshot_clear": "npx @jsenv/filesystem clear **/tests/**/side_effects/"
   },
   "dependencies": {
-    "@jsenv/ast": "6.9.1",
-    "@jsenv/js-module-fallback": "1.5.0",
-    "@jsenv/plugin-bundling": "2.10.16",
-    "@jsenv/plugin-minification": "1.7.8",
-    "@jsenv/plugin-supervisor": "1.8.12",
-    "@jsenv/plugin-transpilation": "1.6.0",
-    "@jsenv/server": "17.6.1",
+    "@jsenv/ast": "6.9.2",
+    "@jsenv/js-module-fallback": "1.5.1",
+    "@jsenv/plugin-bundling": "2.10.18",
+    "@jsenv/plugin-minification": "1.7.10",
+    "@jsenv/plugin-supervisor": "1.8.13",
+    "@jsenv/plugin-transpilation": "1.6.1",
+    "@jsenv/server": "17.6.2",
     "@jsenv/sourcemap": "1.4.2",
     "react-table": "7.8.0"
   },

package/src/build/build.js

@@ -38,10 +38,7 @@ import {
   UNICODE,
 } from "@jsenv/humanize";
 import { applyNodeEsmResolution } from "@jsenv/node-esm-resolution";
-import {
-  startMonitoringCpuUsage,
-  startMonitoringMemoryUsage,
-} from "@jsenv/os-metrics";
+import { startMonitoringMemoryUsage } from "@jsenv/os-metrics";
 import { jsenvPluginBundling } from "@jsenv/plugin-bundling";
 import { jsenvPluginMinification } from "@jsenv/plugin-minification";
 import { jsenvPluginJsModuleFallback } from "@jsenv/plugin-transpilation";
@@ -395,13 +392,12 @@ entryPoints: {
     });
   }
 
-  const cpuMonitoring = startMonitoringCpuUsage();
-  operation.addEndCallback(cpuMonitoring.stop);
-  const [processCpuUsageMonitoring] = cpuMonitoring;
+  // cpu is not sampled: cooking, rollup and terser hold the event loop for
+  // seconds at a time, a sampler only runs in the gaps and would report the
+  // idle time. What the build cost is process.cpuUsage() over its duration.
   const memoryMonitoring = startMonitoringMemoryUsage();
   const [processMemoryUsageMonitoring] = memoryMonitoring;
   const interval = setInterval(() => {
-    processCpuUsageMonitoring.measure();
     processMemoryUsageMonitoring.measure();
   }, 500).unref();
   operation.addEndCallback(() => {
@@ -471,19 +467,24 @@ entryPoints: {
     content += "\n";
     return content;
   };
-  const renderBuildEndLog = ({ duration, buildFileContents }) => {
+  const renderBuildEndLog = ({
+    duration,
+    buildFileContents,
+    cpuUsage,
+    phaseTimings,
+  }) => {
     // 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({
       entryPointArray,
       duration,
       buildFileContents,
-      processCpuUsage: processCpuUsageMonitoring.info,
+      cpuUsage,
+      phaseTimings,
       processMemoryUsage: processMemoryUsageMonitoring.info,
     });
   };
@@ -558,13 +559,25 @@ entryPoints: {
             }, renderDynamicLog());
           };
         },
-        onBuildEnd: ({ buildFileContents, duration }) => {
+        onBuildEnd: ({
+          buildFileContents,
+          duration,
+          cpuUsage,
+          phaseTimings,
+        }) => {
           clearInterval(interval);
           dynamicLog.update("");
           dynamicLog.destroy();
           dynamicLog = null;
           logger.info("");
-          logger.info(renderBuildEndLog({ duration, buildFileContents }));
+          logger.info(
+            renderBuildEndLog({
+              duration,
+              buildFileContents,
+              cpuUsage,
+              phaseTimings,
+            }),
+          );
         },
       };
     };
@@ -591,8 +604,20 @@ entryPoints: {
             );
           };
         },
-        onBuildEnd: ({ buildFileContents, duration }) => {
-          logger.info(renderBuildEndLog({ duration, buildFileContents }));
+        onBuildEnd: ({
+          buildFileContents,
+          duration,
+          cpuUsage,
+          phaseTimings,
+        }) => {
+          logger.info(
+            renderBuildEndLog({
+              duration,
+              buildFileContents,
+              cpuUsage,
+              phaseTimings,
+            }),
+          );
         },
       };
     };
@@ -642,6 +667,7 @@ entryPoints: {
 
   const runBuild = async ({ signal }) => {
     const startDate = Date.now();
+    const cpuUsageAtStart = process.cpuUsage();
     const { onBuildEnd, onEntryPointBuildStart } = startBuildLogs();
 
     const buildUrlsGenerator = createBuildUrlsGenerator({
@@ -750,6 +776,7 @@ entryPoints: {
             entryBuildInfo.buildInlineContents = result.buildInlineContents;
             entryBuildInfo.buildManifest = result.buildManifest;
             entryBuildInfo.buildSideEffectFiles = result.buildSideEffectFiles;
+            entryBuildInfo.phaseTimings = result.phaseTimings;
             entryBuildInfo.duration = Date.now() - entryPointBuildStartMs;
             onEntryPointBuildEnd();
           })();
@@ -854,11 +881,19 @@ entryPoints: {
         }
       }
     }
+    // entry points are built concurrently, interleaved on the same thread:
+    // their phases overlap and only a single one can be told apart
+    const phaseTimings =
+      entryBuildInfoMap.size === 1
+        ? entryBuildInfoMap.values().next().value.phaseTimings
+        : null;
     onBuildEnd({
       buildFileContents,
       buildInlineContents,
       buildManifest,
       duration: Date.now() - startDate,
+      cpuUsage: process.cpuUsage(cpuUsageAtStart),
+      phaseTimings,
     });
     return {
       ...(returnBuildInlineContents ? { buildInlineContents } : {}),
@@ -1222,6 +1257,14 @@ const prepareEntryPointBuild = async (
   return {
     entryReference,
     buildEntryPoint: async ({ getOtherEntryBuildInfo }) => {
+      const phaseTimings = {};
+      let phaseStartMs = Date.now();
+      const endPhase = (name) => {
+        const nowMs = Date.now();
+        phaseTimings[name] = nowMs - phaseStartMs;
+        phaseStartMs = nowMs;
+      };
+
       craft: {
         _getOtherEntryBuildInfo = getOtherEntryBuildInfo;
         if (outDirectoryUrl) {
@@ -1229,6 +1272,7 @@ const prepareEntryPointBuild = async (
         }
         await rawRootUrlInfo.cookDependencies({ operation: buildOperation });
       }
+      endPhase("craft");
 
       const finalKitchen = createKitchen({
         name: "shape",
@@ -1443,6 +1487,8 @@ const prepareEntryPointBuild = async (
         }
       }
 
+      endPhase("bundle");
+
       shape: {
         finalKitchen.context.buildStep = "shape";
         if (outDirectoryUrl) {
@@ -1462,6 +1508,8 @@ const prepareEntryPointBuild = async (
         });
       }
 
+      endPhase("shape");
+
       const buildSideEffectFiles = [];
       refine: {
         finalKitchen.context.buildStep = "refine";
@@ -1569,6 +1617,8 @@ const prepareEntryPointBuild = async (
           }
         }
       }
+      endPhase("refine");
+
       const {
         buildFileContents,
         buildFileVersions,
@@ -1588,6 +1638,7 @@ const prepareEntryPointBuild = async (
         buildInlineContents,
         buildManifest,
         buildSideEffectFiles,
+        phaseTimings,
       };
     },
   };

package/src/build/build_content_report.js

@@ -19,11 +19,12 @@ ${createRepartitionMessage(buildContentReport, { indent })}
 --------------------`;
 };
 
-const humanizeProcessCpuUsage = (ratio) => {
-  const percentageAsNumber = ratio * 100;
-  const percentageAsNumberRounded = Math.round(percentageAsNumber);
-  const percentage = `${percentageAsNumberRounded}%`;
-  return percentage;
+// a phase can be a few milliseconds long (refine, mostly): shown as such
+const humanizePhaseDuration = (ms) => {
+  if (ms < 1000) {
+    return `${Math.round(ms)}ms`;
+  }
+  return humanizeDuration(ms, { short: true });
 };
 const humanizeProcessMemoryUsage = (value) => {
   return humanizeMemory(value, { short: true, decimals: 0 });
@@ -32,7 +33,8 @@ export const renderBuildDoneLog = ({
   entryPointArray,
   duration,
   buildFileContents,
-  processCpuUsage,
+  cpuUsage,
+  phaseTimings,
   processMemoryUsage,
 }) => {
   const buildContentReport = createBuildContentReport(buildFileContents);
@@ -47,15 +49,10 @@ export const renderBuildDoneLog = ({
     title = `build done (${entryPointCount} entry points)`;
   }
 
-  // cpu usage
-  let cpuUsageLine = "cpu: ";
-  cpuUsageLine += `${humanizeProcessCpuUsage(processCpuUsage.end)}`;
-  cpuUsageLine += renderDetails({
-    med: humanizeProcessCpuUsage(processCpuUsage.median),
-    min: humanizeProcessCpuUsage(processCpuUsage.min),
-    max: humanizeProcessCpuUsage(processCpuUsage.max),
-  });
-  lines.push(cpuUsageLine);
+  // cpu: the process cpu time over the build duration, 100% being one core
+  // busy the whole time (more when a native module works on other threads)
+  const cpuMs = (cpuUsage.user + cpuUsage.system) / 1000;
+  lines.push(`cpu: ${Math.round((cpuMs / duration) * 100)}%`);
 
   // memory usage
   let memoryUsageLine = "memory: ";
@@ -70,6 +67,16 @@ export const renderBuildDoneLog = ({
   // duration
   let durationLine = `duration: `;
   durationLine += humanizeDuration(duration, { short: true });
+  if (phaseTimings) {
+    durationLine += renderDetails(
+      Object.fromEntries(
+        Object.keys(phaseTimings).map((phaseName) => [
+          phaseName,
+          humanizePhaseDuration(phaseTimings[phaseName]),
+        ]),
+      ),
+    );
+  }
   lines.push(durationLine);
 
   // content
@@ -269,6 +276,8 @@ const createBuildContentReport = (buildFileContents) => {
 };
 
 const determineCategory = (buildRelativeUrl) => {
+  // a versioned url ("main.js?v=abc") is categorized by its file
+  buildRelativeUrl = buildRelativeUrl.replace(/[?#].*$/, "");
   if (buildRelativeUrl.endsWith(".map")) {
     return "sourcemap";
   }

package/src/build/build_specifier_manager.js

@@ -801,7 +801,7 @@ export const createBuildSpecifierManager = ({
           }
           if (mayUsePlaceholder(urlInfo)) {
             const contentBeforeReplace = urlInfo.content;
-            const { content, sourcemap } = placeholderAPI.replaceAll(
+            const replaceResult = placeholderAPI.replaceAll(
               contentBeforeReplace,
               (placeholder) => {
                 const reference = placeholderToReferenceMap.get(placeholder);
@@ -809,7 +809,7 @@ export const createBuildSpecifierManager = ({
                 return value;
               },
             );
-            urlInfo.mutateContent({ content, sourcemap });
+            urlInfo.mutateContent(replaceResult);
           }
         },
       );

package/src/dev/dev_server_plugins/dev_server_plugin_omega_error_handler.js

@@ -15,7 +15,10 @@ export const devServerPluginOmegaErrorHandler = () => {
               status: 403,
             };
           }
-          return convertFileSystemErrorToResponseProperties(error);
+          // the dev server runs with canExposeSensitiveData: file paths are welcome
+          return convertFileSystemErrorToResponseProperties(error, {
+            canExposeSensitiveData: true,
+          });
         };
         const response = getResponseForError();
         if (!response) {

package/src/dev/dev_server_plugins/dev_server_plugin_serve_source_files.js

@@ -1,9 +1,8 @@
 import { bufferToEtag } from "@jsenv/filesystem";
 import { formatError } from "@jsenv/humanize";
 import { composeTwoResponses, fetchDirectory } from "@jsenv/server";
-import { URL_META } from "@jsenv/url-meta";
 import { normalizeUrl } from "@jsenv/urls";
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 
 import { watchSourceFiles } from "../../helpers/watch_source_files.js";
 import { WEB_URL_CONVERTER } from "../../helpers/web_url_converter.js";
@@ -56,11 +55,10 @@ export const devServerPluginServeSourceFiles = ({
     if (existing) {
       return existing;
     }
-    const watchAssociations = URL_META.resolveAssociations(
-      { watch: stopWatchingSourceFiles.watchPatterns },
-      sourceDirectoryUrl,
-    );
     let kitchen;
+    // per url info, the file stat under which its content was last compared
+    // with the file on disk and found identical (see isValid)
+    const fileStatValidatedMap = new WeakMap();
     clientFileChangeEventEmitter.on(({ url, event }) => {
       const urlInfo = kitchen.graph.getUrlInfo(url);
       if (urlInfo) {
@@ -101,11 +99,6 @@ export const devServerPluginServeSourceFiles = ({
       packageDirectory,
     });
     kitchen.graph.urlInfoCreatedEventEmitter.on((urlInfoCreated) => {
-      const { watch } = URL_META.applyAssociations({
-        url: urlInfoCreated.url,
-        associations: watchAssociations,
-      });
-      urlInfoCreated.isWatched = watch;
       // when an url depends on many others, we check all these (like package.json)
       urlInfoCreated.isValid = () => {
         const seenSet = new Set();
@@ -125,37 +118,64 @@ export const devServerPluginServeSourceFiles = ({
             //   was compared using etag and it has changed
             return false;
           }
-          // Watched files trust the watcher — except the ones marked
-          // revalidateOnFileSystem (package.json files, see node_esm_resolver):
-          // the watcher fires a beat AFTER a change, and what these files
-          // decide (a package version, hence the ?v= the importer embeds) is
-          // cached as immutable by the browser — a request racing the watcher
-          // must not win a stale answer it would then keep forever.
-          if (!urlInfo.isWatched || urlInfo.revalidateOnFileSystem) {
-            // check the filesystem
-            let fileContentAsBuffer;
+          // The content held in memory is the file as it was read; a request
+          // must never win a stale answer, whatever the watcher's latency,
+          // and the ?v= a package.json decides even ends up in the browser's
+          // immutable cache. So the file is checked on disk at every
+          // validation — cheaply: a stat, compared with the one taken when
+          // the content was read (or last found identical). Only a file
+          // whose stat moved is read and hashed again.
+          // Inline content (a <script> inside an html) has no file of its
+          // own: it is as fresh as the html holding it, checked by the caller.
+          if (!urlInfo.isInline) {
+            let fileStat;
             try {
-              fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
-            } catch (e) {
-              if (e.code === "ENOENT") {
-                urlInfo.onModified();
-                return false;
-              }
+              fileStat = statSync(new URL(urlInfo.url), {
+                throwIfNoEntry: false,
+              });
+            } catch {
               return false;
             }
-            const fileContentEtag = bufferToEtag(fileContentAsBuffer);
-            if (fileContentEtag !== urlInfo.originalContentEtag) {
+            if (!fileStat) {
               urlInfo.onModified();
-              // restore content to be able to compare it again later
-              urlInfo.kitchen.urlInfoTransformer.setContent(
-                urlInfo,
-                String(fileContentAsBuffer),
-                {
-                  contentEtag: fileContentEtag,
-                },
-              );
               return false;
             }
+            const fileStatKnown =
+              fileStatValidatedMap.get(urlInfo) || urlInfo.data.fileStat;
+            const fileUnchanged =
+              fileStatKnown &&
+              fileStatKnown.mtimeMs === fileStat.mtimeMs &&
+              fileStatKnown.size === fileStat.size;
+            if (!fileUnchanged) {
+              let fileContentAsBuffer;
+              try {
+                fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
+              } catch (e) {
+                if (e.code === "ENOENT") {
+                  urlInfo.onModified();
+                  return false;
+                }
+                return false;
+              }
+              const fileContentEtag = bufferToEtag(fileContentAsBuffer);
+              if (fileContentEtag !== urlInfo.originalContentEtag) {
+                fileStatValidatedMap.delete(urlInfo);
+                urlInfo.onModified();
+                // restore content to be able to compare it again later
+                urlInfo.kitchen.urlInfoTransformer.setContent(
+                  urlInfo,
+                  String(fileContentAsBuffer),
+                  {
+                    contentEtag: fileContentEtag,
+                  },
+                );
+                return false;
+              }
+              fileStatValidatedMap.set(urlInfo, {
+                mtimeMs: fileStat.mtimeMs,
+                size: fileStat.size,
+              });
+            }
           }
           for (const implicitUrl of urlInfo.implicitUrlSet) {
             const implicitUrlInfo = urlInfo.graph.getUrlInfo(implicitUrl);
@@ -271,6 +291,40 @@ export const devServerPluginServeSourceFiles = ({
           const ifNoneMatch = request.headers["if-none-match"];
           const inlineParentUrlInfo = urlInfo.findParentIfInline();
           const urlInfoTargetedByCache = inlineParentUrlInfo || urlInfo;
+          // The content held in memory is the response when it is finalized
+          // and still valid. Content can be defined while a cook is still in
+          // flight (a file watcher invalidation re-cooking in the background,
+          // for instance): at that point it holds the raw fetched content,
+          // transformations not applied yet. Serving that would send an html
+          // without any of the injected scripts. An inline url info (a
+          // <script> inside an html) is cooked again whenever the html
+          // containing it is cooked: its content is as fresh as the html's,
+          // so both must be valid.
+          const hasFreshContent = (urlInfo) =>
+            urlInfo.content !== undefined &&
+            urlInfo.contentFinalized &&
+            urlInfo.isValid();
+          const memoryContentIsFresh = () =>
+            inlineParentUrlInfo
+              ? hasFreshContent(urlInfo) && hasFreshContent(inlineParentUrlInfo)
+              : hasFreshContent(urlInfo);
+          // a 304 goes through the hooks too: its headers stand for the
+          // cached response's, they must say the same
+          const augmentResponse = (response) => {
+            const augmentResponseInfo = {
+              ...kitchen.context,
+              reference,
+              urlInfo,
+            };
+            kitchen.jsenvPluginsController.callHooks(
+              "augmentResponse",
+              augmentResponseInfo,
+              (returnValue) => {
+                response = composeTwoResponses(response, returnValue);
+              },
+            );
+            return response;
+          };
           const respondWithNotModified = () => {
             const headers = {
               "cache-control": `private,max-age=0,must-revalidate`,
@@ -280,23 +334,21 @@ export const devServerPluginServeSourceFiles = ({
                 headers[key] = urlInfo.headers[key];
               }
             });
-            return {
+            return augmentResponse({
               status: 304,
               headers,
-            };
+            });
           };
 
           try {
-            // an inline url info is cooked again every time the file containing it
-            // is cooked, so its content is only known after cooking; its etag is
-            // compared below, once cooked
-            if (!urlInfo.error && ifNoneMatch && !inlineParentUrlInfo) {
+            if (!urlInfo.error && ifNoneMatch) {
               const [clientOriginalContentEtag, clientContentEtag] =
                 ifNoneMatch.split("_");
               if (
-                urlInfo.originalContentEtag === clientOriginalContentEtag &&
+                urlInfoTargetedByCache.originalContentEtag ===
+                  clientOriginalContentEtag &&
                 urlInfo.contentEtag === clientContentEtag &&
-                urlInfo.isValid()
+                memoryContentIsFresh()
               ) {
                 return respondWithNotModified();
               }
@@ -314,18 +366,9 @@ export const devServerPluginServeSourceFiles = ({
             // client etag to match).
             const servableFromMemory =
               !urlInfo.error &&
-              !inlineParentUrlInfo &&
               !urlInfo.response &&
-              urlInfo.content !== undefined &&
-              // content can be defined while a cook is still in flight (a file
-              // watcher invalidation re-cooking in the background, for
-              // instance): at that point it holds the raw fetched content,
-              // transformations not applied yet. Serving that would send an
-              // html without any of the injected scripts. Only finalized
-              // content is a complete response; anything else must go through
-              // cook() below, which joins the pending cook (see debounceCook).
-              urlInfo.contentFinalized &&
               !cacheIsDisabledInResponseHeader(urlInfo) &&
+              !cacheIsDisabledInResponseHeader(urlInfoTargetedByCache) &&
               // a "?hot" request exists to bypass every cache, this one
               // included: it must be cooked, because cooking is what rewrites
               // its references so "?hot" cascades to the modified files below
@@ -344,7 +387,7 @@ export const devServerPluginServeSourceFiles = ({
               // signal registry throwing on duplicate ids). Re-cooking under
               // the normal request rewrites the references clean.
               !urlInfo.contentCookedForHotRequest &&
-              urlInfo.isValid();
+              memoryContentIsFresh();
             if (!servableFromMemory) {
               await urlInfo.cook({ request, reference });
               urlInfo.contentCookedForHotRequest =
@@ -402,19 +445,7 @@ export const devServerPluginServeSourceFiles = ({
                 ? { "served from memory cache": null }
                 : urlInfo.timing,
             };
-            const augmentResponseInfo = {
-              ...kitchen.context,
-              reference,
-              urlInfo,
-            };
-            kitchen.jsenvPluginsController.callHooks(
-              "augmentResponse",
-              augmentResponseInfo,
-              (returnValue) => {
-                response = composeTwoResponses(response, returnValue);
-              },
-            );
-            return response;
+            return augmentResponse(response);
           } catch (error) {
             const originalError = error ? error.cause || error : error;
             if (originalError.asResponse) {
@@ -492,6 +523,14 @@ export const devServerPluginServeSourceFiles = ({
                 "cache-control": "no-store",
               },
             };
+          } finally {
+            // What the request put on the url info context is for this
+            // request only: a cook happening later for another reason (the
+            // html holding an inline script is cooked again) must not see a
+            // stale "requestedUrl" and take the inline script for a direct
+            // request, which would make it pick the content of a previous
+            // reference (see jsenv:inline_content_fetcher).
+            forgetRequestFromContext(urlInfo.context);
           }
         },
       },
@@ -501,6 +540,15 @@ export const devServerPluginServeSourceFiles = ({
   return [devServerPluginRoutes, ...devServerJsenvPluginStore.allServerPlugins];
 };
 
+const forgetRequestFromContext = (context) => {
+  // own properties only: what is inherited from the owner context stays
+  for (const key of ["request", "requestedUrl", "reference"]) {
+    if (Object.hasOwn(context, key)) {
+      delete context[key];
+    }
+  }
+};
+
 const cacheIsDisabledInResponseHeader = (urlInfo) => {
   return (
     urlInfo.headers["cache-control"] === "no-store" ||

package/src/dev/start_dev_server.js

@@ -8,8 +8,13 @@ import {
   serverPluginCORS,
   startServer,
 } from "@jsenv/server";
-import { urlIsOrIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
+import {
+  urlIsOrIsInsideOf,
+  urlToFileSystemPath,
+  urlToRelativeUrl,
+} from "@jsenv/urls";
 import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 
 import { defaultRuntimeCompat } from "../build/build_params.js";
 import { createEventEmitter } from "../helpers/event_emitter.js";
@@ -50,6 +55,7 @@ const EXECUTED_BY_TEST_PLAN = process.argv.includes("--jsenv-test");
  * @param {boolean|object} [params.serverTiming={ minDuration: 0.5 }] - server-timing response headers; `minDuration` (ms) drops entries that took less (0 when run by the test plan, so tests see every entry).
  * @param {boolean|object} [params.ribbon=true] - The "ribbon" overlay marking the page as non-production. As an object: `text` (defaults to `"DEV"`), `color` (background, defaults to `"orange"`), `textColor` (defaults to dark or light depending on `color`), `href` (turns the ribbon into a link; only then does it capture clicks), `target` (defaults to `"_blank"`), `position` (`"top-right"` (default), `"top-left"`, `"bottom-right"`, `"bottom-left"` draw a diagonal corner ribbon; `"top"`, `"bottom"` draw a full width band), `htmlInclude` (defaults to `"/**\/*.html"`).
  * @param {boolean} [params.supervisor=true] - Script supervisor (better error reporting).
+ * @param {boolean} [params.modulepreload=false] - Send `Link: <url>; rel=modulepreload` response headers listing the static import graph of a page (as far as the graph knows it). Off by default, to enable once the server runs on http/2 or http/3: over http/1.1 the preloads take the 6 connections per origin ahead of the render-blocking scripts, and pages get slower (the why, with measures, in jsenv_plugin_modulepreload.js).
  * @param {boolean|object} [params.directoryListing=true] - Directory listing pages.
  * @param {object} [params.injections] - Values to inject into files, as `{ urlPattern: getInjections }`. Keys are url patterns relative to sourceDirectoryUrl (`"./index.html"`, `"**\/*.js"`), values are functions receiving `urlInfo` and returning (or resolving to) an object of placeholders to replace, named `__LIKE_THIS__` by convention. In JS the value is injected as a JS literal (a string brings its own quotes), everywhere else as-is so it can be concatenated: `href="__BACKEND_URL__/users/me"`. An html url pattern also covers what is inlined in that html, so `<script>window.backendUrl = __BACKEND_URL__;</script>` shares the value with every js file of the page. See `INJECTIONS.optional` and `INJECTIONS.global`.
  * @param {object} [params.runtimeCompat] - Target runtimes; warns when dev code wouldn't survive the build.
@@ -91,6 +97,7 @@ export const startDevServer = async ({
   sourceFilesConfig = {},
   clientAutoreload = true,
   clientAutoreloadOnServerRestart = true,
+  modulepreload = false,
   // server-timing response headers: devtools show how the time to answer is
   // spent (cook measures come from the kitchen, see urlInfo.timing). Entries
   // under minDuration are dropped so a human reads the measures that matter;
@@ -181,9 +188,12 @@ export const startDevServer = async ({
   }
 
   const logger = createLogger({ logLevel });
-  const startDevServerTask = createTaskLog("start dev server", {
-    disabled: !logger.levels.info,
-  });
+  const startDevServerTask = createTaskLog(
+    `start dev server for ${humanizeSourceDirectory(sourceDirectoryUrl)}`,
+    {
+      disabled: !logger.levels.info,
+    },
+  );
 
   const serverStopCallbackSet = new Set();
   const serverStopAbortController = new AbortController();
@@ -262,6 +272,7 @@ export const startDevServer = async ({
 
       clientAutoreload,
       clientAutoreloadOnServerRestart,
+      modulepreload,
       dependencyStatus: {
         dependencyProblemEventEmitter,
         getDependencyProblems: dependencyWatcher.getProblems,
@@ -366,3 +377,12 @@ export const startDevServer = async ({
     kitchenCache,
   };
 };
+
+// "./src/" when inside the current working directory, the full path otherwise
+const humanizeSourceDirectory = (sourceDirectoryUrl) => {
+  const cwdUrl = pathToFileURL(`${process.cwd()}/`).href;
+  if (urlIsOrIsInsideOf(sourceDirectoryUrl, cwdUrl)) {
+    return `./${urlToRelativeUrl(sourceDirectoryUrl, cwdUrl)}`;
+  }
+  return urlToFileSystemPath(sourceDirectoryUrl);
+};