@jsenv/test 1.5.2 → 1.6.1

package/dist/jsenv_test.js

@@ -1,4 +1,4 @@
-import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, readFileSync, readdirSync, existsSync } from "node:fs";
+import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, readFileSync, existsSync, readdirSync } from "node:fs";
 import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import "node:crypto";
@@ -8,7 +8,9 @@ import os from "node:os";
 import tty from "node:tty";
 import stringWidth from "string-width";
 import { createRequire } from "node:module";
+import { Worker } from "node:worker_threads";
 import { createServer } from "node:net";
+import { spawn, spawnSync, fork } from "node:child_process";
 import v8, { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { applyBabelPlugins } from "@jsenv/ast";
@@ -17,1068 +19,1066 @@ import { runInNewContext } from "node:vm";
 import wrapAnsi from "wrap-ansi";
 import { injectSupervisorIntoHTML, supervisorFileUrl } from "@jsenv/plugin-supervisor";
 import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap";
-import { fork } from "node:child_process";
 import { findFreePort } from "@jsenv/server";
-import { Worker } from "node:worker_threads";
 
-const urlToScheme = (url) => {
-  const urlString = String(url);
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) {
-    return "";
-  }
+/*
+ * See callback_race.md
+ */
 
-  const scheme = urlString.slice(0, colonIndex);
-  return scheme;
-};
+const raceCallbacks = (raceDescription, winnerCallback) => {
+  let cleanCallbacks = [];
+  let status = "racing";
 
-const urlToResource = (url) => {
-  const scheme = urlToScheme(url);
+  const clean = () => {
+    cleanCallbacks.forEach((clean) => {
+      clean();
+    });
+    cleanCallbacks = null;
+  };
 
-  if (scheme === "file") {
-    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
-    return urlAsStringWithoutFileProtocol;
-  }
+  const cancel = () => {
+    if (status !== "racing") {
+      return;
+    }
+    status = "cancelled";
+    clean();
+  };
 
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = String(url).slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex);
-    return urlAsStringWithoutOrigin;
-  }
+  Object.keys(raceDescription).forEach((candidateName) => {
+    const register = raceDescription[candidateName];
+    const returnValue = register((data) => {
+      if (status !== "racing") {
+        return;
+      }
+      status = "done";
+      clean();
+      winnerCallback({
+        name: candidateName,
+        data,
+      });
+    });
+    if (typeof returnValue === "function") {
+      cleanCallbacks.push(returnValue);
+    }
+  });
 
-  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1);
-  return urlAsStringWithoutProtocol;
+  return cancel;
 };
 
-const urlToPathname = (url) => {
-  const resource = urlToResource(url);
-  const pathname = resourceToPathname(resource);
-  return pathname;
-};
+const createCallbackListNotifiedOnce = () => {
+  let callbacks = [];
+  let status = "waiting";
+  let currentCallbackIndex = -1;
 
-const resourceToPathname = (resource) => {
-  const searchSeparatorIndex = resource.indexOf("?");
-  if (searchSeparatorIndex > -1) {
-    return resource.slice(0, searchSeparatorIndex);
-  }
-  const hashIndex = resource.indexOf("#");
-  if (hashIndex > -1) {
-    return resource.slice(0, hashIndex);
-  }
-  return resource;
-};
+  const callbackListOnce = {};
 
-const urlToExtension = (url) => {
-  const pathname = urlToPathname(url);
-  return pathnameToExtension(pathname);
-};
+  const add = (callback) => {
+    if (status !== "waiting") {
+      emitUnexpectedActionWarning({ action: "add", status });
+      return removeNoop;
+    }
 
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1);
-  }
+    if (typeof callback !== "function") {
+      throw new Error(`callback must be a function, got ${callback}`);
+    }
 
-  const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return "";
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = pathname.slice(dotLastIndex);
-  return extension;
-};
+    // don't register twice
+    const existingCallback = callbacks.find((callbackCandidate) => {
+      return callbackCandidate === callback;
+    });
+    if (existingCallback) {
+      emitCallbackDuplicationWarning();
+      return removeNoop;
+    }
 
-const ensurePathnameTrailingSlash = (url) => {
-  const urlObject = new URL(url);
-  const { pathname } = urlObject;
-  if (pathname.endsWith("/")) {
-    return url;
-  }
-  let { origin } = urlObject;
-  // origin is "null" for "file://" urls with Node.js
-  if (origin === "null" && urlObject.href.startsWith("file:")) {
-    origin = "file://";
-  }
-  const { search, hash } = urlObject;
-  return `${origin}${pathname}/${search}${hash}`;
+    callbacks.push(callback);
+    return () => {
+      if (status === "notified") {
+        // once called removing does nothing
+        // as the callbacks array is frozen to null
+        return;
+      }
+
+      const index = callbacks.indexOf(callback);
+      if (index === -1) {
+        return;
+      }
+
+      if (status === "looping") {
+        if (index <= currentCallbackIndex) {
+          // The callback was already called (or is the current callback)
+          // We don't want to mutate the callbacks array
+          // or it would alter the looping done in "call" and the next callback
+          // would be skipped
+          return;
+        }
+
+        // Callback is part of the next callback to call,
+        // we mutate the callbacks array to prevent this callback to be called
+      }
+
+      callbacks.splice(index, 1);
+    };
+  };
+
+  const notify = (param) => {
+    if (status !== "waiting") {
+      emitUnexpectedActionWarning({ action: "call", status });
+      return [];
+    }
+    status = "looping";
+    const values = callbacks.map((callback, index) => {
+      currentCallbackIndex = index;
+      return callback(param);
+    });
+    callbackListOnce.notified = true;
+    status = "notified";
+    // we reset callbacks to null after looping
+    // so that it's possible to remove during the loop
+    callbacks = null;
+    currentCallbackIndex = -1;
+
+    return values;
+  };
+
+  callbackListOnce.notified = false;
+  callbackListOnce.add = add;
+  callbackListOnce.notify = notify;
+
+  return callbackListOnce;
 };
 
-const isFileSystemPath = (value) => {
-  if (typeof value !== "string") {
-    throw new TypeError(
-      `isFileSystemPath first arg must be a string, got ${value}`,
+const emitUnexpectedActionWarning = ({ action, status }) => {
+  if (typeof process.emitWarning === "function") {
+    process.emitWarning(
+      `"${action}" should not happen when callback list is ${status}`,
+      {
+        CODE: "UNEXPECTED_ACTION_ON_CALLBACK_LIST",
+        detail: `Code is potentially executed when it should not`,
+      },
+    );
+  } else {
+    console.warn(
+      `"${action}" should not happen when callback list is ${status}`,
     );
   }
-  if (value[0] === "/") {
-    return true;
+};
+
+const emitCallbackDuplicationWarning = () => {
+  if (typeof process.emitWarning === "function") {
+    process.emitWarning(`Trying to add a callback already in the list`, {
+      CODE: "CALLBACK_DUPLICATION",
+      detail: `Code is potentially executed more than it should`,
+    });
+  } else {
+    console.warn(`Trying to add same callback twice`);
   }
-  return startsWithWindowsDriveLetter(value);
 };
 
-const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
+const removeNoop = () => {};
 
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
+/*
+ * https://github.com/whatwg/dom/issues/920
+ */
 
-  return true;
-};
 
-const fileSystemPathToUrl = (value) => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`value must be a filesystem path, got ${value}`);
-  }
-  return String(pathToFileURL(value));
-};
+const Abort = {
+  isAbortError: (error) => {
+    return error && error.name === "AbortError";
+  },
 
-const resolveUrl = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
-  }
-  return String(new URL(specifier, baseUrl));
+  startOperation: () => {
+    return createOperation();
+  },
+
+  throwIfAborted: (signal) => {
+    if (signal.aborted) {
+      const error = new Error(`The operation was aborted`);
+      error.name = "AbortError";
+      error.type = "aborted";
+      throw error;
+    }
+  },
 };
 
