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

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

@@ -12,38 +12,55 @@
  */
 
 import { createRequire } from "node:module"
-import { readFileSync, urlToFilename } from "@jsenv/filesystem"
+import { readFileSync, urlToFilename, urlIsInsideOf } from "@jsenv/filesystem"
 
 import { requireBabelPlugin } from "@jsenv/babel-plugins"
 import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_composition_v3.js"
+import { fetchOriginalUrlInfo } from "@jsenv/utils/graph/fetch_original_url_info.js"
 
-import { fetchOriginalUrlInfo } from "../fetch_original_url_info.js"
+import { jsenvRootDirectoryUrl } from "@jsenv/core/src/jsenv_root_directory_url.js"
 import { babelPluginTransformImportMetaUrl } from "./helpers/babel_plugin_transform_import_meta_url.js"
-import { jsenvPluginScriptTypeModuleAsClassic } from "./jsenv_plugin_script_type_module_as_classic.js"
-import { jsenvPluginWorkersTypeModuleAsClassic } from "./jsenv_plugin_workers_type_module_as_classic.js"
+import { jsenvPluginAsJsClassicHtml } from "./jsenv_plugin_script_type_module_as_classic.js"
+import { jsenvPluginAsJsClassicWorkers } from "./jsenv_plugin_as_js_classic_workers.js"
 
 const require = createRequire(import.meta.url)
 
