@jsenv/core 28.1.0 → 28.1.3

package/dist/js/script_type_module_supervisor.js

@@ -1,45 +1,35 @@
-let previousExecutionPromise; // https://twitter.com/damienmaillard/status/1554752482273787906
-
+// https://twitter.com/damienmaillard/status/1554752482273787906
 const isWebkitOrSafari = typeof window.webkitConvertPointFromNodeToPage === "function";
 const superviseScriptTypeModule = async ({
   src,
   async
 }) => {
+  const currentScript = document.querySelector(`script[type="module"][inlined-from-src="${src}"]`);
   const execute = isWebkitOrSafari ? createExecuteWithDynamicImport({
     src
   }) : createExecuteWithScript({
+    currentScript,
     src
   });
 
-  const startExecution = () => {
-    const execution = window.__supervisor__.createExecution({
-      src,
-      type: "js_module",
-      execute
-    });
-
-    return execution.start();
-  };
-
-  if (async) {
-    startExecution();
-    return;
-  } // there is guaranteed execution order for non async script type="module"
-  // see https://gist.github.com/jakub-g/385ee6b41085303a53ad92c7c8afd7a6#typemodule-vs-non-module-typetextjavascript-vs-script-nomodule
-
-
-  if (previousExecutionPromise) {
-    await previousExecutionPromise;
-    previousExecutionPromise = null;
+  if (!async) {
+    await window.__supervisor__.getPreviousExecutionDonePromise();
   }
 
-  previousExecutionPromise = startExecution();
+  const execution = window.__supervisor__.createExecution({
+    src,
+    async,
+    type: "js_module",
+    execute
+  });
+
+  return execution.start();
 };
 
 const createExecuteWithScript = ({
+  currentScript,
   src
 }) => {
-  const currentScript = document.querySelector(`script[type="module"][inlined-from-src="${src}"]`);
   const parentNode = currentScript.parentNode;
   let nodeToReplace;
   let currentScriptClone;
@@ -48,7 +38,10 @@ const createExecuteWithScript = ({
   }) => {
     const urlObject = new URL(src, window.location);
     const loadPromise = new Promise((resolve, reject) => {
-      currentScriptClone = document.createElement("script");
+      currentScriptClone = document.createElement("script"); // browsers set async by default when creating script(s)
+      // we want an exact copy to preserves how code is executed
+
+      currentScriptClone.async = false;
       Array.from(currentScript.attributes).forEach(attribute => {
         currentScriptClone.setAttribute(attribute.nodeName, attribute.nodeValue);
       });

package/dist/js/supervisor.js

@@ -7,27 +7,17 @@ window.__supervisor__ = (() => {
     reportError: notImplemented,
     superviseScript: notImplemented,
     reloadSupervisedScript: notImplemented,
-    collectScriptResults: notImplemented,
-    getScriptExecutionResults: () => {
-      // wait for page to load before collecting script execution results
-      const htmlReadyPromise = new Promise((resolve) => {
-        if (document.readyState === "complete") {
-          resolve()
-          return
-        }
-        const loadCallback = () => {
-          window.removeEventListener("load", loadCallback)
-          resolve()
-        }
-        window.addEventListener("load", loadCallback)
-      })
-      return htmlReadyPromise.then(() => {
-        return supervisor.collectScriptResults()
-      })
-    },
+    getDocumentExecutionResult: notImplemented,
     executionResults,
   }
 
+  let navigationStartTime
+  try {
+    navigationStartTime = window.performance.timing.navigationStart
+  } catch (e) {
+    navigationStartTime = Date.now()
+  }
+
   supervisor.setupReportException = ({
     rootDirectoryUrl,
     errorNotification,
@@ -728,11 +718,12 @@ window.__supervisor__ = (() => {
     })
 
     const supervisedScripts = []
-    const executionPromises = []
-    supervisor.createExecution = ({ type, src, execute }) => {
+    const scriptExecutionPromises = []
+    supervisor.createExecution = ({ type, src, async, execute }) => {
       const execution = {
         type,
         src,
+        async,
         execute,
       }
       execution.start = () => {
@@ -753,21 +744,27 @@ window.__supervisor__ = (() => {
       }
       const executionResult = {
         status: "pending",
+        startTime: Date.now(),
+        endTime: null,
         exception: null,
         namespace: null,
         coverage: null,
       }
       executionResults[execution.src] = executionResult
-      let resolvePromise
-      const promise = new Promise((resolve) => {
-        resolvePromise = resolve
+      let resolveScriptExecutionPromise
+      const scriptExecutionPromise = new Promise((resolve) => {
+        resolveScriptExecutionPromise = () => {
+          executionResult.endTime = Date.now()
+          if (measurePerf) {
+            performance.measure(`execution`, `execution_start`)
+          }
+          resolve()
+        }
       })
-      executionPromises.push(promise)
+      scriptExecutionPromise.execution = execution
+      scriptExecutionPromises.push(scriptExecutionPromise)
       try {
         const result = await execution.execute({ isReload })
-        if (measurePerf) {
-          performance.measure(`execution`, `execution_start`)
-        }
         executionResult.status = "completed"
         executionResult.namespace = result
         executionResult.coverage = window.__coverage__
@@ -775,11 +772,8 @@ window.__supervisor__ = (() => {
           console.log(`${execution.type} load ended`)
           console.groupEnd()
         }
-        resolvePromise()
+        resolveScriptExecutionPromise()
       } catch (e) {
-        if (measurePerf) {
-          performance.measure(`execution`, `execution_start`)
-        }
         executionResult.status = "errored"
         const exception = supervisor.createException({
           reason: e,
@@ -792,73 +786,79 @@ window.__supervisor__ = (() => {
         if (logs) {
           console.groupEnd()
         }
-        resolvePromise()
+        resolveScriptExecutionPromise()
       }
     }
-    let previousExecutionPromise
+
+    // respect execution order
+    // - wait for classic scripts to be done (non async)
+    // - wait module script previous execution (non async)
+    // see  https://gist.github.com/jakub-g/385ee6b41085303a53ad92c7c8afd7a6#typemodule-vs-non-module-typetextjavascript-vs-script-nomodule
+    supervisor.getPreviousExecutionDonePromise = async () => {
+      const previousNonAsyncScriptExecutions = scriptExecutionPromises.filter(
+        (promise) => !promise.execution.async,
+      )
+      await Promise.all(previousNonAsyncScriptExecutions)
+    }
     supervisor.superviseScript = async ({ src, async }) => {
       const { currentScript } = document
       const parentNode = currentScript.parentNode
-      const startExecution = () => {
-        let nodeToReplace
-        let currentScriptClone
-        const execution = supervisor.createExecution({
-          src,
-          type: "js_classic",
-          execute: async ({ isReload }) => {
-            const urlObject = new URL(src, window.location)
-            const loadPromise = new Promise((resolve, reject) => {
-              // do not use script.cloneNode()
-              // bcause https://stackoverflow.com/questions/28771542/why-dont-clonenode-script-tags-execute
-              currentScriptClone = document.createElement("script")
-              Array.from(currentScript.attributes).forEach((attribute) => {
-                currentScriptClone.setAttribute(
-                  attribute.nodeName,
-                  attribute.nodeValue,
-                )
-              })
-              if (isReload) {
-                urlObject.searchParams.set("hmr", Date.now())
-                nodeToReplace = currentScriptClone
-                currentScriptClone.src = urlObject.href
-              } else {
-                currentScriptClone.removeAttribute("jsenv-plugin-owner")
-                currentScriptClone.removeAttribute("jsenv-plugin-action")
-                currentScriptClone.removeAttribute("inlined-from-src")
-                currentScriptClone.removeAttribute("original-position")
-                currentScriptClone.removeAttribute("original-src-position")
-                nodeToReplace = currentScript
-                currentScriptClone.src = src
-              }
-              currentScriptClone.addEventListener("error", reject)
-              currentScriptClone.addEventListener("load", resolve)
-              parentNode.replaceChild(currentScriptClone, nodeToReplace)
+      if (!async) {
+        await supervisor.getPreviousExecutionDonePromise()
+      }
+      let nodeToReplace
+      let currentScriptClone
+      const execution = supervisor.createExecution({
+        src,
+        type: "js_classic",
+        async,
+        execute: async ({ isReload }) => {
+          const urlObject = new URL(src, window.location)
+          const loadPromise = new Promise((resolve, reject) => {
+            // do not use script.cloneNode()
+            // bcause https://stackoverflow.com/questions/28771542/why-dont-clonenode-script-tags-execute
+            currentScriptClone = document.createElement("script")
+            // browsers set async by default when creating script(s)
+            // we want an exact copy to preserves how code is executed
+            currentScriptClone.async = false
+            Array.from(currentScript.attributes).forEach((attribute) => {
+              currentScriptClone.setAttribute(
+                attribute.nodeName,
+                attribute.nodeValue,
+              )
             })
-            try {
-              await loadPromise
-            } catch (e) {
-              // eslint-disable-next-line no-throw-literal
-              throw {
-                message: `Failed to fetch script: ${urlObject.href}`,
-                reportedBy: "script_error_event",
-                url: urlObject.href,
-                // window.error won't be dispatched for this error
-                needsReport: true,
-              }
+            if (isReload) {
+              urlObject.searchParams.set("hmr", Date.now())
+              nodeToReplace = currentScriptClone
+              currentScriptClone.src = urlObject.href
+            } else {
+              currentScriptClone.removeAttribute("jsenv-plugin-owner")
+              currentScriptClone.removeAttribute("jsenv-plugin-action")
+              currentScriptClone.removeAttribute("inlined-from-src")
+              currentScriptClone.removeAttribute("original-position")
+              currentScriptClone.removeAttribute("original-src-position")
+              nodeToReplace = currentScript
+              currentScriptClone.src = src
             }
-          },
-        })
-        return execution.start()
-      }
-      if (async) {
-        startExecution()
-        return
-      }
-      if (previousExecutionPromise) {
-        await previousExecutionPromise
-        previousExecutionPromise = null
-      }
-      previousExecutionPromise = startExecution()
+            currentScriptClone.addEventListener("error", reject)
+            currentScriptClone.addEventListener("load", resolve)
+            parentNode.replaceChild(currentScriptClone, nodeToReplace)
+          })
+          try {
+            await loadPromise
+          } catch (e) {
+            // eslint-disable-next-line no-throw-literal
+            throw {
+              message: `Failed to fetch script: ${urlObject.href}`,
+              reportedBy: "script_error_event",
+              url: urlObject.href,
+              // window.error won't be dispatched for this error
+              needsReport: true,
+            }
+          }
+        },
+      })
+      return execution.start()
     }
     supervisor.reloadSupervisedScript = ({ type, src }) => {
       const supervisedScript = supervisedScripts.find(
@@ -876,45 +876,39 @@ window.__supervisor__ = (() => {
         supervisedScript.reload()
       }
     }
-    supervisor.collectScriptResults = async () => {
+    supervisor.getDocumentExecutionResult = async () => {
       // just to be super safe and ensure any <script type="module"> got a chance to execute
-      const scriptTypeModuleLoaded = new Promise((resolve) => {
-        const scriptTypeModule = document.createElement("script")
-        scriptTypeModule.type = "module"
-        scriptTypeModule.innerText =
-          "window.__supervisor__.scriptModuleCallback()"
-        window.__supervisor__.scriptModuleCallback = () => {
-          scriptTypeModule.parentNode.removeChild(scriptTypeModule)
+      const documentReadyPromise = new Promise((resolve) => {
+        if (document.readyState === "complete") {
           resolve()
+          return
         }
-        document.body.appendChild(scriptTypeModule)
+        const loadCallback = () => {
+          window.removeEventListener("load", loadCallback)
+          resolve()
+        }
+        window.addEventListener("load", loadCallback)
       })
-      await scriptTypeModuleLoaded
-
-      const waitPendingExecutions = async () => {
-        if (executionPromises.length) {
-          const promisesToWait = executionPromises.slice()
-          executionPromises.length = 0
-          await Promise.all(promisesToWait)
-          await waitPendingExecutions()
+      await documentReadyPromise
+      const waitScriptExecutions = async () => {
+        const numberOfScripts = scriptExecutionPromises.length
+        await Promise.all(scriptExecutionPromises)
+        // new scripts added while the other where executing
+        // (should happen only on webkit where
+        // script might be added after window load event)
+        if (scriptExecutionPromises.length > numberOfScripts) {
+          await waitScriptExecutions()
         }
       }
-      await waitPendingExecutions()
+      await waitScriptExecutions()
+
       return {
         status: "completed",
         executionResults,
-        startTime: getNavigationStartTime(),
+        startTime: navigationStartTime,
         endTime: Date.now(),
       }
     }
-
-    const getNavigationStartTime = () => {
-      try {
-        return window.performance.timing.navigationStart
-      } catch (e) {
-        return Date.now()
-      }
-    }
   }
 
   return supervisor

package/dist/main.js

@@ -1320,29 +1320,33 @@ const createOperation = () => {
   };
 
   const addAbortSource = abortSourceCallback => {
+    const abortSource = {
+      cleaned: false,
+      signal: null,
+      remove: callbackNoop
+    };
     const abortSourceController = new AbortController();
     const abortSourceSignal = abortSourceController.signal;
+    abortSource.signal = abortSourceSignal;
 
     if (operationSignal.aborted) {
-      return {
-        signal: abortSourceSignal,
-        remove: callbackNoop
-      };
+      return abortSource;
     }
 
     const returnValue = abortSourceCallback(value => {
       abortSourceController.abort(value);
     });
-    const removeAbortSource = typeof returnValue === "function" ? returnValue : callbackNoop;
     const removeAbortSignal = addAbortSignal(abortSourceSignal, {
       onRemove: () => {
-        removeAbortSource();
+        if (typeof returnValue === "function") {
+          returnValue();
+        }
+
+        abortSource.cleaned = true;
       }
     });
-    return {
-      signal: abortSourceSignal,
-      remove: removeAbortSignal
-    };
+    abortSource.remove = removeAbortSignal;
+    return abortSource;
   };
 
   const timeout = ms => {
@@ -26503,7 +26507,7 @@ const run = async ({
           } catch (e) {
             cb({
               status: "errored",
-              error: e
+              errors: [e]
             });
           }
         }
@@ -27575,7 +27579,7 @@ const executeTestPlan = async ({
   testPlan,
   updateProcessExitCode = true,
   maxExecutionsInParallel = 1,
-  defaultMsAllocatedPerExecution = 30000,
+  defaultMsAllocatedPerExecution = 30_000,
   failFast = false,
   // keepRunning: false to ensure runtime is stopped once executed
   // because we have what we wants: execution is completed and
@@ -28036,7 +28040,7 @@ const createRuntimeFromPlaywright = ({
                 throw new Error(`window.__supervisor__ not found`);
               }
 
-              return window.__supervisor__.getScriptExecutionResults();
+              return window.__supervisor__.getDocumentExecutionResult();
             }
             /* eslint-enable no-undef */
             );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "28.1.0",
+  "version": "28.1.3",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -65,15 +65,15 @@
     "@babel/plugin-transform-modules-umd": "7.18.6",
     "@c88/v8-coverage": "0.1.1",
     "@financial-times/polyfill-useragent-normaliser": "2.0.1",
-    "@jsenv/abort": "4.2.3",
+    "@jsenv/abort": "4.2.4",
     "@jsenv/ast": "1.2.0",
     "@jsenv/babel-plugins": "1.0.6",
-    "@jsenv/filesystem": "4.1.2",
+    "@jsenv/filesystem": "4.1.3",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.1",
     "@jsenv/log": "3.2.0",
     "@jsenv/node-esm-resolution": "0.1.0",
-    "@jsenv/server": "14.1.1",
+    "@jsenv/server": "14.1.2",
     "@jsenv/sourcemap": "1.0.4",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/url-meta": "7.0.0",

package/src/execute/run.js

@@ -108,7 +108,7 @@ export const run = async ({
             } catch (e) {
               cb({
                 status: "errored",
-                error: e,
+                errors: [e],
               })
             }
           },

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

@@ -306,7 +306,7 @@ export const createRuntimeFromPlaywright = ({
                   if (!window.__supervisor__) {
                     throw new Error(`window.__supervisor__ not found`)
                   }
-                  return window.__supervisor__.getScriptExecutionResults()
+                  return window.__supervisor__.getDocumentExecutionResult()
                 },
                 /* eslint-enable no-undef */
               )

package/src/plugins/supervisor/client/script_type_module_supervisor.js

@@ -1,46 +1,37 @@
-let previousExecutionPromise
-
 // https://twitter.com/damienmaillard/status/1554752482273787906
 const isWebkitOrSafari =
   typeof window.webkitConvertPointFromNodeToPage === "function"
 
 export const superviseScriptTypeModule = async ({ src, async }) => {
+  const currentScript = document.querySelector(
+    `script[type="module"][inlined-from-src="${src}"]`,
+  )
   const execute = isWebkitOrSafari
     ? createExecuteWithDynamicImport({ src })
-    : createExecuteWithScript({ src })
-  const startExecution = () => {
-    const execution = window.__supervisor__.createExecution({
-      src,
-      type: "js_module",
-      execute,
-    })
-    return execution.start()
-  }
-  if (async) {
-    startExecution()
-    return
+    : createExecuteWithScript({ currentScript, src })
+  if (!async) {
+    await window.__supervisor__.getPreviousExecutionDonePromise()
   }
-  // there is guaranteed execution order for non async script type="module"
-  // see https://gist.github.com/jakub-g/385ee6b41085303a53ad92c7c8afd7a6#typemodule-vs-non-module-typetextjavascript-vs-script-nomodule
-  if (previousExecutionPromise) {
-    await previousExecutionPromise
-    previousExecutionPromise = null
-  }
-  previousExecutionPromise = startExecution()
+  const execution = window.__supervisor__.createExecution({
+    src,
+    async,
+    type: "js_module",
+    execute,
+  })
+  return execution.start()
 }
 
-const createExecuteWithScript = ({ src }) => {
-  const currentScript = document.querySelector(
-    `script[type="module"][inlined-from-src="${src}"]`,
-  )
+const createExecuteWithScript = ({ currentScript, src }) => {
   const parentNode = currentScript.parentNode
   let nodeToReplace
   let currentScriptClone
-
   return async ({ isReload }) => {
     const urlObject = new URL(src, window.location)
     const loadPromise = new Promise((resolve, reject) => {
       currentScriptClone = document.createElement("script")
+      // browsers set async by default when creating script(s)
+      // we want an exact copy to preserves how code is executed
+      currentScriptClone.async = false
       Array.from(currentScript.attributes).forEach((attribute) => {
         currentScriptClone.setAttribute(attribute.nodeName, attribute.nodeValue)
       })

package/src/plugins/supervisor/client/supervisor.js

@@ -7,27 +7,17 @@ window.__supervisor__ = (() => {
     reportError: notImplemented,
     superviseScript: notImplemented,
     reloadSupervisedScript: notImplemented,
-    collectScriptResults: notImplemented,
-    getScriptExecutionResults: () => {
-      // wait for page to load before collecting script execution results
-      const htmlReadyPromise = new Promise((resolve) => {
-        if (document.readyState === "complete") {
-          resolve()
-          return
-        }
-        const loadCallback = () => {
-          window.removeEventListener("load", loadCallback)
-          resolve()
-        }
-        window.addEventListener("load", loadCallback)
-      })
-      return htmlReadyPromise.then(() => {
-        return supervisor.collectScriptResults()
-      })
-    },
+    getDocumentExecutionResult: notImplemented,
     executionResults,
   }
 
+  let navigationStartTime
+  try {
+    navigationStartTime = window.performance.timing.navigationStart
+  } catch (e) {
+    navigationStartTime = Date.now()
+  }
+
   supervisor.setupReportException = ({
     rootDirectoryUrl,
     errorNotification,
@@ -728,11 +718,12 @@ window.__supervisor__ = (() => {
     })
 
     const supervisedScripts = []
-    const executionPromises = []
-    supervisor.createExecution = ({ type, src, execute }) => {
+    const scriptExecutionPromises = []
+    supervisor.createExecution = ({ type, src, async, execute }) => {
       const execution = {
         type,
         src,
+        async,
         execute,
       }
       execution.start = () => {
@@ -753,21 +744,27 @@ window.__supervisor__ = (() => {
       }
       const executionResult = {
         status: "pending",
+        startTime: Date.now(),
+        endTime: null,
         exception: null,
         namespace: null,
         coverage: null,
       }
       executionResults[execution.src] = executionResult
-      let resolvePromise
-      const promise = new Promise((resolve) => {
-        resolvePromise = resolve
+      let resolveScriptExecutionPromise
+      const scriptExecutionPromise = new Promise((resolve) => {
+        resolveScriptExecutionPromise = () => {
+          executionResult.endTime = Date.now()
+          if (measurePerf) {
+            performance.measure(`execution`, `execution_start`)
+          }
+          resolve()
+        }
       })
-      executionPromises.push(promise)
+      scriptExecutionPromise.execution = execution
+      scriptExecutionPromises.push(scriptExecutionPromise)
       try {
         const result = await execution.execute({ isReload })
-        if (measurePerf) {
-          performance.measure(`execution`, `execution_start`)
-        }
         executionResult.status = "completed"
         executionResult.namespace = result
         executionResult.coverage = window.__coverage__
@@ -775,11 +772,8 @@ window.__supervisor__ = (() => {
           console.log(`${execution.type} load ended`)
           console.groupEnd()
         }
-        resolvePromise()
+        resolveScriptExecutionPromise()
       } catch (e) {
-        if (measurePerf) {
-          performance.measure(`execution`, `execution_start`)
-        }
         executionResult.status = "errored"
         const exception = supervisor.createException({
           reason: e,
@@ -792,73 +786,79 @@ window.__supervisor__ = (() => {
         if (logs) {
           console.groupEnd()
         }
-        resolvePromise()
+        resolveScriptExecutionPromise()
       }
     }
-    let previousExecutionPromise
+
+    // respect execution order
+    // - wait for classic scripts to be done (non async)
+    // - wait module script previous execution (non async)
+    // see  https://gist.github.com/jakub-g/385ee6b41085303a53ad92c7c8afd7a6#typemodule-vs-non-module-typetextjavascript-vs-script-nomodule
+    supervisor.getPreviousExecutionDonePromise = async () => {
+      const previousNonAsyncScriptExecutions = scriptExecutionPromises.filter(
+        (promise) => !promise.execution.async,
+      )
+      await Promise.all(previousNonAsyncScriptExecutions)
+    }
     supervisor.superviseScript = async ({ src, async }) => {
       const { currentScript } = document
       const parentNode = currentScript.parentNode
-      const startExecution = () => {
-        let nodeToReplace
-        let currentScriptClone
-        const execution = supervisor.createExecution({
-          src,
-          type: "js_classic",
-          execute: async ({ isReload }) => {
-            const urlObject = new URL(src, window.location)
-            const loadPromise = new Promise((resolve, reject) => {
-              // do not use script.cloneNode()
-              // bcause https://stackoverflow.com/questions/28771542/why-dont-clonenode-script-tags-execute
-              currentScriptClone = document.createElement("script")
-              Array.from(currentScript.attributes).forEach((attribute) => {
-                currentScriptClone.setAttribute(
-                  attribute.nodeName,
-                  attribute.nodeValue,
-                )
-              })
-              if (isReload) {
-                urlObject.searchParams.set("hmr", Date.now())
-                nodeToReplace = currentScriptClone
-                currentScriptClone.src = urlObject.href
-              } else {
-                currentScriptClone.removeAttribute("jsenv-plugin-owner")
-                currentScriptClone.removeAttribute("jsenv-plugin-action")
-                currentScriptClone.removeAttribute("inlined-from-src")
-                currentScriptClone.removeAttribute("original-position")
-                currentScriptClone.removeAttribute("original-src-position")
-                nodeToReplace = currentScript
-                currentScriptClone.src = src
-              }
-              currentScriptClone.addEventListener("error", reject)
-              currentScriptClone.addEventListener("load", resolve)
-              parentNode.replaceChild(currentScriptClone, nodeToReplace)
+      if (!async) {
+        await supervisor.getPreviousExecutionDonePromise()
+      }
+      let nodeToReplace
+      let currentScriptClone
+      const execution = supervisor.createExecution({
+        src,
+        type: "js_classic",
+        async,
+        execute: async ({ isReload }) => {
+          const urlObject = new URL(src, window.location)
+          const loadPromise = new Promise((resolve, reject) => {
+            // do not use script.cloneNode()
+            // bcause https://stackoverflow.com/questions/28771542/why-dont-clonenode-script-tags-execute
+            currentScriptClone = document.createElement("script")
+            // browsers set async by default when creating script(s)
+            // we want an exact copy to preserves how code is executed
+            currentScriptClone.async = false
+            Array.from(currentScript.attributes).forEach((attribute) => {
+              currentScriptClone.setAttribute(
+                attribute.nodeName,
+                attribute.nodeValue,
+              )
             })
-            try {
-              await loadPromise
-            } catch (e) {
-              // eslint-disable-next-line no-throw-literal
-              throw {
-                message: `Failed to fetch script: ${urlObject.href}`,
-                reportedBy: "script_error_event",
-                url: urlObject.href,
-                // window.error won't be dispatched for this error
-                needsReport: true,
-              }
+            if (isReload) {
+              urlObject.searchParams.set("hmr", Date.now())
+              nodeToReplace = currentScriptClone
+              currentScriptClone.src = urlObject.href
+            } else {
+              currentScriptClone.removeAttribute("jsenv-plugin-owner")
+              currentScriptClone.removeAttribute("jsenv-plugin-action")
+              currentScriptClone.removeAttribute("inlined-from-src")
+              currentScriptClone.removeAttribute("original-position")
+              currentScriptClone.removeAttribute("original-src-position")
+              nodeToReplace = currentScript
+              currentScriptClone.src = src
             }
-          },
-        })
-        return execution.start()
-      }
-      if (async) {
-        startExecution()
-        return
-      }
-      if (previousExecutionPromise) {
-        await previousExecutionPromise
-        previousExecutionPromise = null
-      }
-      previousExecutionPromise = startExecution()
+            currentScriptClone.addEventListener("error", reject)
+            currentScriptClone.addEventListener("load", resolve)
+            parentNode.replaceChild(currentScriptClone, nodeToReplace)
+          })
+          try {
+            await loadPromise
+          } catch (e) {
+            // eslint-disable-next-line no-throw-literal
+            throw {
+              message: `Failed to fetch script: ${urlObject.href}`,
+              reportedBy: "script_error_event",
+              url: urlObject.href,
+              // window.error won't be dispatched for this error
+              needsReport: true,
+            }
+          }
+        },
+      })
+      return execution.start()
     }
     supervisor.reloadSupervisedScript = ({ type, src }) => {
       const supervisedScript = supervisedScripts.find(
@@ -876,45 +876,39 @@ window.__supervisor__ = (() => {
         supervisedScript.reload()
       }
     }
-    supervisor.collectScriptResults = async () => {
+    supervisor.getDocumentExecutionResult = async () => {
       // just to be super safe and ensure any <script type="module"> got a chance to execute
-      const scriptTypeModuleLoaded = new Promise((resolve) => {
-        const scriptTypeModule = document.createElement("script")
-        scriptTypeModule.type = "module"
-        scriptTypeModule.innerText =
-          "window.__supervisor__.scriptModuleCallback()"
-        window.__supervisor__.scriptModuleCallback = () => {
-          scriptTypeModule.parentNode.removeChild(scriptTypeModule)
+      const documentReadyPromise = new Promise((resolve) => {
+        if (document.readyState === "complete") {
           resolve()
+          return
         }
-        document.body.appendChild(scriptTypeModule)
+        const loadCallback = () => {
+          window.removeEventListener("load", loadCallback)
+          resolve()
+        }
+        window.addEventListener("load", loadCallback)
       })
-      await scriptTypeModuleLoaded
-
-      const waitPendingExecutions = async () => {
-        if (executionPromises.length) {
-          const promisesToWait = executionPromises.slice()
-          executionPromises.length = 0
-          await Promise.all(promisesToWait)
-          await waitPendingExecutions()
+      await documentReadyPromise
+      const waitScriptExecutions = async () => {
+        const numberOfScripts = scriptExecutionPromises.length
+        await Promise.all(scriptExecutionPromises)
+        // new scripts added while the other where executing
+        // (should happen only on webkit where
+        // script might be added after window load event)
+        if (scriptExecutionPromises.length > numberOfScripts) {
+          await waitScriptExecutions()
         }
       }
-      await waitPendingExecutions()
+      await waitScriptExecutions()
+
       return {
         status: "completed",
         executionResults,
-        startTime: getNavigationStartTime(),
+        startTime: navigationStartTime,
         endTime: Date.now(),
       }
     }
-
-    const getNavigationStartTime = () => {
-      try {
-        return window.performance.timing.navigationStart
-      } catch (e) {
-        return Date.now()
-      }
-    }
   }
 
   return supervisor

package/src/plugins/toolbar/client/execution/toolbar_execution.js

@@ -9,7 +9,7 @@ export const renderExecutionInToolbar = async () => {
   removeForceHideElement(document.querySelector("#execution-indicator"))
 
   const { status, startTime, endTime } =
-    await window.parent.__supervisor__.getScriptExecutionResults()
+    await window.parent.__supervisor__.getDocumentExecutionResult()
   const execution = { status, startTime, endTime }
   applyExecutionIndicator(execution)
   const executionStorageKey = window.location.href

package/src/test/execute_test_plan.js

@@ -52,7 +52,7 @@ export const executeTestPlan = async ({
   testPlan,
   updateProcessExitCode = true,
   maxExecutionsInParallel = 1,
-  defaultMsAllocatedPerExecution = 30000,
+  defaultMsAllocatedPerExecution = 30_000,
   failFast = false,
   // keepRunning: false to ensure runtime is stopped once executed
   // because we have what we wants: execution is completed and