-const getCommonPathname = (pathname, otherPathname) => {
-  if (pathname === otherPathname) {
-    return pathname;
-  }
-  let commonPart = "";
-  let commonPathname = "";
-  let i = 0;
-  const length = pathname.length;
-  const otherLength = otherPathname.length;
-  while (i < length) {
-    const char = pathname.charAt(i);
-    const otherChar = otherPathname.charAt(i);
-    i++;
-    if (char === otherChar) {
-      if (char === "/") {
-        commonPart += "/";
-        commonPathname += commonPart;
-        commonPart = "";
-      } else {
-        commonPart += char;
-      }
-    } else {
-      if (char === "/" && i - 1 === otherLength) {
-        commonPart += "/";
-        commonPathname += commonPart;
-      }
-      return commonPathname;
-    }
-  }
-  if (length === otherLength) {
-    commonPathname += commonPart;
-  } else if (otherPathname.charAt(i) === "/") {
-    commonPathname += commonPart;
-  }
-  return commonPathname;
-};
-
-const urlToRelativeUrl = (url, baseUrl) => {
-  const urlObject = new URL(url);
-  const baseUrlObject = new URL(baseUrl);
-
-  if (urlObject.protocol !== baseUrlObject.protocol) {
-    const urlAsString = String(url);
-    return urlAsString;
-  }
-
-  if (
-    urlObject.username !== baseUrlObject.username ||
-    urlObject.password !== baseUrlObject.password ||
-    urlObject.host !== baseUrlObject.host
-  ) {
-    const afterUrlScheme = String(url).slice(urlObject.protocol.length);
-    return afterUrlScheme;
-  }
-
-  const { pathname, hash, search } = urlObject;
-  if (pathname === "/") {
-    const baseUrlResourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1);
-    return baseUrlResourceWithoutLeadingSlash;
-  }
-
-  const basePathname = baseUrlObject.pathname;
-  const commonPathname = getCommonPathname(pathname, basePathname);
-  if (!commonPathname) {
-    const urlAsString = String(url);
-    return urlAsString;
-  }
-  const specificPathname = pathname.slice(commonPathname.length);
-  const baseSpecificPathname = basePathname.slice(commonPathname.length);
-  if (baseSpecificPathname.includes("/")) {
-    const baseSpecificParentPathname =
-      pathnameToParentPathname(baseSpecificPathname);
-    const relativeDirectoriesNotation = baseSpecificParentPathname.replace(
-      /.*?\//g,
-      "../",
-    );
-    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`;
-    return relativeUrl;
-  }
-
-  const relativeUrl = `${specificPathname}${search}${hash}`;
-  return relativeUrl;
-};
+const createOperation = () => {
+  const operationAbortController = new AbortController();
+  // const abortOperation = (value) => abortController.abort(value)
+  const operationSignal = operationAbortController.signal;
 
-const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex === -1) {
-    return "/";
-  }
-  return pathname.slice(0, slashLastIndex + 1);
-};
+  // abortCallbackList is used to ignore the max listeners warning from Node.js
+  // this warning is useful but becomes problematic when it's expected
+  // (a function doing 20 http call in parallel)
+  // To be 100% sure we don't have memory leak, only Abortable.asyncCallback
+  // uses abortCallbackList to know when something is aborted
+  const abortCallbackList = createCallbackListNotifiedOnce();
+  const endCallbackList = createCallbackListNotifiedOnce();
 
-const moveUrl = ({ url, from, to, preferRelative }) => {
-  let relativeUrl = urlToRelativeUrl(url, from);
-  if (relativeUrl.slice(0, 2) === "//") {
-    // restore the protocol
-    relativeUrl = new URL(relativeUrl, url).href;
-  }
-  const absoluteUrl = new URL(relativeUrl, to).href;
-  if (preferRelative) {
-    return urlToRelativeUrl(absoluteUrl, to);
-  }
-  return absoluteUrl;
-};
+  let isAbortAfterEnd = false;
 
-const urlIsInsideOf = (url, otherUrl) => {
-  const urlObject = new URL(url);
-  const otherUrlObject = new URL(otherUrl);
+  operationSignal.onabort = () => {
+    operationSignal.onabort = null;
 
-  if (urlObject.origin !== otherUrlObject.origin) {
-    return false;
-  }
+    const allAbortCallbacksPromise = Promise.all(abortCallbackList.notify());
+    if (!isAbortAfterEnd) {
+      addEndCallback(async () => {
+        await allAbortCallbacksPromise;
+      });
+    }
+  };
 
-  const urlPathname = urlObject.pathname;
-  const otherUrlPathname = otherUrlObject.pathname;
-  if (urlPathname === otherUrlPathname) {
-    return false;
-  }
+  const throwIfAborted = () => {
+    Abort.throwIfAborted(operationSignal);
+  };
 
-  const isInside = urlPathname.startsWith(otherUrlPathname);
-  return isInside;
-};
+  // add a callback called on abort
+  // differences with signal.addEventListener('abort')
+  // - operation.end awaits the return value of this callback
+  // - It won't increase the count of listeners for "abort" that would
+  //   trigger max listeners warning when count > 10
+  const addAbortCallback = (callback) => {
+    // It would be painful and not super redable to check if signal is aborted
+    // before deciding if it's an abort or end callback
+    // with pseudo-code below where we want to stop server either
+    // on abort or when ended because signal is aborted
+    // operation[operation.signal.aborted ? 'addAbortCallback': 'addEndCallback'](async () => {
+    //   await server.stop()
+    // })
+    if (operationSignal.aborted) {
+      return addEndCallback(callback);
+    }
+    return abortCallbackList.add(callback);
+  };
 
-const urlToFileSystemPath = (url) => {
-  let urlString = String(url);
-  if (urlString[urlString.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1);
-  }
-  const fileSystemPath = fileURLToPath(urlString);
-  return fileSystemPath;
-};
+  const addEndCallback = (callback) => {
+    return endCallbackList.add(callback);
+  };
 
-const validateDirectoryUrl = (value) => {
-  let urlString;
+  const end = async ({ abortAfterEnd = false } = {}) => {
+    await Promise.all(endCallbackList.notify());
 
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value));
-      } catch (e) {
-        return {
-          valid: false,
-          value,
-          message: `must be a valid url`,
-        };
+    // "abortAfterEnd" can be handy to ensure "abort" callbacks
+    // added with { once: true } are removed
+    // It might also help garbage collection because
+    // runtime implementing AbortSignal (Node.js, browsers) can consider abortSignal
+    // as settled and clean up things
+    if (abortAfterEnd) {
+      // because of operationSignal.onabort = null
+      // + abortCallbackList.clear() this won't re-call
+      // callbacks
+      if (!operationSignal.aborted) {
+        isAbortAfterEnd = true;
+        operationAbortController.abort();
       }
     }
-  } else {
-    return {
-      valid: false,
-      value,
-      message: `must be a string or an url`,
+  };
+
+  const addAbortSignal = (
+    signal,
+    { onAbort = callbackNoop, onRemove = callbackNoop } = {},
+  ) => {
+    const applyAbortEffects = () => {
+      const onAbortCallback = onAbort;
+      onAbort = callbackNoop;
+      onAbortCallback();
     };
-  }
-  if (!urlString.startsWith("file://")) {
-    return {
-      valid: false,
-      value,
-      message: 'must start with "file://"',
+    const applyRemoveEffects = () => {
+      const onRemoveCallback = onRemove;
+      onRemove = callbackNoop;
+      onAbort = callbackNoop;
+      onRemoveCallback();
     };
-  }
-  return {
-    valid: true,
-    value: ensurePathnameTrailingSlash(urlString),
-  };
-};
 
-const assertAndNormalizeDirectoryUrl = (
-  directoryUrl,
-  name = "directoryUrl",
-) => {
-  const { valid, message, value } = validateDirectoryUrl(directoryUrl);
-  if (!valid) {
-    throw new TypeError(`${name} ${message}, got ${value}`);
-  }
-  return value;
-};
+    if (operationSignal.aborted) {
+      applyAbortEffects();
+      applyRemoveEffects();
+      return callbackNoop;
+    }
 
-const validateFileUrl = (value, baseUrl) => {
-  let urlString;
+    if (signal.aborted) {
+      operationAbortController.abort();
+      applyAbortEffects();
+      applyRemoveEffects();
+      return callbackNoop;
+    }
 
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value, baseUrl));
-      } catch (e) {
-        return {
-          valid: false,
-          value,
-          message: "must be a valid url",
+    const cancelRace = raceCallbacks(
+      {
+        operation_abort: (cb) => {
+          return addAbortCallback(cb);
+        },
+        operation_end: (cb) => {
+          return addEndCallback(cb);
+        },
+        child_abort: (cb) => {
+          return addEventListener(signal, "abort", cb);
+        },
+      },
+      (winner) => {
+        const raceEffects = {
+          // Both "operation_abort" and "operation_end"
+          // means we don't care anymore if the child aborts.
+          // So we can:
+          // - remove "abort" event listener on child (done by raceCallback)
+          // - remove abort callback on operation (done by raceCallback)
+          // - remove end callback on operation (done by raceCallback)
+          // - call any custom cancel function
+          operation_abort: () => {
+            applyAbortEffects();
+            applyRemoveEffects();
+          },
+          operation_end: () => {
+            // Exists to
+            // - remove abort callback on operation
+            // - remove "abort" event listener on child
+            // - call any custom cancel function
+            applyRemoveEffects();
+          },
+          child_abort: () => {
+            applyAbortEffects();
+            operationAbortController.abort();
+          },
         };
-      }
-    }
-  } else {
-    return {
-      valid: false,
-      value,
-      message: "must be a string or an url",
-    };
-  }
+        raceEffects[winner.name](winner.value);
+      },
+    );
 
-  if (!urlString.startsWith("file://")) {
-    return {
-      valid: false,
-      value,
-      message: 'must start with "file://"',
+    return () => {
+      cancelRace();
+      applyRemoveEffects();
     };
-  }
-
-  return {
-    valid: true,
-    value: urlString,
   };
-};
-
-const assertAndNormalizeFileUrl = (
-  fileUrl,
-  baseUrl,
-  name = "fileUrl",
-) => {
-  const { valid, message, value } = validateFileUrl(fileUrl, baseUrl);
-  if (!valid) {
-    throw new TypeError(`${name} ${message}, got ${fileUrl}`);
-  }
-  return value;
-};
 
-const statsToType = (stats) => {
-  if (stats.isFile()) return "file";
-  if (stats.isDirectory()) return "directory";
-  if (stats.isSymbolicLink()) return "symbolic-link";
-  if (stats.isFIFO()) return "fifo";
-  if (stats.isSocket()) return "socket";
-  if (stats.isCharacterDevice()) return "character-device";
-  if (stats.isBlockDevice()) return "block-device";
-  return undefined;
-};
+  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 abortSource;
+    }
+    const returnValue = abortSourceCallback((value) => {
+      abortSourceController.abort(value);
+    });
+    const removeAbortSignal = addAbortSignal(abortSourceSignal, {
+      onRemove: () => {
+        if (typeof returnValue === "function") {
+          returnValue();
+        }
+        abortSource.cleaned = true;
+      },
+    });
+    abortSource.remove = removeAbortSignal;
+    return abortSource;
+  };
 
-// https://github.com/coderaiser/cloudcmd/issues/63#issuecomment-195478143
-// https://nodejs.org/api/fs.html#fs_file_modes
-// https://github.com/TooTallNate/stat-mode
+  const timeout = (ms) => {
+    return addAbortSource((abort) => {
+      const timeoutId = setTimeout(abort, ms);
+      // an abort source return value is called when:
+      // - operation is aborted (by an other source)
+      // - operation ends
+      return () => {
+        clearTimeout(timeoutId);
+      };
+    });
+  };
 
-// cannot get from fs.constants because they are not available on windows
-const S_IRUSR = 256; /* 0000400 read permission, owner */
-const S_IWUSR = 128; /* 0000200 write permission, owner */
-const S_IXUSR = 64; /* 0000100 execute/search permission, owner */
-const S_IRGRP = 32; /* 0000040 read permission, group */
-const S_IWGRP = 16; /* 0000020 write permission, group */
-const S_IXGRP = 8; /* 0000010 execute/search permission, group */
-const S_IROTH = 4; /* 0000004 read permission, others */
-const S_IWOTH = 2; /* 0000002 write permission, others */
-const S_IXOTH = 1; /* 0000001 execute/search permission, others */
+  const withSignal = async (asyncCallback) => {
+    const abortController = new AbortController();
+    const signal = abortController.signal;
+    const removeAbortSignal = addAbortSignal(signal, {
+      onAbort: () => {
+        abortController.abort();
+      },
+    });
+    try {
+      const value = await asyncCallback(signal);
+      removeAbortSignal();
+      return value;
+    } catch (e) {
+      removeAbortSignal();
+      throw e;
+    }
+  };
 
-const permissionsToBinaryFlags = ({ owner, group, others }) => {
-  let binaryFlags = 0;
+  const withSignalSync = (callback) => {
+    const abortController = new AbortController();
+    const signal = abortController.signal;
+    const removeAbortSignal = addAbortSignal(signal, {
+      onAbort: () => {
+        abortController.abort();
+      },
+    });
+    try {
+      const value = callback(signal);
+      removeAbortSignal();
+      return value;
+    } catch (e) {
+      removeAbortSignal();
+      throw e;
+    }
+  };
 
-  if (owner.read) binaryFlags |= S_IRUSR;
-  if (owner.write) binaryFlags |= S_IWUSR;
-  if (owner.execute) binaryFlags |= S_IXUSR;
+  return {
+    // We could almost hide the operationSignal
+    // But it can be handy for 2 things:
+    // - know if operation is aborted (operation.signal.aborted)
+    // - forward the operation.signal directly (not using "withSignal" or "withSignalSync")
+    signal: operationSignal,
 
-  if (group.read) binaryFlags |= S_IRGRP;
-  if (group.write) binaryFlags |= S_IWGRP;
-  if (group.execute) binaryFlags |= S_IXGRP;
+    throwIfAborted,
+    addAbortCallback,
+    addAbortSignal,
+    addAbortSource,
+    timeout,
+    withSignal,
+    withSignalSync,
+    addEndCallback,
+    end,
+  };
+};
 
-  if (others.read) binaryFlags |= S_IROTH;
-  if (others.write) binaryFlags |= S_IWOTH;
-  if (others.execute) binaryFlags |= S_IXOTH;
+const callbackNoop = () => {};
 
-  return binaryFlags;
+const addEventListener = (target, eventName, cb) => {
+  target.addEventListener(eventName, cb);
+  return () => {
+    target.removeEventListener(eventName, cb);
+  };
 };
 
-const writeEntryPermissions = async (source, permissions) => {
-  const sourceUrl = assertAndNormalizeFileUrl(source);
+const raceProcessTeardownEvents = (processTeardownEvents, callback) => {
+  return raceCallbacks(
+    {
+      ...(processTeardownEvents.SIGHUP ? SIGHUP_CALLBACK : {}),
+      ...(processTeardownEvents.SIGTERM ? SIGTERM_CALLBACK : {}),
+      ...(processTeardownEvents.SIGINT ? SIGINT_CALLBACK : {}),
+      ...(processTeardownEvents.beforeExit ? BEFORE_EXIT_CALLBACK : {}),
+      ...(processTeardownEvents.exit ? EXIT_CALLBACK : {}),
+    },
+    callback,
+  );
+};
 
-  let binaryFlags;
-  if (typeof permissions === "object") {
-    permissions = {
-      owner: {
-        read: getPermissionOrComputeDefault("read", "owner", permissions),
-        write: getPermissionOrComputeDefault("write", "owner", permissions),
-        execute: getPermissionOrComputeDefault("execute", "owner", permissions),
-      },
-      group: {
-        read: getPermissionOrComputeDefault("read", "group", permissions),
-        write: getPermissionOrComputeDefault("write", "group", permissions),
-        execute: getPermissionOrComputeDefault("execute", "group", permissions),
-      },
-      others: {
-        read: getPermissionOrComputeDefault("read", "others", permissions),
-        write: getPermissionOrComputeDefault("write", "others", permissions),
-        execute: getPermissionOrComputeDefault(
-          "execute",
-          "others",
-          permissions,
-        ),
-      },
+const SIGHUP_CALLBACK = {
+  SIGHUP: (cb) => {
+    process.on("SIGHUP", cb);
+    return () => {
+      process.removeListener("SIGHUP", cb);
     };
-    binaryFlags = permissionsToBinaryFlags(permissions);
-  } else {
-    binaryFlags = permissions;
-  }
+  },
+};
 
-  return new Promise((resolve, reject) => {
-    chmod(new URL(sourceUrl), binaryFlags, (error) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
+const SIGTERM_CALLBACK = {
+  SIGTERM: (cb) => {
+    process.on("SIGTERM", cb);
+    return () => {
+      process.removeListener("SIGTERM", cb);
+    };
+  },
 };
 
-const actionLevels = { read: 0, write: 1, execute: 2 };
-const subjectLevels = { others: 0, group: 1, owner: 2 };
+const BEFORE_EXIT_CALLBACK = {
+  beforeExit: (cb) => {
+    process.on("beforeExit", cb);
+    return () => {
+      process.removeListener("beforeExit", cb);
+    };
+  },
+};
 
-const getPermissionOrComputeDefault = (action, subject, permissions) => {
-  if (subject in permissions) {
-    const subjectPermissions = permissions[subject];
-    if (action in subjectPermissions) {
-      return subjectPermissions[action];
-    }
+const EXIT_CALLBACK = {
+  exit: (cb) => {
+    process.on("exit", cb);
+    return () => {
+      process.removeListener("exit", cb);
+    };
+  },
+};
 
-    const actionLevel = actionLevels[action];
-    const actionFallback = Object.keys(actionLevels).find(
-      (actionFallbackCandidate) =>
-        actionLevels[actionFallbackCandidate] > actionLevel &&
-        actionFallbackCandidate in subjectPermissions,
-    );
-    if (actionFallback) {
-      return subjectPermissions[actionFallback];
-    }
-  }
+const SIGINT_CALLBACK = {
+  SIGINT: (cb) => {
+    process.on("SIGINT", cb);
+    return () => {
+      process.removeListener("SIGINT", cb);
+    };
+  },
+};
 
-  const subjectLevel = subjectLevels[subject];
-  // do we have a subject with a stronger level (group or owner)
-  // where we could read the action permission ?
-  const subjectFallback = Object.keys(subjectLevels).find(
-    (subjectFallbackCandidate) =>
-      subjectLevels[subjectFallbackCandidate] > subjectLevel &&
-      subjectFallbackCandidate in permissions,
-  );
-  if (subjectFallback) {
-    const subjectPermissions = permissions[subjectFallback];
-    return action in subjectPermissions
-      ? subjectPermissions[action]
-      : getPermissionOrComputeDefault(action, subjectFallback, permissions);
+const urlToScheme = (url) => {
+  const urlString = String(url);
+  const colonIndex = urlString.indexOf(":");
+  if (colonIndex === -1) {
+    return "";
   }
 
-  return false;
+  const scheme = urlString.slice(0, colonIndex);
+  return scheme;
 };
 
-/*
- * - stats object documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
- */
-
-
-const isWindows$2 = process.platform === "win32";
-
-const readEntryStat = async (
-  source,
-  { nullIfNotFound = false, followLink = true } = {},
-) => {
-  let sourceUrl = assertAndNormalizeFileUrl(source);
-  if (sourceUrl.endsWith("/")) sourceUrl = sourceUrl.slice(0, -1);
-
-  const sourcePath = urlToFileSystemPath(sourceUrl);
+const urlToResource = (url) => {
+  const scheme = urlToScheme(url);
 
-  const handleNotFoundOption = nullIfNotFound
-    ? {
-        handleNotFoundError: () => null,
-      }
-    : {};
+  if (scheme === "file") {
+    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
+    return urlAsStringWithoutFileProtocol;
+  }
 
-  return readStat(sourcePath, {
-    followLink,
-    ...handleNotFoundOption,
-    ...(isWindows$2
-      ? {
-          // Windows can EPERM on stat
-          handlePermissionDeniedError: async (error) => {
-            console.error(
-              `trying to fix windows EPERM after stats on ${sourcePath}`,
-            );
+  if (scheme === "https" || scheme === "http") {
+    // remove origin
+    const afterProtocol = String(url).slice(scheme.length + "://".length);
+    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
+    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex);
+    return urlAsStringWithoutOrigin;
+  }
 
-            try {
-              // unfortunately it means we mutate the permissions
-              // without being able to restore them to the previous value
-              // (because reading current permission would also throw)
-              await writeEntryPermissions(sourceUrl, 0o666);
-              const stats = await readStat(sourcePath, {
-                followLink,
-                ...handleNotFoundOption,
-                // could not fix the permission error, give up and throw original error
-                handlePermissionDeniedError: () => {
-                  console.error(`still got EPERM after stats on ${sourcePath}`);
-                  throw error;
-                },
-              });
-              return stats;
-            } catch (e) {
-              console.error(
-                `error while trying to fix windows EPERM after stats on ${sourcePath}: ${e.stack}`,
-              );
-              throw error;
-            }
-          },
-        }
-      : {}),
-  });
+  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1);
+  return urlAsStringWithoutProtocol;
 };
 
-const readStat = (
-  sourcePath,
-  {
-    followLink,
-    handleNotFoundError = null,
-    handlePermissionDeniedError = null,
-  } = {},
-) => {
-  const nodeMethod = followLink ? stat : lstat;
-
-  return new Promise((resolve, reject) => {
-    nodeMethod(sourcePath, (error, statsObject) => {
-      if (error) {
-        if (handleNotFoundError && error.code === "ENOENT") {
-          resolve(handleNotFoundError(error));
-        } else if (
-          handlePermissionDeniedError &&
-          (error.code === "EPERM" || error.code === "EACCES")
-        ) {
-          resolve(handlePermissionDeniedError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(statsObject);
-      }
-    });
-  });
+const urlToPathname = (url) => {
+  const resource = urlToResource(url);
+  const pathname = resourceToPathname(resource);
+  return pathname;
 };
 
-/*
- * See callback_race.md
- */
+const resourceToPathname = (resource) => {
+  const searchSeparatorIndex = resource.indexOf("?");
+  if (searchSeparatorIndex > -1) {
+    return resource.slice(0, searchSeparatorIndex);
+  }
+  const hashIndex = resource.indexOf("#");
+  if (hashIndex > -1) {
+    return resource.slice(0, hashIndex);
+  }
+  return resource;
+};
 
-const raceCallbacks = (raceDescription, winnerCallback) => {
-  let cleanCallbacks = [];
-  let status = "racing";
+const urlToExtension = (url) => {
+  const pathname = urlToPathname(url);
+  return pathnameToExtension(pathname);
+};
 
-  const clean = () => {
-    cleanCallbacks.forEach((clean) => {
-      clean();
-    });
-    cleanCallbacks = null;
-  };
+const pathnameToExtension = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex !== -1) {
+    pathname = pathname.slice(slashLastIndex + 1);
+  }
 
-  const cancel = () => {
-    if (status !== "racing") {
-      return;
-    }
-    status = "cancelled";
-    clean();
-  };
+  const dotLastIndex = pathname.lastIndexOf(".");
+  if (dotLastIndex === -1) return "";
+  // if (dotLastIndex === pathname.length - 1) return ""
+  const extension = pathname.slice(dotLastIndex);
+  return extension;
+};
 
-  Object.keys(raceDescription).forEach((candidateName) => {
-    const register = raceDescription[candidateName];
-    const returnValue = register((data) => {
-      if (status !== "racing") {
-        return;
-      }
-      status = "done";
-      clean();
-      winnerCallback({
-        name: candidateName,
-        data,
-      });
-    });
-    if (typeof returnValue === "function") {
-      cleanCallbacks.push(returnValue);
-    }
-  });
+const ensurePathnameTrailingSlash = (url) => {
+  const urlObject = new URL(url);
+  const { pathname } = urlObject;
+  if (pathname.endsWith("/")) {
+    return url;
+  }
+  let { origin } = urlObject;
+  // origin is "null" for "file://" urls with Node.js
+  if (origin === "null" && urlObject.href.startsWith("file:")) {
+    origin = "file://";
+  }
+  const { search, hash } = urlObject;
+  return `${origin}${pathname}/${search}${hash}`;
+};
 
-  return cancel;
+const isFileSystemPath = (value) => {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `isFileSystemPath first arg must be a string, got ${value}`,
+    );
+  }
+  if (value[0] === "/") {
+    return true;
+  }
+  return startsWithWindowsDriveLetter(value);
 };
 
-const createCallbackListNotifiedOnce = () => {
-  let callbacks = [];
-  let status = "waiting";
-  let currentCallbackIndex = -1;
+const startsWithWindowsDriveLetter = (string) => {
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
 
-  const callbackListOnce = {};
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
 
-  const add = (callback) => {
-    if (status !== "waiting") {
-      emitUnexpectedActionWarning({ action: "add", status });
-      return removeNoop;
-    }
+  return true;
+};
 
-    if (typeof callback !== "function") {
-      throw new Error(`callback must be a function, got ${callback}`);
-    }
+const fileSystemPathToUrl = (value) => {
+  if (!isFileSystemPath(value)) {
+    throw new Error(`value must be a filesystem path, got ${value}`);
+  }
+  return String(pathToFileURL(value));
+};
 
-    // don't register twice
-    const existingCallback = callbacks.find((callbackCandidate) => {
-      return callbackCandidate === callback;
-    });
-    if (existingCallback) {
-      emitCallbackDuplicationWarning();
-      return removeNoop;
-    }
+const resolveUrl = (specifier, baseUrl) => {
+  if (typeof baseUrl === "undefined") {
+    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
+  }
+  return String(new URL(specifier, baseUrl));
+};
 
-    callbacks.push(callback);
-    return () => {
-      if (status === "notified") {
-        // once called removing does nothing
-        // as the callbacks array is frozen to null
-        return;
+const getCommonPathname = (pathname, otherPathname) => {
+  if (pathname === otherPathname) {
+    return pathname;
+  }
+  let commonPart = "";
+  let commonPathname = "";
+  let i = 0;
+  const length = pathname.length;
+  const otherLength = otherPathname.length;
+  while (i < length) {
+    const char = pathname.charAt(i);
+    const otherChar = otherPathname.charAt(i);
+    i++;
+    if (char === otherChar) {
+      if (char === "/") {
+        commonPart += "/";
+        commonPathname += commonPart;
+        commonPart = "";
+      } else {
+        commonPart += char;
       }
-
-      const index = callbacks.indexOf(callback);
-      if (index === -1) {
-        return;
+    } else {
+      if (char === "/" && i - 1 === otherLength) {
+        commonPart += "/";
+        commonPathname += commonPart;
       }
+      return commonPathname;
+    }
+  }
+  if (length === otherLength) {
+    commonPathname += commonPart;
+  } else if (otherPathname.charAt(i) === "/") {
+    commonPathname += commonPart;
+  }
+  return commonPathname;
+};
 
-      if (status === "looping") {
-        if (index <= currentCallbackIndex) {
-          // The callback was already called (or is the current callback)
-          // We don't want to mutate the callbacks array
-          // or it would alter the looping done in "call" and the next callback
-          // would be skipped
-          return;
-        }
+const urlToRelativeUrl = (url, baseUrl) => {
+  const urlObject = new URL(url);
+  const baseUrlObject = new URL(baseUrl);
 
-        // Callback is part of the next callback to call,
-        // we mutate the callbacks array to prevent this callback to be called
-      }
+  if (urlObject.protocol !== baseUrlObject.protocol) {
+    const urlAsString = String(url);
+    return urlAsString;
+  }
 
-      callbacks.splice(index, 1);
-    };
-  };
+  if (
+    urlObject.username !== baseUrlObject.username ||
+    urlObject.password !== baseUrlObject.password ||
+    urlObject.host !== baseUrlObject.host
+  ) {
+    const afterUrlScheme = String(url).slice(urlObject.protocol.length);
+    return afterUrlScheme;
+  }
 
-  const notify = (param) => {
-    if (status !== "waiting") {
-      emitUnexpectedActionWarning({ action: "call", status });
-      return [];
-    }
-    status = "looping";
-    const values = callbacks.map((callback, index) => {
-      currentCallbackIndex = index;
-      return callback(param);
-    });
-    callbackListOnce.notified = true;
-    status = "notified";
-    // we reset callbacks to null after looping
-    // so that it's possible to remove during the loop
-    callbacks = null;
-    currentCallbackIndex = -1;
+  const { pathname, hash, search } = urlObject;
+  if (pathname === "/") {
+    const baseUrlResourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1);
+    return baseUrlResourceWithoutLeadingSlash;
+  }
 
-    return values;
-  };
+  const basePathname = baseUrlObject.pathname;
+  const commonPathname = getCommonPathname(pathname, basePathname);
+  if (!commonPathname) {
+    const urlAsString = String(url);
+    return urlAsString;
+  }
+  const specificPathname = pathname.slice(commonPathname.length);
+  const baseSpecificPathname = basePathname.slice(commonPathname.length);
+  if (baseSpecificPathname.includes("/")) {
+    const baseSpecificParentPathname =
+      pathnameToParentPathname(baseSpecificPathname);
+    const relativeDirectoriesNotation = baseSpecificParentPathname.replace(
+      /.*?\//g,
+      "../",
+    );
+    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`;
+    return relativeUrl;
+  }
 
