@jsenv/core 24.2.1 → 24.3.3

package/src/internal/{runtime/createNodeRuntime/createNodeExecutionWithDynamicImport.js → node_runtime/node_execution_dynamic_import.js}

@@ -2,10 +2,33 @@ import { resolveUrl } from "@jsenv/filesystem"
 
 import { unevalException } from "@jsenv/core/src/internal/unevalException.js"
 import { measureAsyncFnPerf } from "@jsenv/core/src/internal/perf_node.js"
+import { startObservingPerformances } from "./node_execution_performance.js"
 
-export const createNodeExecutionWithDynamicImport = ({
+export const execute = async ({
   projectDirectoryUrl,
+  fileRelativeUrl,
+  // do not log in the console
+  // because error handling becomes responsability
+  // of node code launching node process
+  // it avoids seeing error in runtime logs during testing
+  errorExposureInConsole = false,
+  collectCoverage,
+  measurePerformance,
+  collectPerformance,
 }) => {
+  let finalizeExecutionResult = (result) => result
+
+  if (collectPerformance) {
+    const getPerformance = startObservingPerformances()
+    finalizeExecutionResult = async (executionResult) => {
+      const performance = await getPerformance()
+      return {
+        ...executionResult,
+        performance,
+      }
+    }
+  }
+
   const executeFile = async (
     specifier,
     { measurePerformance, errorExposureInConsole = false } = {},
@@ -13,7 +36,6 @@ export const createNodeExecutionWithDynamicImport = ({
     // we can't dynamically import from compileServerOrigin I guess
     // we have to use the filesystem
     const fileUrl = resolveUrl(specifier, projectDirectoryUrl)
-
     const importWithDynamicImport = async () => {
       try {
         const status = "completed"
@@ -33,14 +55,20 @@ export const createNodeExecutionWithDynamicImport = ({
         }
       }
     }
-
     if (measurePerformance) {
       return measureAsyncFnPerf(importWithDynamicImport, "jsenv_file_import")
     }
     return importWithDynamicImport()
   }
 
-  return {
-    executeFile,
-  }
+  const executionResult = await executeFile(fileRelativeUrl, {
+    errorExposureInConsole,
+    measurePerformance,
+    collectCoverage,
+  })
+
+  return finalizeExecutionResult({
+    ...executionResult,
+    indirectCoverage: global.__indirectCoverage__,
+  })
 }

package/src/internal/node_runtime/node_execution_performance.js

@@ -0,0 +1,67 @@
+import { PerformanceObserver, performance } from "node:perf_hooks"
+
+export const startObservingPerformances = () => {
+  const measureEntries = []
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
+  const perfObserver = new PerformanceObserver(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
+      list,
+    ) => {
+      const perfMeasureEntries = list.getEntriesByType("measure")
+      measureEntries.push(...perfMeasureEntries)
+    },
+  )
+  perfObserver.observe({
+    entryTypes: ["measure"],
+  })
+  return async () => {
+    // wait for node to call the performance observer
+    await new Promise((resolve) => {
+      setTimeout(resolve)
+    })
+    performance.clearMarks()
+    perfObserver.disconnect()
+    return {
+      ...readNodePerformance(),
+      measures: measuresFromMeasureEntries(measureEntries),
+    }
+  }
+}
+
+const readNodePerformance = () => {
+  const nodePerformance = {
+    nodeTiming: asPlainObject(performance.nodeTiming),
+    timeOrigin: performance.timeOrigin,
+    eventLoopUtilization: performance.eventLoopUtilization(),
+  }
+  return nodePerformance
+}
+
+// remove getters that cannot be stringified
+const asPlainObject = (objectWithGetters) => {
+  const objectWithoutGetters = {}
+  Object.keys(objectWithGetters).forEach((key) => {
+    objectWithoutGetters[key] = objectWithGetters[key]
+  })
+  return objectWithoutGetters
+}
+
+const measuresFromMeasureEntries = (measureEntries) => {
+  const measures = {}
+  // Sort to ensure measures order is predictable
+  // It seems to be already predictable on Node 16+ but
+  // it's not the case on Node 14.
+  measureEntries.sort((a, b) => {
+    return a.startTime - b.startTime
+  })
+  measureEntries.forEach(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
+      perfMeasureEntry,
+    ) => {
+      measures[perfMeasureEntry.name] = perfMeasureEntry.duration
+    },
+  )
+  return measures
+}

package/src/internal/{runtime/createNodeRuntime/createNodeExecutionWithSystemJs.js → node_runtime/node_execution_systemjs.js}

@@ -1,38 +1,48 @@
 import { resolveUrl } from "@jsenv/filesystem"
 
 import { measureAsyncFnPerf } from "@jsenv/core/src/internal/perf_node.js"
+import { startObservingPerformances } from "./node_execution_performance.js"
 import { unevalException } from "@jsenv/core/src/internal/unevalException.js"
-import { memoize } from "../../memoize.js"
-import { installNodeErrorStackRemapping } from "../../error-stack-remapping/installNodeErrorStackRemapping.js"
-import { fetchSource } from "./fetchSource.js"
-import { createNodeSystem } from "./createNodeSystem.js"
 
-const memoizedCreateNodeSystem = memoize(createNodeSystem)
+import { installNodeErrorStackRemapping } from "@jsenv/core/src/internal/error-stack-remapping/installNodeErrorStackRemapping.js"
+import { fetchSource } from "@jsenv/core/src/internal/node_runtime/fetchSource.js"
+import { createNodeSystem } from "@jsenv/core/src/internal/node_runtime/node_system.js"
 
-export const createNodeExecutionWithSystemJs = ({
+export const execute = async ({
   projectDirectoryUrl,
   compileServerOrigin,
+  fileRelativeUrl,
   outDirectoryRelativeUrl,
   compileId,
   importDefaultExtension,
+  // do not log in the console
+  // because error handling becomes responsability
+  // of node code launching node process
+  // it avoids seeing error in runtime logs during testing
+  errorExposureInConsole = false,
+  collectCoverage,
+  measurePerformance,
+  collectPerformance,
 }) => {
+  let finalizeExecutionResult = (result) => result
+
+  if (collectPerformance) {
+    const getPerformance = startObservingPerformances()
+    finalizeExecutionResult = async (executionResult) => {
+      const performance = await getPerformance()
+      return {
+        ...executionResult,
+        performance,
+      }
+    }
+  }
+
   const { getErrorOriginalStackString } = installNodeErrorStackRemapping({
     projectDirectoryUrl,
   })
 
   const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
 
-  const importFile = async (specifier) => {
-    const nodeSystem = await memoizedCreateNodeSystem({
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      fetchSource,
-      importDefaultExtension,
-    })
-    return makePromiseKeepNodeProcessAlive(nodeSystem.import(specifier))
-  }
-
   const errorTransformer = async (error) => {
     // code can throw something else than an error
     // in that case return it unchanged
@@ -52,7 +62,7 @@ export const createNodeExecutionWithSystemJs = ({
       `${compileServerOrigin}/${compileDirectoryRelativeUrl}`,
     )
 
-    const nodeSystem = await memoizedCreateNodeSystem({
+    const nodeSystem = await createNodeSystem({
       projectDirectoryUrl,
       compileServerOrigin,
       compileDirectoryRelativeUrl,
@@ -88,18 +98,22 @@ export const createNodeExecutionWithSystemJs = ({
         }
       }
     }
-
     if (measurePerformance) {
       return measureAsyncFnPerf(importWithSystemJs, "jsenv_file_import")
     }
     return importWithSystemJs()
   }
 
-  return {
-    compileDirectoryRelativeUrl,
-    importFile,
-    executeFile,
-  }
+  const executionResult = await executeFile(fileRelativeUrl, {
+    errorExposureInConsole,
+    measurePerformance,
+    collectCoverage,
+  })
+
+  return finalizeExecutionResult({
+    ...executionResult,
+    indirectCoverage: global.__indirectCoverage__,
+  })
 }
 
 const makePromiseKeepNodeProcessAlive = async (promise) => {

package/src/internal/{runtime/createNodeRuntime/createNodeSystem.js → node_runtime/node_system.js}

@@ -8,14 +8,14 @@ import { urlToFileSystemPath, resolveUrl } from "@jsenv/filesystem"
 import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
 
 import { createImportResolverForNode } from "@jsenv/core/src/internal/import-resolution/import-resolver-node.js"
-import { require } from "../../require.js"
-import "../s.js"
+import { require } from "../require.js"
+import "../runtime/s.js"
 import {
   fromFunctionReturningNamespace,
   getJavaScriptModuleResponseError,
   fromFunctionReturningRegisteredModule,
-} from "../module-registration.js"
-import { valueInstall } from "../valueInstall.js"
+} from "../runtime/module-registration.js"
+import { valueInstall } from "../runtime/valueInstall.js"
 import { evalSource } from "./evalSource.js"
 
 export const createNodeSystem = async ({

package/src/internal/runtime/computeCompileIdFromGroupId.js

@@ -1,4 +1,5 @@
 import { createDetailedMessage } from "@jsenv/logger"
+
 import { COMPILE_ID_OTHERWISE } from "../CONSTANTS.js"
 
 export const computeCompileIdFromGroupId = ({ groupId, groupMap }) => {

package/src/internal/runtime/resolveGroup.js

@@ -1,4 +1,4 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
+import { findHighestVersion } from "../semantic_versioning/index.js"
 
 export const resolveGroup = ({ name, version }, groupMap) => {
   return Object.keys(groupMap).find((compileIdCandidate) => {

package/src/internal/runtime/resolveRuntimeGroup.js

@@ -1,6 +1,6 @@
 /* eslint-env browser, node */
-import { detectBrowser } from "./detectBrowser/detectBrowser.js"
-import { detectNode } from "./detectNode/detectNode.js"
+import { detectBrowser } from "../browser_detection/browser_detection.js"
+import { detectNode } from "../node_runtime/detectNode.js"
 import { resolveGroup } from "./resolveGroup.js"
 
 export const resolveRuntimeGroup = (groupMap) => {

package/src/launchBrowser.js

@@ -11,9 +11,9 @@ import { memoize } from "@jsenv/filesystem"
 
 import { fetchUrl } from "./internal/fetchUrl.js"
 import { validateResponse } from "./internal/response_validation.js"
-import { trackPageToNotify } from "./internal/browser-launcher/trackPageToNotify.js"
-import { createSharing } from "./internal/browser-launcher/createSharing.js"
-import { executeHtmlFile } from "./internal/browser-launcher/executeHtmlFile.js"
+import { trackPageToNotify } from "./internal/browser_launcher/trackPageToNotify.js"
+import { createSharing } from "./internal/browser_launcher/createSharing.js"
+import { executeHtmlFile } from "./internal/browser_launcher/executeHtmlFile.js"
 import {
   PLAYWRIGHT_CHROMIUM_VERSION,
   PLAYWRIGHT_FIREFOX_VERSION,
@@ -32,6 +32,7 @@ chromiumRuntime.launch = async ({
 
   projectDirectoryUrl,
   compileServerOrigin,
+  compileServerId,
   outDirectoryRelativeUrl,
 
   collectPerformance,
@@ -106,10 +107,12 @@ chromiumRuntime.launch = async ({
   }
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    runtime: chromiumRuntime,
     browserServerLogLevel,
 
     projectDirectoryUrl,
     compileServerOrigin,
+    compileServerId,
     outDirectoryRelativeUrl,
 
     collectPerformance,
@@ -184,6 +187,7 @@ firefoxRuntime.launch = async ({
   const browser = await browserPromise
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    runtime: firefoxRuntime,
     launchBrowserOperation,
     browserServerLogLevel,
 
@@ -262,6 +266,7 @@ webkitRuntime.launch = async ({
   const browser = await browserPromise
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    runtime: webkitRuntime,
     launchBrowserOperation,
     browserServerLogLevel,
 
@@ -391,8 +396,10 @@ const stopBrowser = async (browser) => {
 const browserToRuntimeHooks = (
   browser,
   {
+    runtime,
     projectDirectoryUrl,
     compileServerOrigin,
+    compileServerId,
     outDirectoryRelativeUrl,
 
     collectPerformance,
@@ -461,10 +468,12 @@ const browserToRuntimeHooks = (
     stoppedCallbackList.add(stopTrackingToNotify)
 
     const result = await executeHtmlFile(fileRelativeUrl, {
+      runtime,
       executeOperation,
 
       projectDirectoryUrl,
       compileServerOrigin,
+      compileServerId,
       outDirectoryRelativeUrl,
 
       page,

package/src/launchNode.js

@@ -3,7 +3,8 @@ import { loggerToLogLevel } from "@jsenv/logger"
 
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 import { escapeRegexpSpecialCharacters } from "./internal/escapeRegexpSpecialCharacters.js"
-import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
+import { createControllableNodeProcess } from "./internal/node_launcher/createControllableNodeProcess.js"
+import { getNodeRuntimeReport } from "./internal/node_launcher/node_runtime_report.js"
 
 export const nodeRuntime = {
   name: "node",
@@ -15,6 +16,7 @@ nodeRuntime.launch = async ({
   logProcessCommand,
 
   projectDirectoryUrl,
+  compileServerId,
   compileServerOrigin,
   outDirectoryRelativeUrl,
 
@@ -34,7 +36,7 @@ nodeRuntime.launch = async ({
   stdout,
   stderr,
   stopAfterExecute,
-  canUseNativeModuleSystem,
+  forceSystemJs,
 
   remap = true,
 }) => {
@@ -103,7 +105,6 @@ nodeRuntime.launch = async ({
 
       fileRelativeUrl,
       executionId,
-      canUseNativeModuleSystem,
       exitAfterAction: stopAfterExecute,
 
       measurePerformance,
@@ -114,11 +115,39 @@ nodeRuntime.launch = async ({
       remap,
     }
 
-    let executionResult = await requestActionOnChildProcess({
-      signal,
-      actionType: "execute-using-dynamic-import-fallback-on-systemjs",
-      actionParams: executeParams,
+    // the computation of runtime features can be cached
+    const nodeFeatures = await getNodeRuntimeReport({
+      runtime: nodeRuntime,
+      compileServerId,
+      compileServerOrigin,
+      outDirectoryRelativeUrl,
+      // https://nodejs.org/docs/latest-v15.x/api/cli.html#cli_node_v8_coverage_dir
+      // instrumentation CAN be handed by process.env.NODE_V8_COVERAGE
+      // "transform-instrument" becomes non mandatory
+      coverageHandledFromOutside:
+        !coverageForceIstanbul && process.env.NODE_V8_COVERAGE,
     })
+    const { canAvoidCompilation, compileId, importDefaultExtension } =
+      nodeFeatures
+
+    let executionResult
+    if (canAvoidCompilation && !forceSystemJs) {
+      executionResult = await requestActionOnChildProcess({
+        signal,
+        actionType: "execute-using-dynamic-import",
+        actionParams: executeParams,
+      })
+    } else {
+      executionResult = await requestActionOnChildProcess({
+        signal,
+        actionType: "execute-using-systemjs",
+        actionParams: {
+          compileId,
+          importDefaultExtension,
+          ...executeParams,
+        },
+      })
+    }
 
     executionResult = transformExecutionResult(executionResult, {
       compileServerOrigin,

package/src/requireUsingChildProcess.js

@@ -1,5 +1,5 @@
 import { launchAndExecute } from "./internal/executing/launchAndExecute.js"
-import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
+import { createControllableNodeProcess } from "./internal/node_launcher/createControllableNodeProcess.js"
 
 export const requireUsingChildProcess = async (
   fileUrl,