-export const jsenvPluginAsJsClassic = ({ systemJsInjection }) => {
-  const systemJsClientFileUrl = new URL("./client/s.js", import.meta.url).href
+export const jsenvPluginAsJsClassic = ({
+  rootDirectoryUrl,
+  systemJsInjection,
+}) => {
+  const preferSourceFiles =
+    rootDirectoryUrl === jsenvRootDirectoryUrl ||
+    urlIsInsideOf(rootDirectoryUrl, jsenvRootDirectoryUrl)
+  const systemJsClientFileUrl = preferSourceFiles
+    ? new URL("./client/s.js", import.meta.url).href
+    : new URL("./dist/s.js", import.meta.url).href
 
   return [
-    asJsClassic({ systemJsInjection, systemJsClientFileUrl }),
-    jsenvPluginScriptTypeModuleAsClassic({
+    jsenvPluginAsJsClassicConversion({
+      systemJsInjection,
+      systemJsClientFileUrl,
+    }),
+    jsenvPluginAsJsClassicHtml({
       systemJsInjection,
       systemJsClientFileUrl,
       generateJsClassicFilename,
     }),
-    jsenvPluginWorkersTypeModuleAsClassic({
+    jsenvPluginAsJsClassicWorkers({
       generateJsClassicFilename,
     }),
   ]
 }
 
-const asJsClassic = ({ systemJsInjection, systemJsClientFileUrl }) => {
+// propagate ?as_js_classic to referenced urls
+// and perform the conversion during fetchUrlContent
+const jsenvPluginAsJsClassicConversion = ({
+  systemJsInjection,
+  systemJsClientFileUrl,
+}) => {
   const propagateJsClassicSearchParam = (reference, context) => {
     const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl)
     if (
@@ -60,9 +77,8 @@ const asJsClassic = ({ systemJsInjection, systemJsClientFileUrl }) => {
   }
 
   return {
-    name: "jsenv:as_js_classic",
+    name: "jsenv:as_js_classic_conversion",
     appliesDuring: "*",
-    // forward ?as_js_classic to referenced urls
     redirectUrl: {
       // We want to propagate transformation of js module to js classic to:
       // - import specifier (static/dynamic import + re-export)

package/src/plugins/transpilation/as_js_classic/{jsenv_plugin_workers_type_module_as_classic.js → jsenv_plugin_as_js_classic_workers.js}

@@ -1,6 +1,6 @@
 import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
 
-export const jsenvPluginWorkersTypeModuleAsClassic = ({
+export const jsenvPluginAsJsClassicWorkers = ({
   generateJsClassicFilename,
 }) => {
   const updateReference = (reference) => {
@@ -19,7 +19,7 @@ export const jsenvPluginWorkersTypeModuleAsClassic = ({
   }
 
   return {
-    name: "jsenv:workers_type_module_as_classic",
+    name: "jsenv:as_js_classic_workers",
     appliesDuring: "*",
     redirectUrl: {
       js_url_specifier: (reference, context) => {

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

@@ -14,22 +14,19 @@ import {
 import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
 import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
 
-export const jsenvPluginScriptTypeModuleAsClassic = ({
+export const jsenvPluginAsJsClassicHtml = ({
   systemJsInjection,
   systemJsClientFileUrl,
   generateJsClassicFilename,
 }) => {
   return {
-    name: "jsenv:script_type_module_as_classic",
+    name: "jsenv:as_js_classic_html",
     appliesDuring: "*",
     transformUrlContent: {
       html: async (urlInfo, context) => {
-        if (
-          context.isSupportedOnCurrentClients("script_type_module") &&
-          context.isSupportedOnCurrentClients("import_dynamic")
-        ) {
-          return null
-        }
+        const shouldTransformScriptTypeModule =
+          !context.isSupportedOnCurrentClients("script_type_module") ||
+          !context.isSupportedOnCurrentClients("import_dynamic")
         const htmlAst = parseHtmlString(urlInfo.content)
         const preloadAsScriptNodes = []
         const modulePreloadNodes = []
@@ -47,8 +44,8 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           }
           if (rel === "preload") {
             const asAttribute = getHtmlNodeAttributeByName(node, "as")
-            const as = asAttribute ? asAttribute.value : undefined
-            if (as === "script") {
+            const asValue = asAttribute ? asAttribute.value : undefined
+            if (asValue === "script") {
               preloadAsScriptNodes.push(node)
             }
             return
@@ -74,30 +71,9 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
           visitScriptNodes(node)
         })
 
-        const classicScriptUrls = []
-        const moduleScriptUrls = []
-        classicScriptNodes.forEach((classicScriptNode) => {
-          const srcAttribute = getHtmlNodeAttributeByName(
-            classicScriptNode,
-            "src",
-          )
-          if (srcAttribute) {
-            const url = new URL(srcAttribute.value, urlInfo.url).href
-            classicScriptUrls.push(url)
-          }
-        })
-        moduleScriptNodes.forEach((moduleScriptNode) => {
-          const srcAttribute = getHtmlNodeAttributeByName(
-            moduleScriptNode,
-            "src",
-          )
-          if (srcAttribute) {
-            const url = new URL(srcAttribute.value, urlInfo.url).href
-            moduleScriptUrls.push(url)
-          }
-        })
-
+        const actions = []
         const jsModuleUrls = []
+        const convertedUrls = []
         const getReferenceAsJsClassic = async (
           reference,
           {
@@ -108,19 +84,20 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
             cookIt = false,
           } = {},
         ) => {
+          const newReferenceProps = {
+            expectedType: "js_classic",
+            specifier: injectQueryParamsIntoSpecifier(reference.specifier, {
+              as_js_classic: "",
+            }),
+            filename: generateJsClassicFilename(reference.url),
+          }
           const [newReference, newUrlInfo] = context.referenceUtils.update(
             reference,
-            {
-              expectedType: "js_classic",
-              specifier: injectQueryParamsIntoSpecifier(reference.specifier, {
-                as_js_classic: "",
-              }),
-              filename: generateJsClassicFilename(reference.url),
-            },
+            newReferenceProps,
           )
-          const jsModuleUrl = newUrlInfo.url
-          if (!jsModuleUrls.includes(jsModuleUrl)) {
-            jsModuleUrls.push(newUrlInfo.url)
+          const convertedUrl = newUrlInfo.url
+          if (!convertedUrls.includes(convertedUrl)) {
+            convertedUrls.push(convertedUrl)
           }
           if (cookIt) {
             // during dev it means js modules will be cooked before server sends the HTML
@@ -128,123 +105,178 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
             // - during dev script_type_module are supported (dev use a recent browser)
             // - even if browser is not supported it still works it's jus a bit slower
             //   because it needs to decide if systemjs will be injected or not
-            await context.cook({
-              reference: newReference,
-              urlInfo: newUrlInfo,
-            })
+            await context.cook(newUrlInfo, { reference: newReference })
           }
           return [newReference, newUrlInfo]
         }
-        const actions = []
-        preloadAsScriptNodes.forEach((preloadAsScriptNode) => {
-          const hrefAttribute = getHtmlNodeAttributeByName(
-            preloadAsScriptNode,
-            "href",
+
+        classicScriptNodes.forEach((classicScriptNode) => {
+          const srcAttribute = getHtmlNodeAttributeByName(
+            classicScriptNode,
+            "src",
           )
-          const href = hrefAttribute.value
-          const url = new URL(href, urlInfo.url).href
-          const expectedScriptType = moduleScriptUrls.includes(url)
-            ? "module"
-            : "classic"
-          // keep in mind:
-          // when the url is not referenced by a <script type="module">
-          // we assume we want to preload "classic" but it might not be the case
-          // but it's unlikely to happen and people should use "modulepreload" in that case anyway
-          if (expectedScriptType === "module") {
-            actions.push(async () => {
-              const reference =
-                context.referenceUtils.findByGeneratedSpecifier(href)
-              const [newReference] = await getReferenceAsJsClassic(reference)
-              assignHtmlNodeAttributes(preloadAsScriptNode, {
-                href: newReference.generatedSpecifier,
+          if (srcAttribute) {
+            const reference = urlInfo.references.find(
+              (ref) =>
+                ref.generatedSpecifier === srcAttribute.value &&
+                ref.type === "script_src",
+            )
+            const urlObject = new URL(reference.url)
+            if (urlObject.searchParams.has("as_js_classic")) {
+              const convertedUrl = urlObject.href
+              convertedUrls.push(convertedUrl)
+              urlObject.searchParams.delete("as_js_classic")
+              const jsModuleUrl = urlObject.href
+              jsModuleUrls.push(jsModuleUrl)
+              actions.push(async () => {
+                const urlInfo = context.urlGraph.getUrlInfo(convertedUrl)
+                await context.cook(urlInfo, { reference })
               })
-              removeHtmlNodeAttributeByName(preloadAsScriptNode, "crossorigin")
-            })
+            }
           }
         })
-        modulePreloadNodes.forEach((modulePreloadNode) => {
-          const hrefAttribute = getHtmlNodeAttributeByName(
-            modulePreloadNode,
-            "href",
-          )
-          const href = hrefAttribute.value
-          actions.push(async () => {
-            const reference =
-              context.referenceUtils.findByGeneratedSpecifier(href)
-            const [newReference] = await getReferenceAsJsClassic(reference)
-            assignHtmlNodeAttributes(modulePreloadNode, {
-              rel: "preload",
-              as: "script",
-              href: newReference.generatedSpecifier,
-            })
-          })
-        })
         moduleScriptNodes.forEach((moduleScriptNode) => {
           const srcAttribute = getHtmlNodeAttributeByName(
             moduleScriptNode,
             "src",
           )
           if (srcAttribute) {
+            const reference = urlInfo.references.find(
+              (ref) =>
+                ref.generatedSpecifier === srcAttribute.value &&
+                ref.type === "script_src" &&
+                ref.expectedType === "js_module",
+            )
+            jsModuleUrls.push(reference.url)
+            if (shouldTransformScriptTypeModule) {
+              actions.push(async () => {
+                const [newReference] = await getReferenceAsJsClassic(
+                  reference,
+                  {
+                    cookIt: true,
+                  },
+                )
+                removeHtmlNodeAttributeByName(moduleScriptNode, "type")
+                srcAttribute.value = newReference.generatedSpecifier
+              })
+            }
+            return
+          }
+          if (shouldTransformScriptTypeModule) {
+            const textNode = getHtmlNodeTextNode(moduleScriptNode)
             actions.push(async () => {
-              const specifier = srcAttribute.value
-              const reference =
-                context.referenceUtils.findByGeneratedSpecifier(specifier)
-              const [newReference] = await getReferenceAsJsClassic(reference, {
-                cookIt: true,
+              const { line, column, lineEnd, columnEnd, isOriginal } =
+                htmlNodePosition.readNodePosition(moduleScriptNode, {
+                  preferOriginal: true,
+                })
+              let inlineScriptUrl = generateInlineContentUrl({
+                url: urlInfo.url,
+                extension: ".js",
+                line,
+                column,
+                lineEnd,
+                columnEnd,
               })
+              const [inlineReference] = context.referenceUtils.foundInline({
+                node: moduleScriptNode,
+                type: "script_src",
+                expectedType: "js_module",
+                isOriginalPosition: isOriginal,
+                // we remove 1 to the line because imagine the following html:
+                // <script>console.log('ok')</script>
+                // -> content starts same line as <script>
+                specifierLine: line - 1,
+                specifierColumn: column,
+                specifier: inlineScriptUrl,
+                contentType: "application/javascript",
+                content: textNode.value,
+              })
+              const [, newUrlInfo] = await getReferenceAsJsClassic(
+                inlineReference,
+                { cookIt: true },
+              )
               removeHtmlNodeAttributeByName(moduleScriptNode, "type")
-              srcAttribute.value = newReference.generatedSpecifier
+              setHtmlNodeGeneratedText(moduleScriptNode, {
+                generatedText: newUrlInfo.content,
+                generatedBy: "jsenv:as_js_classic_html",
+              })
             })
-            return
           }
-          const textNode = getHtmlNodeTextNode(moduleScriptNode)
-          actions.push(async () => {
-            const { line, column, lineEnd, columnEnd, isOriginal } =
-              htmlNodePosition.readNodePosition(moduleScriptNode, {
-                preferOriginal: true,
+        })
+        if (shouldTransformScriptTypeModule) {
+          preloadAsScriptNodes.forEach((preloadAsScriptNode) => {
+            const hrefAttribute = getHtmlNodeAttributeByName(
+              preloadAsScriptNode,
+              "href",
+            )
+            const href = hrefAttribute.value
+            const reference = urlInfo.references.find(
+              (ref) =>
+                ref.generatedSpecifier === href &&
+                ref.type === "link_href" &&
+                ref.expectedType === undefined,
+            )
+            const expectedScriptType = jsModuleUrls.includes(reference.url)
+              ? "module"
+              : "classic"
+            if (expectedScriptType === "module") {
+              actions.push(async () => {
+                // reference modified by <script type="module"> conversion
+                let newReference
+                if (reference.next) {
+                  newReference = reference.next
+                } else {
+                  // when the url is not referenced by a <script type="module">
+                  // we assume we want to preload "classic" but it might not be the case
+                  // but it's unlikely to happen and people should use "modulepreload" in that case anyway
+                  ;[newReference] = await getReferenceAsJsClassic(reference)
+                }
+                assignHtmlNodeAttributes(preloadAsScriptNode, {
+                  href: newReference.generatedSpecifier,
+                })
+                removeHtmlNodeAttributeByName(
+                  preloadAsScriptNode,
+                  "crossorigin",
+                )
               })
-            let inlineScriptUrl = generateInlineContentUrl({
-              url: urlInfo.url,
-              extension: ".js",
-              line,
-              column,
-              lineEnd,
-              columnEnd,
-            })
-            const [inlineReference] = context.referenceUtils.foundInline({
-              node: moduleScriptNode,
-              type: "script_src",
-              expectedType: "js_module",
-              isOriginalPosition: isOriginal,
-              // we remove 1 to the line because imagine the following html:
-              // <script>console.log('ok')</script>
-              // -> content starts same line as <script>
-              specifierLine: line - 1,
-              specifierColumn: column,
-              specifier: inlineScriptUrl,
-              contentType: "application/javascript",
-              content: textNode.value,
-            })
-            const [, newUrlInfo] = await getReferenceAsJsClassic(
-              inlineReference,
-              { cookIt: true },
+            }
+          })
+          modulePreloadNodes.forEach((modulePreloadNode) => {
+            const hrefAttribute = getHtmlNodeAttributeByName(
+              modulePreloadNode,
+              "href",
+            )
+            const href = hrefAttribute.value
+            const reference = urlInfo.references.find(
+              (ref) =>
+                ref.generatedSpecifier === href &&
+                ref.type === "link_href" &&
+                ref.expectedType === "js_module",
             )
-            removeHtmlNodeAttributeByName(moduleScriptNode, "type")
-            setHtmlNodeGeneratedText(moduleScriptNode, {
-              generatedText: newUrlInfo.content,
-              generatedBy: "jsenv:script_type_module_as_classic",
+            actions.push(async () => {
+              let newReference
+              if (reference.next) {
+                newReference = reference.next
+              } else {
+                ;[newReference] = await getReferenceAsJsClassic(reference)
+              }
+              assignHtmlNodeAttributes(modulePreloadNode, {
+                rel: "preload",
+                as: "script",
+                href: newReference.generatedSpecifier,
+              })
             })
           })
-        })
+        }
 
         if (actions.length === 0) {
           return null
         }
         await Promise.all(actions.map((action) => action()))
         if (systemJsInjection) {
-          const needsSystemJs = jsModuleUrls.some(
-            (jsModuleUrl) =>
-              context.urlGraph.getUrlInfo(jsModuleUrl).data.jsClassicFormat ===
+          const needsSystemJs = convertedUrls.some(
+            (convertedUrl) =>
+              context.urlGraph.getUrlInfo(convertedUrl).data.jsClassicFormat ===
               "system",
           )
           if (needsSystemJs) {
@@ -258,7 +290,7 @@ export const jsenvPluginScriptTypeModuleAsClassic = ({
               createHtmlNode({
                 "tagName": "script",
                 "src": systemJsReference.generatedSpecifier,
-                "injected-by": "jsenv:script_type_module_as_classic",
+                "injected-by": "jsenv:as_js_classic_html",
               }),
             )
           }

package/src/plugins/transpilation/babel/jsenv_plugin_babel.js

@@ -7,7 +7,10 @@ import { babelPluginNewStylesheetAsJsenvImport } from "./new_stylesheet/babel_pl
 import { babelPluginGlobalThisAsJsenvImport } from "./global_this/babel_plugin_global_this_as_jsenv_import.js"
 import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./regenerator_runtime/babel_plugin_regenerator_runtime_as_jsenv_import.js"
 
-export const jsenvPluginBabel = ({ getCustomBabelPlugins } = {}) => {
+export const jsenvPluginBabel = ({
+  getCustomBabelPlugins,
+  babelHelpersAsImport = true,
+} = {}) => {
   const transformWithBabel = async (urlInfo, context) => {
     const isJsModule = urlInfo.type === "js_module"
     const isWorker = urlInfo.subtype === "worker"
@@ -55,7 +58,7 @@ export const jsenvPluginBabel = ({ getCustomBabelPlugins } = {}) => {
       Object.assign(babelPluginStructure, getCustomBabelPlugins(context))
     }
 
-    if (isJsModule) {
+    if (isJsModule && babelHelpersAsImport) {
       if (!isSupported("global_this")) {
         babelPluginStructure["global-this-as-jsenv-import"] = [
           babelPluginGlobalThisAsJsenvImport,

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

@@ -14,8 +14,7 @@ import { urlToFilename } from "@jsenv/filesystem"
 
 import { injectQueryParams } from "@jsenv/utils/urls/url_utils.js"
 import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
-
-import { fetchOriginalUrlInfo } from "../fetch_original_url_info.js"
+import { fetchOriginalUrlInfo } from "@jsenv/utils/graph/fetch_original_url_info.js"
 
 export const jsenvPluginImportAssertions = () => {
   const updateReference = (reference, searchParam) => {

package/src/plugins/transpilation/jsenv_plugin_transpilation.js

@@ -14,11 +14,13 @@ import { jsenvPluginBabel } from "./babel/jsenv_plugin_babel.js"
 import { jsenvPluginTopLevelAwait } from "./jsenv_plugin_top_level_await.js"
 
 export const jsenvPluginTranspilation = ({
+  rootDirectoryUrl,
   importAssertions = true,
   css = true,
   jsModuleAsJsClassic = true,
   systemJsInjection = true,
   topLevelAwait = true,
+  babelHelpersAsImport = true,
   getCustomBabelPlugins,
 }) => {
   return [
@@ -28,13 +30,14 @@ export const jsenvPluginTranspilation = ({
     jsenvPluginBabel({
       topLevelAwait,
       getCustomBabelPlugins,
+      babelHelpersAsImport,
     }),
     // but the conversion from js_module to js_classic
     // we want to do it after bundling
     // so the build function will disable jsModuleAsJsClassic during build
     // and enable it manually during postbuild
     ...(jsModuleAsJsClassic
-      ? [jsenvPluginAsJsClassic({ systemJsInjection })]
+      ? [jsenvPluginAsJsClassic({ rootDirectoryUrl, systemJsInjection })]
       : []),
     // topLevelAwait must come after js_module_as_js_classic because it's related to the module format
     // so we want to wait to know the module format before transforming things related to top level await

package/src/test/execute_plan.js

@@ -25,11 +25,7 @@ import { run } from "@jsenv/core/src/execute/run.js"
 
 import { ensureGlobalGc } from "./gc.js"
 import { generateExecutionSteps } from "./execution_steps.js"
-import {
-  formatExecuting,
-  formatExecutionResult,
-  createSummaryLog,
-} from "./logs_file_execution.js"
+import { createExecutionLog, createSummaryLog } from "./logs_file_execution.js"
 
 export const executePlan = async (
   plan,
@@ -38,6 +34,7 @@ export const executePlan = async (
     handleSIGINT,
     logger,
     logSummary,
+    logTimeUsage,
     logMemoryHeapUsage,
     logFileRelativeUrl,
     completedExecutionLogMerging,
@@ -326,17 +323,29 @@ export const executePlan = async (
           runtimeVersion,
           executionIndex,
           executionParams,
+          startMs: Date.now(),
+          executionResult: {
+            status: "executing",
+          },
         }
         let spinner
         if (executionSpinner) {
-          spinner = startSpinner({
-            log: executionLog,
-            text: formatExecuting(beforeExecutionInfo, {
+          const renderSpinnerText = () =>
+            createExecutionLog(beforeExecutionInfo, {
               counters,
+              ...(logTimeUsage
+                ? {
+                    timeEllapsed: Date.now() - startMs,
+                  }
+                : {}),
               ...(logMemoryHeapUsage
                 ? { memoryHeap: memoryUsage().heapUsed }
                 : {}),
-            }),
+            })
+          spinner = startSpinner({
+            log: executionLog,
+            text: renderSpinnerText(),
+            update: renderSpinnerText,
           })
         }
         beforeExecutionCallback(beforeExecutionInfo)
@@ -368,10 +377,15 @@ export const executePlan = async (
           }
         }
         counters.done++
-        if (fileRelativeUrl in report === false) {
-          report[fileRelativeUrl] = {}
+        const fileReport = report[fileRelativeUrl]
+        if (fileReport) {
+          fileReport[executionName] = executionResult
+        } else {
+          report[fileRelativeUrl] = {
+            [executionName]: executionResult,
+          }
         }
-        report[fileRelativeUrl][executionName] = executionResult
+
         const afterExecutionInfo = {
           ...beforeExecutionInfo,
           endMs: Date.now(),
@@ -392,9 +406,14 @@ export const executePlan = async (
           global.gc()
         }
         if (executionLogsEnabled) {
-          let log = formatExecutionResult(afterExecutionInfo, {
+          let log = createExecutionLog(afterExecutionInfo, {
             completedExecutionLogAbbreviation,
             counters,
+            ...(logTimeUsage
+              ? {
+                  timeEllapsed: Date.now() - startMs,
+                }
+              : {}),
             ...(logMemoryHeapUsage
               ? { memoryHeap: memoryUsage().heapUsed }
               : {}),

package/src/test/execute_test_plan.js

@@ -42,6 +42,7 @@ export const executeTestPlan = async ({
   handleSIGINT = true,
   logLevel = "info",
   logSummary = true,
+  logTimeUsage = false,
   logMemoryHeapUsage = false,
   logFileRelativeUrl = ".jsenv/test_plan_debug.txt",
   completedExecutionLogAbbreviation = false,
@@ -148,6 +149,7 @@ export const executeTestPlan = async ({
     logger,
     logLevel,
     logSummary,
+    logTimeUsage,
     logMemoryHeapUsage,
     logFileRelativeUrl,
     completedExecutionLogMerging,