-  callbackListOnce.notified = false;
-  callbackListOnce.add = add;
-  callbackListOnce.notify = notify;
+  const relativeUrl = `${specificPathname}${search}${hash}`;
+  return relativeUrl;
+};
 
-  return callbackListOnce;
+const pathnameToParentPathname = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return "/";
+  }
+  return pathname.slice(0, slashLastIndex + 1);
 };
 
-const emitUnexpectedActionWarning = ({ action, status }) => {
-  if (typeof process.emitWarning === "function") {
-    process.emitWarning(
-      `"${action}" should not happen when callback list is ${status}`,
-      {
-        CODE: "UNEXPECTED_ACTION_ON_CALLBACK_LIST",
-        detail: `Code is potentially executed when it should not`,
-      },
-    );
-  } else {
-    console.warn(
-      `"${action}" should not happen when callback list is ${status}`,
-    );
+const moveUrl = ({ url, from, to, preferRelative }) => {
+  let relativeUrl = urlToRelativeUrl(url, from);
+  if (relativeUrl.slice(0, 2) === "//") {
+    // restore the protocol
+    relativeUrl = new URL(relativeUrl, url).href;
+  }
+  const absoluteUrl = new URL(relativeUrl, to).href;
+  if (preferRelative) {
+    return urlToRelativeUrl(absoluteUrl, to);
   }
+  return absoluteUrl;
 };
 
-const emitCallbackDuplicationWarning = () => {
-  if (typeof process.emitWarning === "function") {
-    process.emitWarning(`Trying to add a callback already in the list`, {
-      CODE: "CALLBACK_DUPLICATION",
-      detail: `Code is potentially executed more than it should`,
-    });
-  } else {
-    console.warn(`Trying to add same callback twice`);
-  }
-};
+const urlIsInsideOf = (url, otherUrl) => {
+  const urlObject = new URL(url);
+  const otherUrlObject = new URL(otherUrl);
 
-const removeNoop = () => {};
+  if (urlObject.origin !== otherUrlObject.origin) {
+    return false;
+  }
 
-/*
- * https://github.com/whatwg/dom/issues/920
- */
+  const urlPathname = urlObject.pathname;
+  const otherUrlPathname = otherUrlObject.pathname;
+  if (urlPathname === otherUrlPathname) {
+    return false;
+  }
 
+  const isInside = urlPathname.startsWith(otherUrlPathname);
+  return isInside;
+};
 
-const Abort = {
-  isAbortError: (error) => {
-    return error && error.name === "AbortError";
-  },
+const urlToFileSystemPath = (url) => {
+  let urlString = String(url);
+  if (urlString[urlString.length - 1] === "/") {
+    // remove trailing / so that nodejs path becomes predictable otherwise it logs
+    // the trailing slash on linux but does not on windows
+    urlString = urlString.slice(0, -1);
+  }
+  const fileSystemPath = fileURLToPath(urlString);
+  return fileSystemPath;
+};
 
-  startOperation: () => {
-    return createOperation();
-  },
+const validateDirectoryUrl = (value) => {
+  let urlString;
 
-  throwIfAborted: (signal) => {
-    if (signal.aborted) {
-      const error = new Error(`The operation was aborted`);
-      error.name = "AbortError";
-      error.type = "aborted";
-      throw error;
+  if (value instanceof URL) {
+    urlString = value.href;
+  } else if (typeof value === "string") {
+    if (isFileSystemPath(value)) {
+      urlString = fileSystemPathToUrl(value);
+    } else {
+      try {
+        urlString = String(new URL(value));
+      } catch (e) {
+        return {
+          valid: false,
+          value,
+          message: `must be a valid url`,
+        };
+      }
     }
-  },
+  } else {
+    return {
+      valid: false,
+      value,
+      message: `must be a string or an url`,
+    };
+  }
+  if (!urlString.startsWith("file://")) {
+    return {
+      valid: false,
+      value,
+      message: 'must start with "file://"',
+    };
+  }
+  return {
+    valid: true,
+    value: ensurePathnameTrailingSlash(urlString),
+  };
 };
 
-const createOperation = () => {
-  const operationAbortController = new AbortController();
-  // const abortOperation = (value) => abortController.abort(value)
-  const operationSignal = operationAbortController.signal;
+const assertAndNormalizeDirectoryUrl = (
+  directoryUrl,
+  name = "directoryUrl",
+) => {
+  const { valid, message, value } = validateDirectoryUrl(directoryUrl);
+  if (!valid) {
+    throw new TypeError(`${name} ${message}, got ${value}`);
+  }
+  return value;
+};
 
-  // abortCallbackList is used to ignore the max listeners warning from Node.js
-  // this warning is useful but becomes problematic when it's expected
-  // (a function doing 20 http call in parallel)
-  // To be 100% sure we don't have memory leak, only Abortable.asyncCallback
-  // uses abortCallbackList to know when something is aborted
-  const abortCallbackList = createCallbackListNotifiedOnce();
-  const endCallbackList = createCallbackListNotifiedOnce();
+const validateFileUrl = (value, baseUrl) => {
+  let urlString;
 
-  let isAbortAfterEnd = false;
+  if (value instanceof URL) {
+    urlString = value.href;
+  } else if (typeof value === "string") {
+    if (isFileSystemPath(value)) {
+      urlString = fileSystemPathToUrl(value);
+    } else {
+      try {
+        urlString = String(new URL(value, baseUrl));
+      } catch (e) {
+        return {
+          valid: false,
+          value,
+          message: "must be a valid url",
+        };
+      }
+    }
+  } else {
+    return {
+      valid: false,
+      value,
+      message: "must be a string or an url",
+    };
+  }
 
-  operationSignal.onabort = () => {
-    operationSignal.onabort = null;
+  if (!urlString.startsWith("file://")) {
+    return {
+      valid: false,
+      value,
+      message: 'must start with "file://"',
+    };
+  }
 
-    const allAbortCallbacksPromise = Promise.all(abortCallbackList.notify());
-    if (!isAbortAfterEnd) {
-      addEndCallback(async () => {
-        await allAbortCallbacksPromise;
-      });
-    }
+  return {
+    valid: true,
+    value: urlString,
   };
+};
 
-  const throwIfAborted = () => {
-    Abort.throwIfAborted(operationSignal);
-  };
+const assertAndNormalizeFileUrl = (
+  fileUrl,
+  baseUrl,
+  name = "fileUrl",
+) => {
+  const { valid, message, value } = validateFileUrl(fileUrl, baseUrl);
+  if (!valid) {
+    throw new TypeError(`${name} ${message}, got ${fileUrl}`);
+  }
+  return value;
+};
 
-  // add a callback called on abort
-  // differences with signal.addEventListener('abort')
-  // - operation.end awaits the return value of this callback
-  // - It won't increase the count of listeners for "abort" that would
-  //   trigger max listeners warning when count > 10
-  const addAbortCallback = (callback) => {
-    // It would be painful and not super redable to check if signal is aborted
-    // before deciding if it's an abort or end callback
-    // with pseudo-code below where we want to stop server either
-    // on abort or when ended because signal is aborted
-    // operation[operation.signal.aborted ? 'addAbortCallback': 'addEndCallback'](async () => {
-    //   await server.stop()
-    // })
-    if (operationSignal.aborted) {
-      return addEndCallback(callback);
-    }
-    return abortCallbackList.add(callback);
-  };
+const statsToType = (stats) => {
+  if (stats.isFile()) return "file";
+  if (stats.isDirectory()) return "directory";
+  if (stats.isSymbolicLink()) return "symbolic-link";
+  if (stats.isFIFO()) return "fifo";
+  if (stats.isSocket()) return "socket";
+  if (stats.isCharacterDevice()) return "character-device";
+  if (stats.isBlockDevice()) return "block-device";
+  return undefined;
+};
 
-  const addEndCallback = (callback) => {
-    return endCallbackList.add(callback);
-  };
+// https://github.com/coderaiser/cloudcmd/issues/63#issuecomment-195478143
+// https://nodejs.org/api/fs.html#fs_file_modes
+// https://github.com/TooTallNate/stat-mode
 
-  const end = async ({ abortAfterEnd = false } = {}) => {
-    await Promise.all(endCallbackList.notify());
+// cannot get from fs.constants because they are not available on windows
+const S_IRUSR = 256; /* 0000400 read permission, owner */
+const S_IWUSR = 128; /* 0000200 write permission, owner */
+const S_IXUSR = 64; /* 0000100 execute/search permission, owner */
+const S_IRGRP = 32; /* 0000040 read permission, group */
+const S_IWGRP = 16; /* 0000020 write permission, group */
+const S_IXGRP = 8; /* 0000010 execute/search permission, group */
+const S_IROTH = 4; /* 0000004 read permission, others */
+const S_IWOTH = 2; /* 0000002 write permission, others */
+const S_IXOTH = 1; /* 0000001 execute/search permission, others */
 
-    // "abortAfterEnd" can be handy to ensure "abort" callbacks
-    // added with { once: true } are removed
-    // It might also help garbage collection because
-    // runtime implementing AbortSignal (Node.js, browsers) can consider abortSignal
-    // as settled and clean up things
-    if (abortAfterEnd) {
-      // because of operationSignal.onabort = null
-      // + abortCallbackList.clear() this won't re-call
-      // callbacks
-      if (!operationSignal.aborted) {
-        isAbortAfterEnd = true;
-        operationAbortController.abort();
-      }
-    }
-  };
+const permissionsToBinaryFlags = ({ owner, group, others }) => {
+  let binaryFlags = 0;
 
-  const addAbortSignal = (
-    signal,
-    { onAbort = callbackNoop, onRemove = callbackNoop } = {},
-  ) => {
-    const applyAbortEffects = () => {
-      const onAbortCallback = onAbort;
-      onAbort = callbackNoop;
-      onAbortCallback();
-    };
-    const applyRemoveEffects = () => {
-      const onRemoveCallback = onRemove;
-      onRemove = callbackNoop;
-      onAbort = callbackNoop;
-      onRemoveCallback();
-    };
+  if (owner.read) binaryFlags |= S_IRUSR;
+  if (owner.write) binaryFlags |= S_IWUSR;
+  if (owner.execute) binaryFlags |= S_IXUSR;
+
+  if (group.read) binaryFlags |= S_IRGRP;
+  if (group.write) binaryFlags |= S_IWGRP;
+  if (group.execute) binaryFlags |= S_IXGRP;
 
-    if (operationSignal.aborted) {
-      applyAbortEffects();
-      applyRemoveEffects();
-      return callbackNoop;
-    }
+  if (others.read) binaryFlags |= S_IROTH;
+  if (others.write) binaryFlags |= S_IWOTH;
+  if (others.execute) binaryFlags |= S_IXOTH;
 
-    if (signal.aborted) {
-      operationAbortController.abort();
-      applyAbortEffects();
-      applyRemoveEffects();
-      return callbackNoop;
-    }
+  return binaryFlags;
+};
 
-    const cancelRace = raceCallbacks(
-      {
-        operation_abort: (cb) => {
-          return addAbortCallback(cb);
-        },
-        operation_end: (cb) => {
-          return addEndCallback(cb);
-        },
-        child_abort: (cb) => {
-          return addEventListener(signal, "abort", cb);
-        },
+const writeEntryPermissions = async (source, permissions) => {
+  const sourceUrl = assertAndNormalizeFileUrl(source);
+
+  let binaryFlags;
+  if (typeof permissions === "object") {
+    permissions = {
+      owner: {
+        read: getPermissionOrComputeDefault("read", "owner", permissions),
+        write: getPermissionOrComputeDefault("write", "owner", permissions),
+        execute: getPermissionOrComputeDefault("execute", "owner", permissions),
       },
-      (winner) => {
-        const raceEffects = {
-          // Both "operation_abort" and "operation_end"
-          // means we don't care anymore if the child aborts.
-          // So we can:
-          // - remove "abort" event listener on child (done by raceCallback)
-          // - remove abort callback on operation (done by raceCallback)
-          // - remove end callback on operation (done by raceCallback)
-          // - call any custom cancel function
-          operation_abort: () => {
-            applyAbortEffects();
-            applyRemoveEffects();
-          },
-          operation_end: () => {
-            // Exists to
-            // - remove abort callback on operation
-            // - remove "abort" event listener on child
-            // - call any custom cancel function
-            applyRemoveEffects();
-          },
-          child_abort: () => {
-            applyAbortEffects();
-            operationAbortController.abort();
-          },
-        };
-        raceEffects[winner.name](winner.value);
+      group: {
+        read: getPermissionOrComputeDefault("read", "group", permissions),
+        write: getPermissionOrComputeDefault("write", "group", permissions),
+        execute: getPermissionOrComputeDefault("execute", "group", permissions),
+      },
+      others: {
+        read: getPermissionOrComputeDefault("read", "others", permissions),
+        write: getPermissionOrComputeDefault("write", "others", permissions),
+        execute: getPermissionOrComputeDefault(
+          "execute",
+          "others",
+          permissions,
+        ),
       },
-    );
-
-    return () => {
-      cancelRace();
-      applyRemoveEffects();
     };
-  };
+    binaryFlags = permissionsToBinaryFlags(permissions);
+  } else {
+    binaryFlags = permissions;
+  }
 
-  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 abortSource;
-    }
-    const returnValue = abortSourceCallback((value) => {
-      abortSourceController.abort(value);
-    });
-    const removeAbortSignal = addAbortSignal(abortSourceSignal, {
-      onRemove: () => {
-        if (typeof returnValue === "function") {
-          returnValue();
-        }
-        abortSource.cleaned = true;
-      },
+  return new Promise((resolve, reject) => {
+    chmod(new URL(sourceUrl), binaryFlags, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
     });
-    abortSource.remove = removeAbortSignal;
-    return abortSource;
-  };
+  });
+};
 
-  const timeout = (ms) => {
-    return addAbortSource((abort) => {
-      const timeoutId = setTimeout(abort, ms);
-      // an abort source return value is called when:
-      // - operation is aborted (by an other source)
-      // - operation ends
-      return () => {
-        clearTimeout(timeoutId);
-      };
-    });
-  };
+const actionLevels = { read: 0, write: 1, execute: 2 };
+const subjectLevels = { others: 0, group: 1, owner: 2 };
 
-  const withSignal = async (asyncCallback) => {
-    const abortController = new AbortController();
-    const signal = abortController.signal;
-    const removeAbortSignal = addAbortSignal(signal, {
-      onAbort: () => {
-        abortController.abort();
-      },
-    });
-    try {
-      const value = await asyncCallback(signal);
-      removeAbortSignal();
-      return value;
-    } catch (e) {
-      removeAbortSignal();
-      throw e;
+const getPermissionOrComputeDefault = (action, subject, permissions) => {
+  if (subject in permissions) {
+    const subjectPermissions = permissions[subject];
+    if (action in subjectPermissions) {
+      return subjectPermissions[action];
     }
-  };
 
-  const withSignalSync = (callback) => {
-    const abortController = new AbortController();
-    const signal = abortController.signal;
-    const removeAbortSignal = addAbortSignal(signal, {
-      onAbort: () => {
-        abortController.abort();
-      },
-    });
-    try {
-      const value = callback(signal);
-      removeAbortSignal();
-      return value;
-    } catch (e) {
-      removeAbortSignal();
-      throw e;
+    const actionLevel = actionLevels[action];
+    const actionFallback = Object.keys(actionLevels).find(
+      (actionFallbackCandidate) =>
+        actionLevels[actionFallbackCandidate] > actionLevel &&
+        actionFallbackCandidate in subjectPermissions,
+    );
+    if (actionFallback) {
+      return subjectPermissions[actionFallback];
     }
-  };
+  }
 
-  return {
-    // We could almost hide the operationSignal
-    // But it can be handy for 2 things:
-    // - know if operation is aborted (operation.signal.aborted)
-    // - forward the operation.signal directly (not using "withSignal" or "withSignalSync")
-    signal: operationSignal,
+  const subjectLevel = subjectLevels[subject];
+  // do we have a subject with a stronger level (group or owner)
+  // where we could read the action permission ?
+  const subjectFallback = Object.keys(subjectLevels).find(
+    (subjectFallbackCandidate) =>
+      subjectLevels[subjectFallbackCandidate] > subjectLevel &&
+      subjectFallbackCandidate in permissions,
+  );
+  if (subjectFallback) {
+    const subjectPermissions = permissions[subjectFallback];
+    return action in subjectPermissions
+      ? subjectPermissions[action]
+      : getPermissionOrComputeDefault(action, subjectFallback, permissions);
+  }
 
-    throwIfAborted,
-    addAbortCallback,
-    addAbortSignal,
-    addAbortSource,
-    timeout,
-    withSignal,
-    withSignalSync,
-    addEndCallback,
-    end,
-  };
+  return false;
 };
 
-const callbackNoop = () => {};
+/*
+ * - stats object documentation on Node.js
+ *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
+ */
 
-const addEventListener = (target, eventName, cb) => {
-  target.addEventListener(eventName, cb);
-  return () => {
-    target.removeEventListener(eventName, cb);
-  };
-};
 
-const raceProcessTeardownEvents = (processTeardownEvents, callback) => {
-  return raceCallbacks(
-    {
-      ...(processTeardownEvents.SIGHUP ? SIGHUP_CALLBACK : {}),
-      ...(processTeardownEvents.SIGTERM ? SIGTERM_CALLBACK : {}),
-      ...(processTeardownEvents.SIGINT ? SIGINT_CALLBACK : {}),
-      ...(processTeardownEvents.beforeExit ? BEFORE_EXIT_CALLBACK : {}),
-      ...(processTeardownEvents.exit ? EXIT_CALLBACK : {}),
-    },
-    callback,
-  );
-};
+const isWindows$2 = process.platform === "win32";
 
-const SIGHUP_CALLBACK = {
-  SIGHUP: (cb) => {
-    process.on("SIGHUP", cb);
-    return () => {
-      process.removeListener("SIGHUP", cb);
-    };
-  },
-};
+const readEntryStat = async (
+  source,
+  { nullIfNotFound = false, followLink = true } = {},
+) => {
+  let sourceUrl = assertAndNormalizeFileUrl(source);
+  if (sourceUrl.endsWith("/")) sourceUrl = sourceUrl.slice(0, -1);
+
+  const sourcePath = urlToFileSystemPath(sourceUrl);
+
+  const handleNotFoundOption = nullIfNotFound
+    ? {
+        handleNotFoundError: () => null,
+      }
+    : {};
 
-const SIGTERM_CALLBACK = {
-  SIGTERM: (cb) => {
-    process.on("SIGTERM", cb);
-    return () => {
-      process.removeListener("SIGTERM", cb);
-    };
-  },
-};
+  return readStat(sourcePath, {
+    followLink,
+    ...handleNotFoundOption,
+    ...(isWindows$2
+      ? {
+          // Windows can EPERM on stat
+          handlePermissionDeniedError: async (error) => {
+            console.error(
+              `trying to fix windows EPERM after stats on ${sourcePath}`,
+            );
 
-const BEFORE_EXIT_CALLBACK = {
-  beforeExit: (cb) => {
-    process.on("beforeExit", cb);
-    return () => {
-      process.removeListener("beforeExit", cb);
-    };
-  },
+            try {
+              // unfortunately it means we mutate the permissions
+              // without being able to restore them to the previous value
+              // (because reading current permission would also throw)
+              await writeEntryPermissions(sourceUrl, 0o666);
+              const stats = await readStat(sourcePath, {
+                followLink,
+                ...handleNotFoundOption,
+                // could not fix the permission error, give up and throw original error
+                handlePermissionDeniedError: () => {
+                  console.error(`still got EPERM after stats on ${sourcePath}`);
+                  throw error;
+                },
+              });
+              return stats;
+            } catch (e) {
+              console.error(
+                `error while trying to fix windows EPERM after stats on ${sourcePath}: ${e.stack}`,
+              );
+              throw error;
+            }
+          },
+        }
+      : {}),
+  });
 };
 
-const EXIT_CALLBACK = {
-  exit: (cb) => {
-    process.on("exit", cb);
-    return () => {
-      process.removeListener("exit", cb);
-    };
-  },
-};
+const readStat = (
+  sourcePath,
+  {
+    followLink,
+    handleNotFoundError = null,
+    handlePermissionDeniedError = null,
+  } = {},
+) => {
+  const nodeMethod = followLink ? stat : lstat;
 
-const SIGINT_CALLBACK = {
-  SIGINT: (cb) => {
-    process.on("SIGINT", cb);
-    return () => {
-      process.removeListener("SIGINT", cb);
-    };
-  },
+  return new Promise((resolve, reject) => {
+    nodeMethod(sourcePath, (error, statsObject) => {
+      if (error) {
+        if (handleNotFoundError && error.code === "ENOENT") {
+          resolve(handleNotFoundError(error));
+        } else if (
+          handlePermissionDeniedError &&
+          (error.code === "EPERM" || error.code === "EACCES")
+        ) {
+          resolve(handlePermissionDeniedError(error));
+        } else {
+          reject(error);
+        }
+      } else {
+        resolve(statsObject);
+      }
+    });
+  });
 };
 
 const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
@@ -2708,6 +2708,22 @@ const startSpinner = ({
   return spinner;
 };
 
+const createTeardown = () => {
+  const teardownCallbackSet = new Set();
+  return {
+    addCallback: (callback) => {
+      teardownCallbackSet.add(callback);
+    },
+    trigger: async () => {
+      await Promise.all(
+        Array.from(teardownCallbackSet.values()).map(async (callback) => {
+          await callback();
+        }),
+      );
+    },
+  };
+};
+
 const generateCoverageJsonFile = async ({
   coverage,
   coverageJsonFileUrl,
@@ -2812,6 +2828,208 @@ const pingServer = async (url) => {
   return false;
 };
 
+const startServerUsingModuleUrl = async (
+  webServer,
+  { signal, teardown, logger, allocatedMs },
+) => {
+  if (!existsSync(new URL(webServer.moduleUrl))) {
+    throw new Error(
+      `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
+    );
+  }
+  const worker = new Worker(webServer.moduleUrl, {
+    env: {
+      // IMPORTED_BY_TEST_PLAN: "1",
+    },
+    stdin: true,
+    stdout: true,
+  });
+  let errorReceived = false;
+  const errorPromise = new Promise((resolve, reject) => {
+    worker.on("error", (e) => {
+      errorReceived = true;
+      reject(e);
+    });
+  });
+
+  const killWorker = async () => {
+    await worker.terminate();
+  };
+
+  const startOperation = Abort.startOperation();
+  startOperation.addAbortSignal(signal);
+  const timeoutAbortSource = startOperation.timeout(allocatedMs);
+  startOperation.addAbortCallback(killWorker);
+  teardown.addCallback(killWorker);
+
+  const startedPromise = (async () => {
+    const logScale = [100, 250, 500];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (errorReceived) {
+        break;
+      }
+      const connected = await pingServer(webServer.origin);
+      if (connected) {
+        break;
+      }
+
+      startOperation.throwIfAborted();
+      const delay = logScale.shift() || 1000;
+      logger.debug(`Waiting ${delay}ms`);
+      await new Promise((x) => setTimeout(x, delay));
+    }
+  })();
+
+  try {
+    await Promise.race([errorPromise, startedPromise]);
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource.signal.aborted) {
+        // aborted by timeout
+        throw new Error(
+          `"${webServer.moduleUrl}" did not start a server in less than ${allocatedMs}ms (webServer.moduleUrl)`,
+        );
+      }
+      if (signal.aborted) {
+        // aborted from outside
+        return;
+      }
+    }
+    throw e;
+  } finally {
+    await startOperation.end();
+  }
+};
+
+const startServerUsingCommand = async (
+  webServer,
+  { signal, allocatedMs, logger, teardown },
+) => {
+  const spawnedProcess = spawn(webServer.command, [], {
+    // On non-windows platforms, `detached: true` makes child process a leader of a new
+    // process group, making it possible to kill child process tree with `.kill(-pid)` command.
+    // @see https://nodejs.org/api/child_process.html#child_process_options_detached
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: true,
+    cwd: webServer.cwd,
+  });
+  if (!spawnedProcess.pid) {
+    await new Promise((resolve, reject) => {
+      spawnedProcess.once("error", (error) => {
+        reject(new Error(`Failed to launch: ${error}`));
+      });
+    });
+  }
+
+  let errorReceived = false;
+  const errorPromise = new Promise((resolve, reject) => {
+    spawnedProcess.on("error", (e) => {
+      errorReceived = true;
+      reject(e);
+    });
+  });
+
+  // const stdout = readline.createInterface({ input: spawnedProcess.stdout });
+  // stdout.on("line", () => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][out] ${data}`);
+  // });
+  // const stderr = readline.createInterface({ input: spawnedProcess.stderr });
+  // stderr.on("line", (data) => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][err] ${data}`);
+  // });
+  let processClosed = false;
+  const closedPromise = new Promise((resolve) => {
+    spawnedProcess.once("exit", (exitCode, signal) => {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] <process did exit: exitCode=${exitCode}, signal=${signal}>`,
+      );
+      processClosed = true;
+      resolve();
+    });
+  });
+  const killProcess = async () => {
+    logger.info(`[pid=${spawnedProcess.pid}] <kill>`);
+    if (!spawnedProcess.pid || spawnedProcess.killed || processClosed) {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] <skipped force kill spawnedProcess.killed=${spawnedProcess.killed} processClosed=${processClosed}>`,
+      );
+      return;
+    }
+    logger.info(`[pid=${spawnedProcess.pid}] <will force kill>`);
+    // Force kill the browser.
+    try {
+      if (process.platform === "win32") {
+        const taskkillProcess = spawnSync(
+          `taskkill /pid ${spawnedProcess.pid} /T /F`,
+          { shell: true },
+        );
+        const [stdout, stderr] = [
+          taskkillProcess.stdout.toString(),
+          taskkillProcess.stderr.toString(),
+        ];
+        if (stdout)
+          logger.info(`[pid=${spawnedProcess.pid}] taskkill stdout: ${stdout}`);
+        if (stderr)
+          logger.info(`[pid=${spawnedProcess.pid}] taskkill stderr: ${stderr}`);
+      } else {
+        process.kill(-spawnedProcess.pid, "SIGKILL");
+      }
+    } catch (e) {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] exception while trying to kill process: ${e}`,
+      );
+      // the process might have already stopped
+    }
+    await closedPromise;
+  };
+
+  const startOperation = Abort.startOperation();
+  startOperation.addAbortSignal(signal);
+  const timeoutAbortSource = startOperation.timeout(allocatedMs);
+  startOperation.addAbortCallback(killProcess);
+  teardown.addCallback(killProcess);
+
+  const startedPromise = (async () => {
+    const logScale = [100, 250, 500];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (errorReceived) {
+        break;
+      }
+      const connected = await pingServer(webServer.origin);
+      if (connected) {
+        break;
+      }
+      startOperation.throwIfAborted();
+      const delay = logScale.shift() || 1000;
+      logger.debug(`Waiting ${delay}ms`);
+      await new Promise((x) => setTimeout(x, delay));
+    }
+  })();
+
+  try {
+    await Promise.race([errorPromise, startedPromise]);
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource.signal.aborted) {
+        // aborted by timeout
+        throw new Error(
+          `"${webServer.command}" command did not start a server in less than ${allocatedMs}ms (webServer.command)`,
+        );
+      }
+      if (signal.aborted) {
+        // aborted from outside
+        return;
+      }
+    }
+    throw e;
+  } finally {
+    await startOperation.end();
+  }
+};
+
 const basicFetch = async (
   url,
   { rejectUnauthorized = true, method = "GET", headers = {} } = {},
@@ -2866,50 +3084,39 @@ const basicFetch = async (
   });
 };
 
-const assertAndNormalizeWebServer = async (webServer) => {
+const assertAndNormalizeWebServer = async (
+  webServer,
+  { signal, logger, teardown },
+) => {
   if (!webServer) {
     throw new TypeError(
       `webServer is required when running tests on browser(s)`,
     );
   }
   const unexpectedParamNames = Object.keys(webServer).filter((key) => {
-    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key);
+    return ![
+      "origin",
+      "moduleUrl",
+      "command",
+      "cwd",
+      "rootDirectoryUrl",
+    ].includes(key);
   });
   if (unexpectedParamNames.length > 0) {
     throw new TypeError(
       `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
     );
   }
-
-  let aServerIsListening = await pingServer(webServer.origin);
-  if (!aServerIsListening) {
-    if (!webServer.moduleUrl) {
-      throw new TypeError(
-        `webServer.moduleUrl is required as there is no server listening "${webServer.origin}"`,
-      );
-    }
-    try {
-      process.env.IMPORTED_BY_TEST_PLAN = "1";
-      await import(webServer.moduleUrl);
-      delete process.env.IMPORTED_BY_TEST_PLAN;
-    } catch (e) {
-      if (
-        e.code === "ERR_MODULE_NOT_FOUND" &&
-        e.message.includes(fileURLToPath(webServer.moduleUrl))
-      ) {
-        throw new Error(
-          `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
-        );
-      }
-      throw e;
-    }
-    aServerIsListening = await pingServer(webServer.origin);
-    if (!aServerIsListening) {
-      throw new Error(
-        `webServer.moduleUrl did not start a server listening at "${webServer.origin}", check file at "${webServer.moduleUrl}"`,
-      );
-    }
+  if (typeof webServer.origin !== "string") {
+    throw new TypeError(
+      `webServer.origin must be a string, got ${webServer.origin}`,
+    );
   }
+  await ensureWebServerIsStarted(webServer, {
+    signal,
+    teardown,
+    logger,
+  });
   const { headers } = await basicFetch(webServer.origin, {
     method: "GET",
     rejectUnauthorized: false,
@@ -2939,6 +3146,37 @@ const assertAndNormalizeWebServer = async (webServer) => {
   }
 };
 
+const ensureWebServerIsStarted = async (
+  webServer,
+  { signal, teardown, logger, allocatedMs = 5_000 },
+) => {
+  const aServerIsListening = await pingServer(webServer.origin);
+  if (aServerIsListening) {
+    return;
+  }
+  if (webServer.moduleUrl) {
+    await startServerUsingModuleUrl(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
+  }
+  if (webServer.command) {
+    await startServerUsingCommand(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
+  }
+  throw new TypeError(
+    `webServer.moduleUrl or webServer.command is required as there is no server listening "${webServer.origin}"`,
+  );
+};
+
 const executionStepsFromTestPlan = async ({
   signal,
   rootDirectoryUrl,
@@ -4209,7 +4447,7 @@ const executeSteps = async (
   executionSteps,
   {
     signal,
-    handleSIGINT,
+    teardown,
     logger,
     logRefresh,
     logRuntime,
@@ -4249,23 +4487,9 @@ const executeSteps = async (
   const executePlanReturnValue = {};
   const report = {};
   const callbacks = [];
-  const stopAfterAllSignal = { notify: () => {} };
 
   const multipleExecutionsOperation = Abort.startOperation();
   multipleExecutionsOperation.addAbortSignal(signal);
-  if (handleSIGINT) {
-    multipleExecutionsOperation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGINT: true,
-        },
-        () => {
-          logger.debug(`SIGINT abort`);
-          abort();
-        },
-      );
-    });
-  }
   const failFastAbortController = new AbortController();
   if (failFast) {
     multipleExecutionsOperation.addAbortSignal(failFastAbortController.signal);
@@ -4318,7 +4542,8 @@ const executeSteps = async (
       coverageConfig,
       coverageMethodForBrowsers,
       coverageMethodForNodeJs,
-      stopAfterAllSignal,
+      isTestPlan: true,
+      teardown,
     };
 
     if (logMergeForCompletedExecutions && !process.stdout.isTTY) {
@@ -4516,8 +4741,8 @@ const executeSteps = async (
       },
     });
     if (!keepRunning) {
-      logger.debug("stopAfterAllSignal.notify()");
-      await stopAfterAllSignal.notify();
+      logger.debug("trigger test plan teardown");
+      await teardown.trigger();
     }
 
     counters.cancelled = counters.total - counters.done;
@@ -4539,10 +4764,9 @@ const executeSteps = async (
     executePlanReturnValue.aborted = multipleExecutionsOperation.signal.aborted;
     executePlanReturnValue.planSummary = summary;
     executePlanReturnValue.planReport = report;
-    await callbacks.reduce(async (previous, callback) => {
-      await previous;
+    for (const callback of callbacks) {
       await callback();
-    }, Promise.resolve());
+    }
     return executePlanReturnValue;
   } finally {
     await multipleExecutionsOperation.end();
@@ -4708,6 +4932,25 @@ const executeTestPlan = async ({
   coverageReportHtmlDirectoryUrl,
   ...rest
 }) => {
+  const teardown = createTeardown();
+
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+  if (handleSIGINT) {
+    operation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        () => {
+          logger.debug(`SIGINT abort`);
+          abort();
+        },
+      );
+    });
+  }
+
+  let logger;
   let someNeedsServer = false;
   let someHasCoverageV8 = false;
   let someNodeRuntime = false;
@@ -4731,6 +4974,8 @@ const executeTestPlan = async ({
       throw new Error(`testPlan must be an object, got ${testPlan}`);
     }
 
+    logger = createLogger({ logLevel });
+
     Object.keys(testPlan).forEach((filePattern) => {
       const filePlan = testPlan[filePattern];
       if (!filePlan) return;
@@ -4753,7 +4998,11 @@ const executeTestPlan = async ({
     });
 
     if (someNeedsServer) {
-      await assertAndNormalizeWebServer(webServer);
+      await assertAndNormalizeWebServer(webServer, {
+        signal: operation.signal,
+        teardown,
+        logger,
+      });
     }
 
     if (coverageEnabled) {
@@ -4838,7 +5087,6 @@ const executeTestPlan = async ({
     }
   }
 
-  const logger = createLogger({ logLevel });
   logger.debug(
     createDetailedMessage(`Prepare executing plan`, {
       runtimes: JSON.stringify(runtimes, null, "  "),
@@ -4893,7 +5141,7 @@ const executeTestPlan = async ({
 
   const result = await executeSteps(executionSteps, {
     signal,
-    handleSIGINT,
+    teardown,
     logger,
     logRefresh,
     logSummary,
@@ -5217,7 +5465,8 @@ const createRuntimeUsingPlaywright = ({
     coverageMethodForBrowsers,
     coverageFileUrl,
 
-    stopAfterAllSignal,
+    teardown,
+    isTestPlan,
     stopSignal,
     keepRunning,
     onConsole,
@@ -5236,7 +5485,7 @@ const createRuntimeUsingPlaywright = ({
       await cleanupCallbackList.notify({ reason });
     });
 
-    const isBrowserDedicatedToExecution = isolatedTab || !stopAfterAllSignal;
+    const isBrowserDedicatedToExecution = isolatedTab || !isTestPlan;
     let browserAndContextPromise = isBrowserDedicatedToExecution
       ? null
       : browserPromiseCache.get(label);
@@ -5485,15 +5734,11 @@ const createRuntimeUsingPlaywright = ({
               cleanupCallbackList.add(() => {
                 browser.removeListener("disconnected", disconnectedCallback);
               });
-              const notifyPrevious = stopAfterAllSignal.notify;
-              stopAfterAllSignal.notify = async () => {
-                await notifyPrevious();
+              teardown.addCallback(async () => {
                 browser.removeListener("disconnected", disconnectedCallback);
-                logger.debug(
-                  `stopAfterAllSignal notified -> closing ${browserName}`,
-                );
+                logger.debug(`testPlan teardown -> closing ${browserName}`);
                 await closeBrowser();
-              };
+              });
             }
           },
           response: async (cb) => {
@@ -6840,6 +7085,7 @@ const execute = async ({
     rootDirectoryUrl,
     "rootDirectoryUrl",
   );
+  const teardown = createTeardown();
   const executeOperation = Abort.startOperation();
   executeOperation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -6854,7 +7100,7 @@ const execute = async ({
   }
 
   if (runtime.type === "browser") {
-    await assertAndNormalizeWebServer(webServer);
+    await assertAndNormalizeWebServer(webServer, { signal, teardown, logger });
   }
 
   let resultTransformer = (result) => result;
@@ -6863,6 +7109,7 @@ const execute = async ({
     webServer,
     fileRelativeUrl,
     importMap,
+    teardown,
     ...runtimeParams,
   };
 
@@ -6902,6 +7149,7 @@ const execute = async ({
     }
     return result;
   } finally {
+    await teardown.trigger();
     await executeOperation.end();
   }
 };