@jsenv/core 29.1.5 → 29.1.7

package/dist/main.js

@@ -2540,16 +2540,16 @@ const writeFileSync = (destination, content = "") => {
   }
 };
 
-const LOG_LEVEL_OFF = "off";
-const LOG_LEVEL_DEBUG = "debug";
-const LOG_LEVEL_INFO = "info";
-const LOG_LEVEL_WARN = "warn";
-const LOG_LEVEL_ERROR = "error";
-
-const createLogger = ({
-  logLevel = LOG_LEVEL_INFO
+const LOG_LEVEL_OFF$1 = "off";
+const LOG_LEVEL_DEBUG$1 = "debug";
+const LOG_LEVEL_INFO$1 = "info";
+const LOG_LEVEL_WARN$1 = "warn";
+const LOG_LEVEL_ERROR$1 = "error";
+
+const createLogger$1 = ({
+  logLevel = LOG_LEVEL_INFO$1
 } = {}) => {
-  if (logLevel === LOG_LEVEL_DEBUG) {
+  if (logLevel === LOG_LEVEL_DEBUG$1) {
     return {
       level: "debug",
       levels: {
@@ -2558,14 +2558,14 @@ const createLogger = ({
         warn: true,
         error: true
       },
-      debug,
-      info,
-      warn,
-      error
+      debug: debug$1,
+      info: info$1,
+      warn: warn$1,
+      error: error$1
     };
   }
 
-  if (logLevel === LOG_LEVEL_INFO) {
+  if (logLevel === LOG_LEVEL_INFO$1) {
     return {
       level: "info",
       levels: {
@@ -2574,14 +2574,14 @@ const createLogger = ({
         warn: true,
         error: true
       },
-      debug: debugDisabled,
-      info,
-      warn,
-      error
+      debug: debugDisabled$1,
+      info: info$1,
+      warn: warn$1,
+      error: error$1
     };
   }
 
-  if (logLevel === LOG_LEVEL_WARN) {
+  if (logLevel === LOG_LEVEL_WARN$1) {
     return {
       level: "warn",
       levels: {
@@ -2590,14 +2590,14 @@ const createLogger = ({
         warn: true,
         error: true
       },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn,
-      error
+      debug: debugDisabled$1,
+      info: infoDisabled$1,
+      warn: warn$1,
+      error: error$1
     };
   }
 
-  if (logLevel === LOG_LEVEL_ERROR) {
+  if (logLevel === LOG_LEVEL_ERROR$1) {
     return {
       level: "error",
       levels: {
@@ -2606,14 +2606,14 @@ const createLogger = ({
         warn: false,
         error: true
       },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error
+      debug: debugDisabled$1,
+      info: infoDisabled$1,
+      warn: warnDisabled$1,
+      error: error$1
     };
   }
 
-  if (logLevel === LOG_LEVEL_OFF) {
+  if (logLevel === LOG_LEVEL_OFF$1) {
     return {
       level: "off",
       levels: {
@@ -2622,10 +2622,10 @@ const createLogger = ({
         warn: false,
         error: false
       },
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error: errorDisabled
+      debug: debugDisabled$1,
+      info: infoDisabled$1,
+      warn: warnDisabled$1,
+      error: errorDisabled$1
     };
   }
 
@@ -2633,30 +2633,30 @@ const createLogger = ({
 --- logLevel ---
 ${logLevel}
 --- allowed log levels ---
-${LOG_LEVEL_OFF}
-${LOG_LEVEL_ERROR}
-${LOG_LEVEL_WARN}
-${LOG_LEVEL_INFO}
-${LOG_LEVEL_DEBUG}`);
+${LOG_LEVEL_OFF$1}
+${LOG_LEVEL_ERROR$1}
+${LOG_LEVEL_WARN$1}
+${LOG_LEVEL_INFO$1}
+${LOG_LEVEL_DEBUG$1}`);
 };
 
-const debug = (...args) => console.debug(...args);
+const debug$1 = (...args) => console.debug(...args);
 
-const debugDisabled = () => {};
+const debugDisabled$1 = () => {};
 
-const info = (...args) => console.info(...args);
+const info$1 = (...args) => console.info(...args);
 
-const infoDisabled = () => {};
+const infoDisabled$1 = () => {};
 
-const warn = (...args) => console.warn(...args);
+const warn$1 = (...args) => console.warn(...args);
 
-const warnDisabled = () => {};
+const warnDisabled$1 = () => {};
 
-const error = (...args) => console.error(...args);
+const error$1 = (...args) => console.error(...args);
 
-const errorDisabled = () => {};
+const errorDisabled$1 = () => {};
 
-function hasFlag(flag, argv = process$1.argv) {
+function hasFlag$1(flag, argv = process$1.argv) {
   const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf('--');
@@ -2664,31 +2664,31 @@ function hasFlag(flag, argv = process$1.argv) {
 }
 
 const {
-  env
+  env: env$1
 } = process$1;
-let flagForceColor;
+let flagForceColor$1;
 
-if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) {
-  flagForceColor = 0;
-} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) {
-  flagForceColor = 1;
+if (hasFlag$1('no-color') || hasFlag$1('no-colors') || hasFlag$1('color=false') || hasFlag$1('color=never')) {
+  flagForceColor$1 = 0;
+} else if (hasFlag$1('color') || hasFlag$1('colors') || hasFlag$1('color=true') || hasFlag$1('color=always')) {
+  flagForceColor$1 = 1;
 }
 
-function envForceColor() {
-  if ('FORCE_COLOR' in env) {
-    if (env.FORCE_COLOR === 'true') {
+function envForceColor$1() {
+  if ('FORCE_COLOR' in env$1) {
+    if (env$1.FORCE_COLOR === 'true') {
       return 1;
     }
 
-    if (env.FORCE_COLOR === 'false') {
+    if (env$1.FORCE_COLOR === 'false') {
       return 0;
     }
 
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    return env$1.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env$1.FORCE_COLOR, 10), 3);
   }
 }
 
-function translateLevel(level) {
+function translateLevel$1(level) {
   if (level === 0) {
     return false;
   }
@@ -2701,28 +2701,28 @@ function translateLevel(level) {
   };
 }
 
-function _supportsColor(haveStream, {
+function _supportsColor$1(haveStream, {
   streamIsTTY,
   sniffFlags = true
 } = {}) {
-  const noFlagForceColor = envForceColor();
+  const noFlagForceColor = envForceColor$1();
 
   if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
+    flagForceColor$1 = noFlagForceColor;
   }
 
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  const forceColor = sniffFlags ? flagForceColor$1 : noFlagForceColor;
 
   if (forceColor === 0) {
     return 0;
   }
 
   if (sniffFlags) {
-    if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) {
+    if (hasFlag$1('color=16m') || hasFlag$1('color=full') || hasFlag$1('color=truecolor')) {
       return 3;
     }
 
-    if (hasFlag('color=256')) {
+    if (hasFlag$1('color=256')) {
       return 2;
     }
   }
@@ -2733,7 +2733,7 @@ function _supportsColor(haveStream, {
 
   const min = forceColor || 0;
 
-  if (env.TERM === 'dumb') {
+  if (env$1.TERM === 'dumb') {
     return min;
   }
 
@@ -2749,31 +2749,31 @@ function _supportsColor(haveStream, {
     return 1;
   }
 
-  if ('CI' in env) {
-    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+  if ('CI' in env$1) {
+    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
       return 1;
     }
 
     return min;
   }
 
-  if ('TEAMCITY_VERSION' in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  if ('TEAMCITY_VERSION' in env$1) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
   } // Check for Azure DevOps pipelines
 
 
-  if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+  if ('TF_BUILD' in env$1 && 'AGENT_NAME' in env$1) {
     return 1;
   }
 
-  if (env.COLORTERM === 'truecolor') {
+  if (env$1.COLORTERM === 'truecolor') {
     return 3;
   }
 
-  if ('TERM_PROGRAM' in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+  if ('TERM_PROGRAM' in env$1) {
+    const version = Number.parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 
-    switch (env.TERM_PROGRAM) {
+    switch (env$1.TERM_PROGRAM) {
       case 'iTerm.app':
         return version >= 3 ? 3 : 2;
 
@@ -2783,39 +2783,39 @@ function _supportsColor(haveStream, {
     }
   }
 
-  if (/-256(color)?$/i.test(env.TERM)) {
+  if (/-256(color)?$/i.test(env$1.TERM)) {
     return 2;
   }
 
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
     return 1;
   }
 
-  if ('COLORTERM' in env) {
+  if ('COLORTERM' in env$1) {
     return 1;
   }
 
   return min;
 }
 
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
+function createSupportsColor$1(stream, options = {}) {
+  const level = _supportsColor$1(stream, {
     streamIsTTY: stream && stream.isTTY,
     ...options
   });
 
-  return translateLevel(level);
+  return translateLevel$1(level);
 }
 ({
-  stdout: createSupportsColor({
+  stdout: createSupportsColor$1({
     isTTY: tty.isatty(1)
   }),
-  stderr: createSupportsColor({
+  stderr: createSupportsColor$1({
     isTTY: tty.isatty(2)
   })
 });
 
-const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic;
+const processSupportsBasicColor = createSupportsColor$1(process.stdout).hasBasic;
 let canUseColors = processSupportsBasicColor; // GitHub workflow does support ANSI but "supports-color" returns false
 // because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
 
@@ -2849,18 +2849,19 @@ const ANSI = {
   color: setANSIColor
 };
 
-function isUnicodeSupported() {
+function isUnicodeSupported$1() {
   if (process$1.platform !== 'win32') {
     return process$1.env.TERM !== 'linux'; // Linux console (kernel)
   }
 
   return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) // Windows Terminal
+  || Boolean(process$1.env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
   || process$1.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
-  || process$1.env.TERM_PROGRAM === 'vscode' || process$1.env.TERM === 'xterm-256color' || process$1.env.TERM === 'alacritty' || process$1.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+  || process$1.env.TERM_PROGRAM === 'Terminus-Sublime' || process$1.env.TERM_PROGRAM === 'vscode' || process$1.env.TERM === 'xterm-256color' || process$1.env.TERM === 'alacritty' || process$1.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
 }
 
 // see also https://github.com/sindresorhus/figures
-const canUseUnicode = isUnicodeSupported();
+const canUseUnicode = isUnicodeSupported$1();
 const COMMAND_RAW = canUseUnicode ? `❯` : `>`;
 const OK_RAW = canUseUnicode ? `✔` : `√`;
 const FAILURE_RAW = canUseUnicode ? `✖` : `×`;
@@ -2894,7 +2895,7 @@ const UNICODE = {
   supported: canUseUnicode
 };
 
-const createDetailedMessage$1 = (message, details = {}) => {
+const createDetailedMessage$2 = (message, details = {}) => {
   let string = `${message}`;
   Object.keys(details).forEach(key => {
     const value = details[key];
@@ -3193,26 +3194,26 @@ const distributePercentages = (namedNumbers, {
   return percentages;
 };
 
-const ESC = '\u001B[';
-const OSC = '\u001B]';
-const BEL = '\u0007';
-const SEP = ';';
-const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
-const ansiEscapes = {};
+const ESC$1 = '\u001B[';
+const OSC$1 = '\u001B]';
+const BEL$1 = '\u0007';
+const SEP$1 = ';';
+const isTerminalApp$1 = process$1.env.TERM_PROGRAM === 'Apple_Terminal';
+const ansiEscapes$1 = {};
 
-ansiEscapes.cursorTo = (x, y) => {
+ansiEscapes$1.cursorTo = (x, y) => {
   if (typeof x !== 'number') {
     throw new TypeError('The `x` argument is required');
   }
 
   if (typeof y !== 'number') {
-    return ESC + (x + 1) + 'G';
+    return ESC$1 + (x + 1) + 'G';
   }
 
-  return ESC + (y + 1) + ';' + (x + 1) + 'H';
+  return ESC$1 + (y + 1) + SEP$1 + (x + 1) + 'H';
 };
 
-ansiEscapes.cursorMove = (x, y) => {
+ansiEscapes$1.cursorMove = (x, y) => {
   if (typeof x !== 'number') {
     throw new TypeError('The `x` argument is required');
   }
@@ -3220,73 +3221,71 @@ ansiEscapes.cursorMove = (x, y) => {
   let returnValue = '';
 
   if (x < 0) {
-    returnValue += ESC + -x + 'D';
+    returnValue += ESC$1 + -x + 'D';
   } else if (x > 0) {
-    returnValue += ESC + x + 'C';
+    returnValue += ESC$1 + x + 'C';
   }
 
   if (y < 0) {
-    returnValue += ESC + -y + 'A';
+    returnValue += ESC$1 + -y + 'A';
   } else if (y > 0) {
-    returnValue += ESC + y + 'B';
+    returnValue += ESC$1 + y + 'B';
   }
 
   return returnValue;
 };
 
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
+ansiEscapes$1.cursorUp = (count = 1) => ESC$1 + count + 'A';
 
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
+ansiEscapes$1.cursorDown = (count = 1) => ESC$1 + count + 'B';
 
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
+ansiEscapes$1.cursorForward = (count = 1) => ESC$1 + count + 'C';
 
-ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
+ansiEscapes$1.cursorBackward = (count = 1) => ESC$1 + count + 'D';
 
-ansiEscapes.cursorLeft = ESC + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
-ansiEscapes.cursorGetPosition = ESC + '6n';
-ansiEscapes.cursorNextLine = ESC + 'E';
-ansiEscapes.cursorPrevLine = ESC + 'F';
-ansiEscapes.cursorHide = ESC + '?25l';
-ansiEscapes.cursorShow = ESC + '?25h';
+ansiEscapes$1.cursorLeft = ESC$1 + 'G';
+ansiEscapes$1.cursorSavePosition = isTerminalApp$1 ? '\u001B7' : ESC$1 + 's';
+ansiEscapes$1.cursorRestorePosition = isTerminalApp$1 ? '\u001B8' : ESC$1 + 'u';
+ansiEscapes$1.cursorGetPosition = ESC$1 + '6n';
+ansiEscapes$1.cursorNextLine = ESC$1 + 'E';
+ansiEscapes$1.cursorPrevLine = ESC$1 + 'F';
+ansiEscapes$1.cursorHide = ESC$1 + '?25l';
+ansiEscapes$1.cursorShow = ESC$1 + '?25h';
 
-ansiEscapes.eraseLines = count => {
+ansiEscapes$1.eraseLines = count => {
   let clear = '';
 
   for (let i = 0; i < count; i++) {
-    clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
+    clear += ansiEscapes$1.eraseLine + (i < count - 1 ? ansiEscapes$1.cursorUp() : '');
   }
 
   if (count) {
-    clear += ansiEscapes.cursorLeft;
+    clear += ansiEscapes$1.cursorLeft;
   }
 
   return clear;
 };
 
-ansiEscapes.eraseEndLine = ESC + 'K';
-ansiEscapes.eraseStartLine = ESC + '1K';
-ansiEscapes.eraseLine = ESC + '2K';
-ansiEscapes.eraseDown = ESC + 'J';
-ansiEscapes.eraseUp = ESC + '1J';
-ansiEscapes.eraseScreen = ESC + '2J';
-ansiEscapes.scrollUp = ESC + 'S';
-ansiEscapes.scrollDown = ESC + 'T';
-ansiEscapes.clearScreen = '\u001Bc';
-ansiEscapes.clearTerminal = process.platform === 'win32' ? `${ansiEscapes.eraseScreen}${ESC}0f` : // 1. Erases the screen (Only done in case `2` is not supported)
+ansiEscapes$1.eraseEndLine = ESC$1 + 'K';
+ansiEscapes$1.eraseStartLine = ESC$1 + '1K';
+ansiEscapes$1.eraseLine = ESC$1 + '2K';
+ansiEscapes$1.eraseDown = ESC$1 + 'J';
+ansiEscapes$1.eraseUp = ESC$1 + '1J';
+ansiEscapes$1.eraseScreen = ESC$1 + '2J';
+ansiEscapes$1.scrollUp = ESC$1 + 'S';
+ansiEscapes$1.scrollDown = ESC$1 + 'T';
+ansiEscapes$1.clearScreen = '\u001Bc';
+ansiEscapes$1.clearTerminal = process$1.platform === 'win32' ? `${ansiEscapes$1.eraseScreen}${ESC$1}0f` // 1. Erases the screen (Only done in case `2` is not supported)
 // 2. Erases the whole screen including scrollback buffer
 // 3. Moves cursor to the top-left position
 // More info: https://www.real-world-systems.com/docs/ANSIcode.html
-`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
-ansiEscapes.beep = BEL;
+: `${ansiEscapes$1.eraseScreen}${ESC$1}3J${ESC$1}H`;
+ansiEscapes$1.beep = BEL$1;
 
-ansiEscapes.link = (text, url) => {
-  return [OSC, '8', SEP, SEP, url, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
-};
+ansiEscapes$1.link = (text, url) => [OSC$1, '8', SEP$1, SEP$1, url, BEL$1, text, OSC$1, '8', SEP$1, SEP$1, BEL$1].join('');
 
-ansiEscapes.image = (buffer, options = {}) => {
-  let returnValue = `${OSC}1337;File=inline=1`;
+ansiEscapes$1.image = (buffer, options = {}) => {
+  let returnValue = `${OSC$1}1337;File=inline=1`;
 
   if (options.width) {
     returnValue += `;width=${options.width}`;
@@ -3300,13 +3299,14 @@ ansiEscapes.image = (buffer, options = {}) => {
     returnValue += ';preserveAspectRatio=0';
   }
 
-  return returnValue + ':' + buffer.toString('base64') + BEL;
+  return returnValue + ':' + buffer.toString('base64') + BEL$1;
 };
 
-ansiEscapes.iTerm = {
-  setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-  annotation: (message, options = {}) => {
-    let returnValue = `${OSC}1337;`;
+ansiEscapes$1.iTerm = {
+  setCwd: (cwd = process$1.cwd()) => `${OSC$1}50;CurrentDir=${cwd}${BEL$1}`,
+
+  annotation(message, options = {}) {
+    let returnValue = `${OSC$1}1337;`;
     const hasX = typeof options.x !== 'undefined';
     const hasY = typeof options.y !== 'undefined';
 
@@ -3323,8 +3323,9 @@ ansiEscapes.iTerm = {
       returnValue += message;
     }
 
-    return returnValue + BEL;
+    return returnValue + BEL$1;
   }
+
 };
 
 /*
@@ -3408,7 +3409,7 @@ const createLog = ({
     }
 
     clearAttemptResult = true;
-    return ansiEscapes.eraseLines(visualLineCount);
+    return ansiEscapes$1.eraseLines(visualLineCount);
   };
 
   const spyStream = () => {
@@ -3486,134 +3487,576 @@ const addNewLines = (string, newLine) => {
 ${string}`;
   }
 
-  if (newLine === "after") {
-    return `${string}
-`;
+  if (newLine === "after") {
+    return `${string}
+`;
+  }
+
+  if (newLine === "around") {
+    return `
+${string}
+`;
+  }
+
+  return string;
+};
+
+const startSpinner = ({
+  log,
+  frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  fps = 20,
+  keepProcessAlive = false,
+  stopOnWriteFromOutside = true,
+  stopOnVerticalOverflow = true,
+  render = () => "",
+  effect = () => {}
+}) => {
+  let frameIndex = 0;
+  let interval;
+  let running = true;
+  const spinner = {
+    message: undefined
+  };
+
+  const update = message => {
+    spinner.message = running ? `${frames[frameIndex]} ${message}` : message;
+    return spinner.message;
+  };
+
+  spinner.update = update;
+  let cleanup;
+
+  if (ANSI.supported) {
+    running = true;
+    cleanup = effect();
+    log.write(update(render()));
+    interval = setInterval(() => {
+      frameIndex = frameIndex === frames.length - 1 ? 0 : frameIndex + 1;
+      log.dynamicWrite(({
+        outputFromOutside
+      }) => {
+        if (outputFromOutside && stopOnWriteFromOutside) {
+          stop();
+          return "";
+        }
+
+        return update(render());
+      });
+    }, 1000 / fps);
+
+    if (!keepProcessAlive) {
+      interval.unref();
+    }
+  } else {
+    log.write(update(render()));
+  }
+
+  const stop = message => {
+    running = false;
+
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+
+    if (cleanup) {
+      cleanup();
+      cleanup = null;
+    }
+
+    if (log && message) {
+      log.write(update(message));
+      log = null;
+    }
+  };
+
+  spinner.stop = stop;
+
+  if (stopOnVerticalOverflow) {
+    log.onVerticalOverflow = stop;
+  }
+
+  return spinner;
+};
+
+const createTaskLog = (label, {
+  disabled = false,
+  stopOnWriteFromOutside
+} = {}) => {
+  if (disabled) {
+    return {
+      setRightText: () => {},
+      done: () => {},
+      happen: () => {},
+      fail: () => {}
+    };
+  }
+
+  const startMs = Date.now();
+  const log = createLog();
+  let message = label;
+  const taskSpinner = startSpinner({
+    log,
+    render: () => message,
+    stopOnWriteFromOutside
+  });
+  return {
+    setRightText: value => {
+      message = `${label} ${value}`;
+    },
+    done: () => {
+      const msEllapsed = Date.now() - startMs;
+      taskSpinner.stop(`${UNICODE.OK} ${label} (done in ${msAsDuration(msEllapsed)})`);
+    },
+    happen: message => {
+      taskSpinner.stop(`${UNICODE.INFO} ${message} (at ${new Date().toLocaleTimeString()})`);
+    },
+    fail: (message = `failed to ${label}`) => {
+      taskSpinner.stop(`${UNICODE.FAILURE} ${message}`);
+    }
+  };
+};
+
+const LOG_LEVEL_OFF = "off";
+const LOG_LEVEL_DEBUG = "debug";
+const LOG_LEVEL_INFO = "info";
+const LOG_LEVEL_WARN = "warn";
+const LOG_LEVEL_ERROR = "error";
+
+const createLogger = ({
+  logLevel = LOG_LEVEL_INFO
+} = {}) => {
+  if (logLevel === LOG_LEVEL_DEBUG) {
+    return {
+      level: "debug",
+      levels: {
+        debug: true,
+        info: true,
+        warn: true,
+        error: true
+      },
+      debug,
+      info,
+      warn,
+      error
+    };
+  }
+
+  if (logLevel === LOG_LEVEL_INFO) {
+    return {
+      level: "info",
+      levels: {
+        debug: false,
+        info: true,
+        warn: true,
+        error: true
+      },
+      debug: debugDisabled,
+      info,
+      warn,
+      error
+    };
+  }
+
+  if (logLevel === LOG_LEVEL_WARN) {
+    return {
+      level: "warn",
+      levels: {
+        debug: false,
+        info: false,
+        warn: true,
+        error: true
+      },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn,
+      error
+    };
+  }
+
+  if (logLevel === LOG_LEVEL_ERROR) {
+    return {
+      level: "error",
+      levels: {
+        debug: false,
+        info: false,
+        warn: false,
+        error: true
+      },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error
+    };
+  }
+
+  if (logLevel === LOG_LEVEL_OFF) {
+    return {
+      level: "off",
+      levels: {
+        debug: false,
+        info: false,
+        warn: false,
+        error: false
+      },
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error: errorDisabled
+    };
+  }
+
+  throw new Error(`unexpected logLevel.
+--- logLevel ---
+${logLevel}
+--- allowed log levels ---
+${LOG_LEVEL_OFF}
+${LOG_LEVEL_ERROR}
+${LOG_LEVEL_WARN}
+${LOG_LEVEL_INFO}
+${LOG_LEVEL_DEBUG}`);
+};
+
+const debug = (...args) => console.debug(...args);
+
+const debugDisabled = () => {};
+
+const info = (...args) => console.info(...args);
+
+const infoDisabled = () => {};
+
+const warn = (...args) => console.warn(...args);
+
+const warnDisabled = () => {};
+
+const error = (...args) => console.error(...args);
+
+const errorDisabled = () => {};
+
+function hasFlag(flag, argv = process$1.argv) {
+  const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf('--');
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+
+const {
+  env
+} = process$1;
+let flagForceColor;
+
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) {
+  flagForceColor = 0;
+} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) {
+  flagForceColor = 1;
+}
+
+function envForceColor() {
+  if ('FORCE_COLOR' in env) {
+    if (env.FORCE_COLOR === 'true') {
+      return 1;
+    }
+
+    if (env.FORCE_COLOR === 'false') {
+      return 0;
+    }
+
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+
+function _supportsColor(haveStream, {
+  streamIsTTY,
+  sniffFlags = true
+} = {}) {
+  const noFlagForceColor = envForceColor();
+
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+
+  if (forceColor === 0) {
+    return 0;
+  }
+
+  if (sniffFlags) {
+    if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) {
+      return 3;
+    }
+
+    if (hasFlag('color=256')) {
+      return 2;
+    }
+  }
+
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+
+  const min = forceColor || 0;
+
+  if (env.TERM === 'dumb') {
+    return min;
+  }
+
+  if (process$1.platform === 'win32') {
+    // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+    // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+    const osRelease = os.release().split('.');
+
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10_586) {
+      return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+    }
+
+    return 1;
+  }
+
+  if ('CI' in env) {
+    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+      return 1;
+    }
+
+    return min;
+  }
+
+  if ('TEAMCITY_VERSION' in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  } // Check for Azure DevOps pipelines
+
+
+  if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+    return 1;
+  }
+
+  if (env.COLORTERM === 'truecolor') {
+    return 3;
+  }
+
+  if ('TERM_PROGRAM' in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        return version >= 3 ? 3 : 2;
+
+      case 'Apple_Terminal':
+        return 2;
+      // No default
+    }
+  }
+
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+
+  if ('COLORTERM' in env) {
+    return 1;
+  }
+
+  return min;
+}
+
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+
+  return translateLevel(level);
+}
+({
+  stdout: createSupportsColor({
+    isTTY: tty.isatty(1)
+  }),
+  stderr: createSupportsColor({
+    isTTY: tty.isatty(2)
+  })
+});
+
+createSupportsColor(process.stdout).hasBasic;
+// because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+
+if (process.env.GITHUB_WORKFLOW) {
+  // Check on FORCE_COLOR is to ensure it is prio over GitHub workflow check
+  if (process.env.FORCE_COLOR !== "false") ;
+} // https://github.com/Marak/colors.js/blob/master/lib/styles.js
+
+function isUnicodeSupported() {
+  if (process$1.platform !== 'win32') {
+    return process$1.env.TERM !== 'linux'; // Linux console (kernel)
+  }
+
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) // Windows Terminal
+  || process$1.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+  || process$1.env.TERM_PROGRAM === 'vscode' || process$1.env.TERM === 'xterm-256color' || process$1.env.TERM === 'alacritty' || process$1.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}
+
+// see also https://github.com/sindresorhus/figures
+isUnicodeSupported();
+
+const createDetailedMessage$1 = (message, details = {}) => {
+  let string = `${message}`;
+  Object.keys(details).forEach(key => {
+    const value = details[key];
+    string += `
+--- ${key} ---
+${Array.isArray(value) ? value.join(`
+`) : value}`;
+  });
+  return string;
+};
+
+const ESC = '\u001B[';
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
+const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
+const ansiEscapes = {};
+
+ansiEscapes.cursorTo = (x, y) => {
+  if (typeof x !== 'number') {
+    throw new TypeError('The `x` argument is required');
+  }
+
+  if (typeof y !== 'number') {
+    return ESC + (x + 1) + 'G';
+  }
+
+  return ESC + (y + 1) + ';' + (x + 1) + 'H';
+};
+
+ansiEscapes.cursorMove = (x, y) => {
+  if (typeof x !== 'number') {
+    throw new TypeError('The `x` argument is required');
+  }
+
+  let returnValue = '';
+
+  if (x < 0) {
+    returnValue += ESC + -x + 'D';
+  } else if (x > 0) {
+    returnValue += ESC + x + 'C';
   }
 
-  if (newLine === "around") {
-    return `
-${string}
-`;
+  if (y < 0) {
+    returnValue += ESC + -y + 'A';
+  } else if (y > 0) {
+    returnValue += ESC + y + 'B';
   }
 
-  return string;
+  return returnValue;
 };
 
-const startSpinner = ({
-  log,
-  frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-  fps = 20,
-  keepProcessAlive = false,
-  stopOnWriteFromOutside = true,
-  stopOnVerticalOverflow = true,
-  render = () => "",
-  effect = () => {}
-}) => {
-  let frameIndex = 0;
-  let interval;
-  let running = true;
-  const spinner = {
-    message: undefined
-  };
+ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
 
-  const update = message => {
-    spinner.message = running ? `${frames[frameIndex]} ${message}` : message;
-    return spinner.message;
-  };
+ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
 
-  spinner.update = update;
-  let cleanup;
+ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
 
-  if (ANSI.supported) {
-    running = true;
-    cleanup = effect();
-    log.write(update(render()));
-    interval = setInterval(() => {
-      frameIndex = frameIndex === frames.length - 1 ? 0 : frameIndex + 1;
-      log.dynamicWrite(({
-        outputFromOutside
-      }) => {
-        if (outputFromOutside && stopOnWriteFromOutside) {
-          stop();
-          return "";
-        }
+ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
 
-        return update(render());
-      });
-    }, 1000 / fps);
+ansiEscapes.cursorLeft = ESC + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
+ansiEscapes.cursorGetPosition = ESC + '6n';
+ansiEscapes.cursorNextLine = ESC + 'E';
+ansiEscapes.cursorPrevLine = ESC + 'F';
+ansiEscapes.cursorHide = ESC + '?25l';
+ansiEscapes.cursorShow = ESC + '?25h';
 
-    if (!keepProcessAlive) {
-      interval.unref();
-    }
-  } else {
-    log.write(update(render()));
+ansiEscapes.eraseLines = count => {
+  let clear = '';
+
+  for (let i = 0; i < count; i++) {
+    clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
   }
 
-  const stop = message => {
-    running = false;
+  if (count) {
+    clear += ansiEscapes.cursorLeft;
+  }
 
-    if (interval) {
-      clearInterval(interval);
-      interval = null;
-    }
+  return clear;
+};
 
-    if (cleanup) {
-      cleanup();
-      cleanup = null;
-    }
+ansiEscapes.eraseEndLine = ESC + 'K';
+ansiEscapes.eraseStartLine = ESC + '1K';
+ansiEscapes.eraseLine = ESC + '2K';
+ansiEscapes.eraseDown = ESC + 'J';
+ansiEscapes.eraseUp = ESC + '1J';
+ansiEscapes.eraseScreen = ESC + '2J';
+ansiEscapes.scrollUp = ESC + 'S';
+ansiEscapes.scrollDown = ESC + 'T';
+ansiEscapes.clearScreen = '\u001Bc';
+ansiEscapes.clearTerminal = process.platform === 'win32' ? `${ansiEscapes.eraseScreen}${ESC}0f` : // 1. Erases the screen (Only done in case `2` is not supported)
+// 2. Erases the whole screen including scrollback buffer
+// 3. Moves cursor to the top-left position
+// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+ansiEscapes.beep = BEL;
 
-    if (log && message) {
-      log.write(update(message));
-      log = null;
-    }
-  };
+ansiEscapes.link = (text, url) => {
+  return [OSC, '8', SEP, SEP, url, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
+};
 
-  spinner.stop = stop;
+ansiEscapes.image = (buffer, options = {}) => {
+  let returnValue = `${OSC}1337;File=inline=1`;
 
-  if (stopOnVerticalOverflow) {
-    log.onVerticalOverflow = stop;
+  if (options.width) {
+    returnValue += `;width=${options.width}`;
   }
 
-  return spinner;
-};
+  if (options.height) {
+    returnValue += `;height=${options.height}`;
+  }
 
-const createTaskLog = (label, {
-  disabled = false,
-  stopOnWriteFromOutside
-} = {}) => {
-  if (disabled) {
-    return {
-      setRightText: () => {},
-      done: () => {},
-      happen: () => {},
-      fail: () => {}
-    };
+  if (options.preserveAspectRatio === false) {
+    returnValue += ';preserveAspectRatio=0';
   }
 
-  const startMs = Date.now();
-  const log = createLog();
-  let message = label;
-  const taskSpinner = startSpinner({
-    log,
-    render: () => message,
-    stopOnWriteFromOutside
-  });
-  return {
-    setRightText: value => {
-      message = `${label} ${value}`;
-    },
-    done: () => {
-      const msEllapsed = Date.now() - startMs;
-      taskSpinner.stop(`${UNICODE.OK} ${label} (done in ${msAsDuration(msEllapsed)})`);
-    },
-    happen: message => {
-      taskSpinner.stop(`${UNICODE.INFO} ${message} (at ${new Date().toLocaleTimeString()})`);
-    },
-    fail: (message = `failed to ${label}`) => {
-      taskSpinner.stop(`${UNICODE.FAILURE} ${message}`);
+  return returnValue + ':' + buffer.toString('base64') + BEL;
+};
+
+ansiEscapes.iTerm = {
+  setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
+  annotation: (message, options = {}) => {
+    let returnValue = `${OSC}1337;`;
+    const hasX = typeof options.x !== 'undefined';
+    const hasY = typeof options.y !== 'undefined';
+
+    if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== 'undefined')) {
+      throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
     }
-  };
+
+    message = message.replace(/\|/g, '');
+    returnValue += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
+
+    if (options.length > 0) {
+      returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join('|');
+    } else {
+      returnValue += message;
+    }
+
+    return returnValue + BEL;
+  }
 };
 
 const memoize = compute => {
@@ -4450,8 +4893,10 @@ const observableFromValue = value => {
 };
 
 // https://github.com/jamestalmage/stream-to-observable/blob/master/index.js
-const readableStreamLifetimeInSeconds = 120;
-const nodeStreamToObservable = nodeStream => {
+const observableFromNodeStream = (nodeStream, {
+  readableStreamLifetime = 120_000 // 2s
+
+} = {}) => {
   const observable = createObservable(({
     next,
     error,
@@ -4490,13 +4935,13 @@ const nodeStreamToObservable = nodeStream => {
     // safe measure, ensure the readable stream gets
     // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
     const timeout = setTimeout(() => {
-      process.emitWarning(`Readable stream not used after ${readableStreamLifetimeInSeconds} seconds. It will be destroyed to release resources`, {
+      process.emitWarning(`Readable stream not used after ${readableStreamLifetime / 1000} seconds. It will be destroyed to release resources`, {
         CODE: "READABLE_STREAM_TIMEOUT",
         // url is for http client request
         detail: `path: ${nodeStream.path}, fd: ${nodeStream.fd}, url: ${nodeStream.url}`
       });
       nodeStream.destroy();
-    }, readableStreamLifetimeInSeconds * 1000);
+    }, readableStreamLifetime);
     observable.timeout = timeout;
     onceReadableStreamUsedOrClosed(nodeStream, () => {
       clearTimeout(timeout);
@@ -4550,10 +4995,13 @@ const headersFromObject = headersObject => {
 
 const fromNodeRequest = (nodeRequest, {
   serverOrigin,
-  signal
+  signal,
+  requestBodyLifetime
 }) => {
   const headers = headersFromObject(nodeRequest.headers);
-  const body = nodeStreamToObservable(nodeRequest);
+  const body = observableFromNodeStream(nodeRequest, {
+    readableStreamLifetime: requestBodyLifetime
+  });
   let requestOrigin;
 
   if (nodeRequest.upgrade) {
@@ -4671,7 +5119,7 @@ const normalizeBodyMethods = body => {
 
   if (isNodeStream(body)) {
     return {
-      asObservable: () => nodeStreamToObservable(body),
+      asObservable: () => observableFromNodeStream(body),
       destroy: () => {
         body.destroy();
       }
@@ -4702,7 +5150,7 @@ const fileHandleToReadableStream = fileHandle => {
 };
 
 const fileHandleToObservable = fileHandle => {
-  return nodeStreamToObservable(fileHandleToReadableStream(fileHandle));
+  return observableFromNodeStream(fileHandleToReadableStream(fileHandle));
 };
 
 const isNodeStream = value => {
@@ -4717,7 +5165,7 @@ const isNodeStream = value => {
   return false;
 };
 
-const populateNodeResponse = async (responseStream, {
+const writeNodeResponse = async (responseStream, {
   status,
   statusText,
   headers,
@@ -5487,7 +5935,16 @@ const startServer = async ({
       "request url": request.url,
       "request headers": JSON.stringify(request.headers, null, "  ")
     }));
-  }
+  },
+  // timeAllocated to start responding to a request
+  // after this delay the server will respond with 504
+  responseTimeout = 60_000 * 10,
+  // 10s
+  // time allocated to server code to start reading the request body
+  // after this delay the underlying stream is destroyed, attempting to read it would throw
+  // if used the stream stays opened, it's only if the stream is not read at all that it gets destroyed
+  requestBodyLifetime = 60_000 * 2 // 2s
+
 } = {}) => {
   const logger = createLogger({
     logLevel
@@ -5972,7 +6429,7 @@ const startServer = async ({
                 abortController.abort();
               } else if (!http2Stream.pushAllowed) {
                 abortController.abort();
-              } else if (responseProperties !== ABORTED_RESPONSE_PROPERTIES) {
+              } else if (responseProperties.requestAborted) {} else {
                 const responseLength = responseProperties.headers["content-length"] || 0;
                 const {
                   effectiveRecvDataLength,
@@ -6047,87 +6504,104 @@ const startServer = async ({
         let handleRequestReturnValue;
         let errorWhileHandlingRequest = null;
         let handleRequestTimings = serverTiming ? {} : null;
+        let timeout;
+        const timeoutPromise = new Promise(resolve => {
+          timeout = setTimeout(() => {
+            resolve({
+              // the correct status code should be 500 because it's
+              // we don't really know what takes time
+              // in practice it's often because server is trying to reach an other server
+              // that is not responding so 504 is more correct
+              status: 504,
+              statusText: `server timeout after ${responseTimeout / 1000}s waiting to handle request`
+            });
+          }, responseTimeout);
+        });
+        const handleRequestPromise = serviceController.callAsyncHooksUntil("handleRequest", request, {
+          timing: handleRequestTimings,
+          warn,
+          pushResponse: async ({
+            path,
+            method
+          }) => {
+            if (typeof path !== "string" || path[0] !== "/") {
+              addRequestLog(requestNode, {
+                type: "warn",
+                value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`
+              });
+              return;
+            }
 
-        try {
-          handleRequestReturnValue = await serviceController.callAsyncHooksUntil("handleRequest", request, {
-            timing: handleRequestTimings,
-            warn,
-            pushResponse: async ({
-              path,
-              method
-            }) => {
-              if (typeof path !== "string" || path[0] !== "/") {
-                addRequestLog(requestNode, {
-                  type: "warn",
-                  value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`
-                });
-                return;
-              }
-
-              if (!request.http2) {
-                addRequestLog(requestNode, {
-                  type: "warn",
-                  value: `response push ignored because request is not http2`
-                });
-                return;
-              }
-
-              const canPushStream = testCanPushStream(nodeResponse.stream);
+            if (!request.http2) {
+              addRequestLog(requestNode, {
+                type: "warn",
+                value: `response push ignored because request is not http2`
+              });
+              return;
+            }
 
-              if (!canPushStream.can) {
-                addRequestLog(requestNode, {
-                  type: "debug",
-                  value: `response push ignored because ${canPushStream.reason}`
-                });
-                return;
-              }
+            const canPushStream = testCanPushStream(nodeResponse.stream);
 
-              let preventedByService = null;
+            if (!canPushStream.can) {
+              addRequestLog(requestNode, {
+                type: "debug",
+                value: `response push ignored because ${canPushStream.reason}`
+              });
+              return;
+            }
 
-              const prevent = () => {
-                preventedByService = serviceController.getCurrentService();
-              };
+            let preventedByService = null;
 
-              serviceController.callHooksUntil("onResponsePush", {
-                path,
-                method
-              }, {
-                request,
-                warn,
-                prevent
-              }, () => preventedByService);
-
-              if (preventedByService) {
-                addRequestLog(requestNode, {
-                  type: "debug",
-                  value: `response push prevented by "${preventedByService.name}" service`
-                });
-                return;
-              }
+            const prevent = () => {
+              preventedByService = serviceController.getCurrentService();
+            };
 
-              const requestChildNode = {
-                logs: [],
-                children: []
-              };
-              requestNode.children.push(requestChildNode);
-              await pushResponse({
-                path,
-                method
-              }, {
-                requestNode: requestChildNode,
-                parentHttp2Stream: nodeResponse.stream
+            serviceController.callHooksUntil("onResponsePush", {
+              path,
+              method
+            }, {
+              request,
+              warn,
+              prevent
+            }, () => preventedByService);
+
+            if (preventedByService) {
+              addRequestLog(requestNode, {
+                type: "debug",
+                value: `response push prevented by "${preventedByService.name}" service`
               });
+              return;
             }
-          });
-        } catch (error) {
-          errorWhileHandlingRequest = error;
+
+            const requestChildNode = {
+              logs: [],
+              children: []
+            };
+            requestNode.children.push(requestChildNode);
+            await pushResponse({
+              path,
+              method
+            }, {
+              requestNode: requestChildNode,
+              parentHttp2Stream: nodeResponse.stream
+            });
+          }
+        });
+
+        try {
+          handleRequestReturnValue = await Promise.race([timeoutPromise, handleRequestPromise]);
+        } catch (e) {
+          errorWhileHandlingRequest = e;
         }
 
+        clearTimeout(timeout);
         let responseProperties;
 
         if (errorWhileHandlingRequest) {
           if (errorWhileHandlingRequest.name === "AbortError" && request.signal.aborted) {
-            responseProperties = ABORTED_RESPONSE_PROPERTIES;
+            responseProperties = {
+              requestAborted: true
+            };
           } else {
             // internal error, create 500 response
             if ( // stopOnInternalError stops server only if requestToResponse generated
@@ -6237,7 +6711,7 @@ const startServer = async ({
           await new Promise(resolve => setTimeout(resolve));
         }
 
-        await populateNodeResponse(responseStream, responseProperties, {
+        await writeNodeResponse(responseStream, responseProperties, {
           signal,
           ignoreBody,
           onAbort: () => {
@@ -6348,7 +6822,8 @@ const startServer = async ({
           });
           const request = fromNodeRequest(nodeRequest, {
             serverOrigin: websocketOrigin,
-            signal: new AbortController().signal
+            signal: new AbortController().signal,
+            requestBodyLifetime
           });
           serviceController.callAsyncHooksUntil("handleWebsocket", websocket, {
             request
@@ -6456,7 +6931,6 @@ const testCanPushStream = http2Stream => {
   };
 };
 
-const ABORTED_RESPONSE_PROPERTIES = {};
 const PROCESS_TEARDOWN_EVENTS_MAP = {
   SIGHUP: STOP_REASON_PROCESS_SIGHUP,
   SIGTERM: STOP_REASON_PROCESS_SIGTERM,
@@ -9065,7 +9539,7 @@ const createResolveUrlError = ({
     reason,
     ...details
   }) => {
-    const resolveError = new Error(createDetailedMessage$1(`Failed to resolve url reference`, {
+    const resolveError = new Error(createDetailedMessage$2(`Failed to resolve url reference`, {
       reason,
       ...details,
       "specifier": `"${reference.specifier}"`,
@@ -9101,7 +9575,7 @@ const createFetchUrlContentError = ({
     reason,
     ...details
   }) => {
-    const fetchError = new Error(createDetailedMessage$1(`Failed to fetch url content`, {
+    const fetchError = new Error(createDetailedMessage$2(`Failed to fetch url content`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -9157,7 +9631,7 @@ const createTransformUrlContentError = ({
     reason,
     ...details
   }) => {
-    const transformError = new Error(createDetailedMessage$1(`"transformUrlContent" error on "${urlInfo.type}"`, {
+    const transformError = new Error(createDetailedMessage$2(`"transformUrlContent" error on "${urlInfo.type}"`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -9213,7 +9687,7 @@ const createFinalizeUrlContentError = ({
   urlInfo,
   error
 }) => {
-  const finalizeError = new Error(createDetailedMessage$1(`"finalizeUrlContent" error on "${urlInfo.type}"`, { ...detailsFromValueThrown(error),
+  const finalizeError = new Error(createDetailedMessage$2(`"finalizeUrlContent" error on "${urlInfo.type}"`, { ...detailsFromValueThrown(error),
     "url": urlInfo.url,
     "url reference trace": reference.trace.message,
     ...detailsFromPluginController(pluginController)
@@ -9475,7 +9949,7 @@ const createKitchen = ({
   writeGeneratedFiles,
   outDirectoryUrl
 }) => {
-  const logger = createLogger({
+  const logger = createLogger$1({
     logLevel
   });
   const pluginController = createPluginController({
@@ -9740,7 +10214,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
       const fetchUrlContentReturnValue = await pluginController.callAsyncHooksUntil("fetchUrlContent", urlInfo, contextDuringFetch);
 
       if (!fetchUrlContentReturnValue) {
-        logger.warn(createDetailedMessage$1(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
+        logger.warn(createDetailedMessage$2(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
           "url": urlInfo.url,
           "url reference trace": reference.trace.message
         }));
@@ -17239,7 +17713,7 @@ const buildWithRollup = async ({
     return resultRef.current;
   } catch (e) {
     if (e.code === "MISSING_EXPORT") {
-      const detailedMessage = createDetailedMessage$1(e.message, {
+      const detailedMessage = createDetailedMessage$2(e.message, {
         frame: e.frame
       });
       throw new Error(detailedMessage, {
@@ -23804,7 +24278,7 @@ const build = async ({
     signal,
     logLevel
   }) => {
-    const logger = createLogger({
+    const logger = createLogger$1({
       logLevel
     });
     const buildOperation = Abort.startOperation();
@@ -24120,7 +24594,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             const rawUrlInfo = rawGraph.getUrlInfo(rawUrl);
 
             if (!rawUrlInfo) {
-              throw new Error(createDetailedMessage$1(`Cannot find url`, {
+              throw new Error(createDetailedMessage$2(`Cannot find url`, {
                 url,
                 "raw urls": Object.values(buildToRawUrls),
                 "build urls": Object.keys(buildToRawUrls)
@@ -25757,7 +26231,7 @@ const startDevServer = async ({
   // and mitigates https://github.com/actions/runner-images/issues/3885
   writeGeneratedFiles = !process.env.CI
 }) => {
-  const logger = createLogger({
+  const logger = createLogger$1({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
@@ -26103,7 +26577,7 @@ const readNodeV8CoverageDirectory = async ({
             return tryReadJsonFile();
           }
 
-          console.warn(createDetailedMessage$1(`Error while reading coverage file`, {
+          console.warn(createDetailedMessage$2(`Error while reading coverage file`, {
             "error stack": e.stack,
             "file": dirEntryUrl
           }));
@@ -26277,7 +26751,7 @@ const composeV8AndIstanbul = (v8FileByFileCoverage, istanbulFileByFileCoverage,
 
     if (v8Coverage) {
       if (coverageV8ConflictWarning) {
-        console.warn(createDetailedMessage$1(`Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`, {
+        console.warn(createDetailedMessage$2(`Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`, {
           details: `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
           suggestion: "You can disable this warning with coverageV8ConflictWarning: false"
         }));
@@ -26804,7 +27278,7 @@ const generateFileExecutionSteps = ({
     }
 
     if (typeof stepConfig !== "object") {
-      throw new TypeError(createDetailedMessage$1(`found unexpected value in plan, they must be object`, {
+      throw new TypeError(createDetailedMessage$2(`found unexpected value in plan, they must be object`, {
         ["file relative path"]: fileRelativeUrl,
         ["execution name"]: executionName,
         ["value"]: stepConfig
@@ -27272,7 +27746,7 @@ const executePlan = async (plan, {
       }
     });
   });
-  logger.debug(createDetailedMessage$1(`Prepare executing plan`, {
+  logger.debug(createDetailedMessage$2(`Prepare executing plan`, {
     runtimes: JSON.stringify(runtimes, null, "  ")
   }));
   const multipleExecutionsOperation = Abort.startOperation();
@@ -27304,7 +27778,7 @@ const executePlan = async (plan, {
         await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE);
       } else {
         coverageMethodForNodeJs = "Profiler";
-        logger.warn(createDetailedMessage$1(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
+        logger.warn(createDetailedMessage$2(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
           "suggestion": `set process.env.NODE_V8_COVERAGE`,
           "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`
         }));
@@ -27777,7 +28251,7 @@ const executeTestPlan = async ({
   coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
   coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null
 }) => {
-  const logger = createLogger({
+  const logger = createLogger$1({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
@@ -27814,7 +28288,7 @@ const executeTestPlan = async ({
 
       if (patternsMatchingCoverAndExecute.length) {
         // It would be strange, for a given file to be both covered and executed
-        throw new Error(createDetailedMessage$1(`some file will be both covered and executed`, {
+        throw new Error(createDetailedMessage$2(`some file will be both covered and executed`, {
           patterns: patternsMatchingCoverAndExecute
         }));
       }
@@ -28364,7 +28838,7 @@ const importPlaywright = async ({
     return namespace;
   } catch (e) {
     if (e.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(createDetailedMessage$1(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
+      throw new Error(createDetailedMessage$2(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
         suggestion: `npm install --save-dev playwright`
       }), {
         cause: e
@@ -28532,7 +29006,7 @@ const createChildExecOptions = async ({
   debugModeInheritBreak = true
 } = {}) => {
   if (typeof debugMode === "string" && AVAILABLE_DEBUG_MODE.indexOf(debugMode) === -1) {
-    throw new TypeError(createDetailedMessage$1(`unexpected debug mode.`, {
+    throw new TypeError(createDetailedMessage$2(`unexpected debug mode.`, {
       ["debug mode"]: debugMode,
       ["allowed debug mode"]: AVAILABLE_DEBUG_MODE
     }));
@@ -28829,7 +29303,7 @@ nodeChildProcess.run = async ({
     stdio: ["pipe", "pipe", "pipe", "ipc"],
     env: envForChildProcess
   });
-  logger.debug(createDetailedMessage$1(`child process forked (pid ${childProcess.pid})`, {
+  logger.debug(createDetailedMessage$2(`child process forked (pid ${childProcess.pid})`, {
     "execArgv": execArgv.join(`\n`),
     "custom env": JSON.stringify(env, null, "  ")
   })); // if we pass stream, pipe them https://github.com/sindresorhus/execa/issues/81
@@ -29427,7 +29901,7 @@ const startBuildServer = async ({
   buildServerMainFile = getCallerPosition().url,
   cooldownBetweenFileEvents
 }) => {
-  const logger = createLogger({
+  const logger = createLogger$1({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
@@ -29652,7 +30126,7 @@ const execute = async ({
   runtimeParams,
   ignoreError = false
 }) => {
-  const logger = createLogger({
+  const logger = createLogger$1({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);