@jsenv/core 30.4.2 → 31.0.0

package/dist/main.js

@@ -9,9 +9,9 @@ import os, { networkInterfaces } from "node:os";
 import tty from "node:tty";
 import stringWidth from "string-width";
 import net, { createServer, isIP } from "node:net";
-import http from "node:http";
 import cluster from "node:cluster";
 import { performance as performance$1 } from "node:perf_hooks";
+import http from "node:http";
 import { Readable, Stream, Writable } from "node:stream";
 import { Http2ServerResponse } from "node:http2";
 import { lookup } from "node:dns";
@@ -592,7 +592,7 @@ const urlToFileSystemPath = url => {
   return fileSystemPath;
 };
 
-const assertAndNormalizeDirectoryUrl = value => {
+const validateDirectoryUrl = value => {
   let urlString;
   if (value instanceof URL) {
     urlString = value.href;
@@ -603,19 +603,45 @@ const assertAndNormalizeDirectoryUrl = value => {
       try {
         urlString = String(new URL(value));
       } catch (e) {
-        throw new TypeError(`directoryUrl must be a valid url, received ${value}`);
+        return {
+          valid: false,
+          value,
+          message: `must be a valid url`
+        };
       }
     }
   } else {
-    throw new TypeError(`directoryUrl must be a string or an url, received ${value}`);
+    return {
+      valid: false,
+      value,
+      message: `must be a string or an url`
+    };
   }
   if (!urlString.startsWith("file://")) {
-    throw new Error(`directoryUrl must starts with file://, received ${value}`);
+    return {
+      valid: false,
+      value,
+      message: 'must start with "file://"'
+    };
+  }
+  return {
+    valid: true,
+    value: ensurePathnameTrailingSlash(urlString)
+  };
+};
+const assertAndNormalizeDirectoryUrl = directoryUrl => {
+  const {
+    valid,
+    message,
+    value
+  } = validateDirectoryUrl(directoryUrl);
+  if (!valid) {
+    throw new TypeError(`directoryUrl ${message}, got ${value}`);
   }
-  return ensurePathnameTrailingSlash(urlString);
+  return value;
 };
 
-const assertAndNormalizeFileUrl = (value, baseUrl) => {
+const validateFileUrl = (value, baseUrl) => {
   let urlString;
   if (value instanceof URL) {
     urlString = value.href;
@@ -626,16 +652,42 @@ const assertAndNormalizeFileUrl = (value, baseUrl) => {
       try {
         urlString = String(new URL(value, baseUrl));
       } catch (e) {
-        throw new TypeError(`fileUrl must be a valid url, received ${value}`);
+        return {
+          valid: false,
+          value,
+          message: "must be a valid url"
+        };
       }
     }
   } else {
-    throw new TypeError(`fileUrl must be a string or an url, received ${value}`);
+    return {
+      valid: false,
+      value,
+      message: "must be a string or an url"
+    };
   }
   if (!urlString.startsWith("file://")) {
-    throw new Error(`fileUrl must starts with file://, received ${value}`);
+    return {
+      valid: false,
+      value,
+      message: 'must start with "file://"'
+    };
+  }
+  return {
+    valid: true,
+    value: urlString
+  };
+};
+const assertAndNormalizeFileUrl = (fileUrl, baseUrl) => {
+  const {
+    valid,
+    message,
+    value
+  } = validateFileUrl(fileUrl, baseUrl);
+  if (!valid) {
+    throw new TypeError(`fileUrl ${message}, got ${fileUrl}`);
   }
-  return urlString;
+  return value;
 };
 
 const statsToType = stats => {
@@ -2264,16 +2316,16 @@ const writeFileSync = (destination, content = "") => {
   }
 };
 
-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 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$1 = ({
-  logLevel = LOG_LEVEL_INFO$1
+const createLogger = ({
+  logLevel = LOG_LEVEL_INFO
 } = {}) => {
-  if (logLevel === LOG_LEVEL_DEBUG$1) {
+  if (logLevel === LOG_LEVEL_DEBUG) {
     return {
       level: "debug",
       levels: {
@@ -2282,13 +2334,13 @@ const createLogger$1 = ({
         warn: true,
         error: true
       },
-      debug: debug$1,
-      info: info$1,
-      warn: warn$1,
-      error: error$1
+      debug,
+      info,
+      warn,
+      error
     };
   }
-  if (logLevel === LOG_LEVEL_INFO$1) {
+  if (logLevel === LOG_LEVEL_INFO) {
     return {
       level: "info",
       levels: {
@@ -2297,13 +2349,13 @@ const createLogger$1 = ({
         warn: true,
         error: true
       },
-      debug: debugDisabled$1,
-      info: info$1,
-      warn: warn$1,
-      error: error$1
+      debug: debugDisabled,
+      info,
+      warn,
+      error
     };
   }
-  if (logLevel === LOG_LEVEL_WARN$1) {
+  if (logLevel === LOG_LEVEL_WARN) {
     return {
       level: "warn",
       levels: {
@@ -2312,13 +2364,13 @@ const createLogger$1 = ({
         warn: true,
         error: true
       },
-      debug: debugDisabled$1,
-      info: infoDisabled$1,
-      warn: warn$1,
-      error: error$1
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn,
+      error
     };
   }
-  if (logLevel === LOG_LEVEL_ERROR$1) {
+  if (logLevel === LOG_LEVEL_ERROR) {
     return {
       level: "error",
       levels: {
@@ -2327,13 +2379,13 @@ const createLogger$1 = ({
         warn: false,
         error: true
       },
-      debug: debugDisabled$1,
-      info: infoDisabled$1,
-      warn: warnDisabled$1,
-      error: error$1
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error
     };
   }
-  if (logLevel === LOG_LEVEL_OFF$1) {
+  if (logLevel === LOG_LEVEL_OFF) {
     return {
       level: "off",
       levels: {
@@ -2342,60 +2394,60 @@ const createLogger$1 = ({
         warn: false,
         error: false
       },
-      debug: debugDisabled$1,
-      info: infoDisabled$1,
-      warn: warnDisabled$1,
-      error: errorDisabled$1
+      debug: debugDisabled,
+      info: infoDisabled,
+      warn: warnDisabled,
+      error: errorDisabled
     };
   }
   throw new Error(`unexpected logLevel.
 --- logLevel ---
 ${logLevel}
 --- allowed log levels ---
-${LOG_LEVEL_OFF$1}
-${LOG_LEVEL_ERROR$1}
-${LOG_LEVEL_WARN$1}
-${LOG_LEVEL_INFO$1}
-${LOG_LEVEL_DEBUG$1}`);
-};
-const debug$1 = (...args) => console.debug(...args);
-const debugDisabled$1 = () => {};
-const info$1 = (...args) => console.info(...args);
-const infoDisabled$1 = () => {};
-const warn$1 = (...args) => console.warn(...args);
-const warnDisabled$1 = () => {};
-const error$1 = (...args) => console.error(...args);
-const errorDisabled$1 = () => {};
+${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 = () => {};
 
 // From: https://github.com/sindresorhus/has-flag/blob/main/index.js
 /// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
-function hasFlag$1(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : 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: env$1
+  env
 } = process$1;
-let 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;
+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$1() {
-  if ('FORCE_COLOR' in env$1) {
-    if (env$1.FORCE_COLOR === 'true') {
+function envForceColor() {
+  if ('FORCE_COLOR' in env) {
+    if (env.FORCE_COLOR === 'true') {
       return 1;
     }
-    if (env$1.FORCE_COLOR === 'false') {
+    if (env.FORCE_COLOR === 'false') {
       return 0;
     }
-    return env$1.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env$1.FORCE_COLOR, 10), 3);
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
   }
 }
-function translateLevel$1(level) {
+function translateLevel(level) {
   if (level === 0) {
     return false;
   }
@@ -2406,37 +2458,37 @@ function translateLevel$1(level) {
     has16m: level >= 3
   };
 }
-function _supportsColor$1(haveStream, {
+function _supportsColor(haveStream, {
   streamIsTTY,
   sniffFlags = true
 } = {}) {
-  const noFlagForceColor = envForceColor$1();
+  const noFlagForceColor = envForceColor();
   if (noFlagForceColor !== undefined) {
-    flagForceColor$1 = noFlagForceColor;
+    flagForceColor = noFlagForceColor;
   }
-  const forceColor = sniffFlags ? flagForceColor$1 : noFlagForceColor;
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
   if (forceColor === 0) {
     return 0;
   }
   if (sniffFlags) {
-    if (hasFlag$1('color=16m') || hasFlag$1('color=full') || hasFlag$1('color=truecolor')) {
+    if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) {
       return 3;
     }
-    if (hasFlag$1('color=256')) {
+    if (hasFlag('color=256')) {
       return 2;
     }
   }
 
   // Check for Azure DevOps pipelines.
   // Has to be above the `!streamIsTTY` check.
-  if ('TF_BUILD' in env$1 && 'AGENT_NAME' in env$1) {
+  if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
     return 1;
   }
   if (haveStream && !streamIsTTY && forceColor === undefined) {
     return 0;
   }
   const min = forceColor || 0;
-  if (env$1.TERM === 'dumb') {
+  if (env.TERM === 'dumb') {
     return min;
   }
   if (process$1.platform === 'win32') {
@@ -2448,27 +2500,27 @@ function _supportsColor$1(haveStream, {
     }
     return 1;
   }
-  if ('CI' in env$1) {
-    if ('GITHUB_ACTIONS' in env$1) {
+  if ('CI' in env) {
+    if ('GITHUB_ACTIONS' in env) {
       return 3;
     }
-    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
+    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
       return 1;
     }
     return min;
   }
-  if ('TEAMCITY_VERSION' in env$1) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
+  if ('TEAMCITY_VERSION' in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
   }
-  if (env$1.COLORTERM === 'truecolor') {
+  if (env.COLORTERM === 'truecolor') {
     return 3;
   }
-  if (env$1.TERM === 'xterm-kitty') {
+  if (env.TERM === 'xterm-kitty') {
     return 3;
   }
-  if ('TERM_PROGRAM' in env$1) {
-    const version = Number.parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-    switch (env$1.TERM_PROGRAM) {
+  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;
@@ -2481,34 +2533,34 @@ function _supportsColor$1(haveStream, {
     }
   }
 
-  if (/-256(color)?$/i.test(env$1.TERM)) {
+  if (/-256(color)?$/i.test(env.TERM)) {
     return 2;
   }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
     return 1;
   }
-  if ('COLORTERM' in env$1) {
+  if ('COLORTERM' in env) {
     return 1;
   }
   return min;
 }
-function createSupportsColor$1(stream, options = {}) {
-  const level = _supportsColor$1(stream, {
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
     streamIsTTY: stream && stream.isTTY,
     ...options
   });
-  return translateLevel$1(level);
+  return translateLevel(level);
 }
 ({
-  stdout: createSupportsColor$1({
+  stdout: createSupportsColor({
     isTTY: tty.isatty(1)
   }),
-  stderr: createSupportsColor$1({
+  stderr: createSupportsColor({
     isTTY: tty.isatty(2)
   })
 });
 
-const processSupportsBasicColor = createSupportsColor$1(process.stdout).hasBasic;
+const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic;
 let canUseColors = processSupportsBasicColor;
 
 // GitHub workflow does support ANSI but "supports-color" returns false
@@ -2588,7 +2640,7 @@ const UNICODE = {
   supported: canUseUnicode
 };
 
-const createDetailedMessage$2 = (message, details = {}) => {
+const createDetailedMessage$1 = (message, details = {}) => {
   let string = `${message}`;
   Object.keys(details).forEach(key => {
     const value = details[key];
@@ -2852,86 +2904,86 @@ const distributePercentages = (namedNumbers, {
   return percentages;
 };
 
-const ESC$1 = '\u001B[';
-const OSC$1 = '\u001B]';
-const BEL$1 = '\u0007';
-const SEP$1 = ';';
+const ESC = '\u001B[';
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
 
 /* global window */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-const isTerminalApp$1 = !isBrowser && process$1.env.TERM_PROGRAM === 'Apple_Terminal';
+const isTerminalApp = !isBrowser && process$1.env.TERM_PROGRAM === 'Apple_Terminal';
 const isWindows = !isBrowser && process$1.platform === 'win32';
 const cwdFunction = isBrowser ? () => {
   throw new Error('`process.cwd()` only works in Node.js, not the browser.');
 } : process$1.cwd;
-const ansiEscapes$1 = {};
-ansiEscapes$1.cursorTo = (x, y) => {
+const ansiEscapes = {};
+ansiEscapes.cursorTo = (x, y) => {
   if (typeof x !== 'number') {
     throw new TypeError('The `x` argument is required');
   }
   if (typeof y !== 'number') {
-    return ESC$1 + (x + 1) + 'G';
+    return ESC + (x + 1) + 'G';
   }
-  return ESC$1 + (y + 1) + SEP$1 + (x + 1) + 'H';
+  return ESC + (y + 1) + SEP + (x + 1) + 'H';
 };
-ansiEscapes$1.cursorMove = (x, y) => {
+ansiEscapes.cursorMove = (x, y) => {
   if (typeof x !== 'number') {
     throw new TypeError('The `x` argument is required');
   }
   let returnValue = '';
   if (x < 0) {
-    returnValue += ESC$1 + -x + 'D';
+    returnValue += ESC + -x + 'D';
   } else if (x > 0) {
-    returnValue += ESC$1 + x + 'C';
+    returnValue += ESC + x + 'C';
   }
   if (y < 0) {
-    returnValue += ESC$1 + -y + 'A';
+    returnValue += ESC + -y + 'A';
   } else if (y > 0) {
-    returnValue += ESC$1 + y + 'B';
+    returnValue += ESC + y + 'B';
   }
   return returnValue;
 };
-ansiEscapes$1.cursorUp = (count = 1) => ESC$1 + count + 'A';
-ansiEscapes$1.cursorDown = (count = 1) => ESC$1 + count + 'B';
-ansiEscapes$1.cursorForward = (count = 1) => ESC$1 + count + 'C';
-ansiEscapes$1.cursorBackward = (count = 1) => ESC$1 + count + 'D';
-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$1.eraseLines = count => {
+ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC + 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.eraseLines = count => {
   let clear = '';
   for (let i = 0; i < count; i++) {
-    clear += ansiEscapes$1.eraseLine + (i < count - 1 ? ansiEscapes$1.cursorUp() : '');
+    clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
   }
   if (count) {
-    clear += ansiEscapes$1.cursorLeft;
+    clear += ansiEscapes.cursorLeft;
   }
   return clear;
 };
-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 = isWindows ? `${ansiEscapes$1.eraseScreen}${ESC$1}0f`
+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 = isWindows ? `${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$1.eraseScreen}${ESC$1}3J${ESC$1}H`;
-ansiEscapes$1.beep = BEL$1;
-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$1.image = (buffer, options = {}) => {
-  let returnValue = `${OSC$1}1337;File=inline=1`;
+: `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+ansiEscapes.beep = BEL;
+ansiEscapes.link = (text, url) => [OSC, '8', SEP, SEP, url, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
+ansiEscapes.image = (buffer, options = {}) => {
+  let returnValue = `${OSC}1337;File=inline=1`;
   if (options.width) {
     returnValue += `;width=${options.width}`;
   }
@@ -2941,12 +2993,12 @@ ansiEscapes$1.image = (buffer, options = {}) => {
   if (options.preserveAspectRatio === false) {
     returnValue += ';preserveAspectRatio=0';
   }
-  return returnValue + ':' + buffer.toString('base64') + BEL$1;
+  return returnValue + ':' + buffer.toString('base64') + BEL;
 };
-ansiEscapes$1.iTerm = {
-  setCwd: (cwd = cwdFunction()) => `${OSC$1}50;CurrentDir=${cwd}${BEL$1}`,
+ansiEscapes.iTerm = {
+  setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
   annotation(message, options = {}) {
-    let returnValue = `${OSC$1}1337;`;
+    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')) {
@@ -2959,7 +3011,7 @@ ansiEscapes$1.iTerm = {
     } else {
       returnValue += message;
     }
-    return returnValue + BEL$1;
+    return returnValue + BEL;
   }
 };
 
@@ -3034,7 +3086,7 @@ const createLog = ({
       return "";
     }
     clearAttemptResult = true;
-    return ansiEscapes$1.eraseLines(visualLineCount);
+    return ansiEscapes.eraseLines(visualLineCount);
   };
   const spyStream = () => {
     if (stream === process.stdout) {
@@ -3082,511 +3134,139 @@ const createLog = ({
   const destroy = () => {
     if (streamOutputSpy) {
       streamOutputSpy(); // this uninstalls the spy
-      streamOutputSpy = null;
-      lastOutput = "";
-    }
-  };
-  Object.assign(log, {
-    write,
-    dynamicWrite,
-    destroy
-  });
-  return log;
-};
-const noopStreamSpy = () => "";
-
-// could be inlined but vscode do not correctly
-// expand/collapse template strings, so I put it at the bottom
-const addNewLines = (string, newLine) => {
-  if (newLine === "before") {
-    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 = () => {};
-
-// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
-/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : 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;
-    }
-  }
-
-  // Check for Azure DevOps pipelines.
-  // Has to be above the `!streamIsTTY` check.
-  if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
-    return 1;
-  }
-  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 ('GITHUB_ACTIONS' in env) {
-      return 3;
-    }
-    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', '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;
-  }
-  if (env.COLORTERM === 'truecolor') {
-    return 3;
-  }
-  if (env.TERM === 'xterm-kitty') {
-    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;
-
-// GitHub workflow does support ANSI but "supports-color" returns false
-// 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") ;
-}
-
-// 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$1.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) + SEP + (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 (y < 0) {
-    returnValue += ESC + -y + 'A';
-  } else if (y > 0) {
-    returnValue += ESC + y + 'B';
-  }
-  return returnValue;
-};
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC + 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.eraseLines = count => {
-  let clear = '';
-  for (let i = 0; i < count; i++) {
-    clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
-  }
-  if (count) {
-    clear += ansiEscapes.cursorLeft;
-  }
-  return clear;
+      streamOutputSpy = null;
+      lastOutput = "";
+    }
+  };
+  Object.assign(log, {
+    write,
+    dynamicWrite,
+    destroy
+  });
+  return log;
 };
-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$1.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;
-ansiEscapes.link = (text, url) => [OSC, '8', SEP, SEP, url, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
-ansiEscapes.image = (buffer, options = {}) => {
-  let returnValue = `${OSC}1337;File=inline=1`;
-  if (options.width) {
-    returnValue += `;width=${options.width}`;
+const noopStreamSpy = () => "";
+
+// could be inlined but vscode do not correctly
+// expand/collapse template strings, so I put it at the bottom
+const addNewLines = (string, newLine) => {
+  if (newLine === "before") {
+    return `
+${string}`;
   }
-  if (options.height) {
-    returnValue += `;height=${options.height}`;
+  if (newLine === "after") {
+    return `${string}
+`;
   }
-  if (options.preserveAspectRatio === false) {
-    returnValue += ';preserveAspectRatio=0';
+  if (newLine === "around") {
+    return `
+${string}
+`;
   }
-  return returnValue + ':' + buffer.toString('base64') + BEL;
+  return string;
 };
-ansiEscapes.iTerm = {
-  setCwd: (cwd = process$1.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');
+
+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();
     }
-    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;
+  } else {
+    log.write(update(render()));
+  }
+  const stop = message => {
+    running = false;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
     }
-    return returnValue + BEL;
+    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 memoize = compute => {
@@ -5264,7 +4944,7 @@ const startServer = async ({
   logLevel,
   startLog = true,
   serverName = "server",
-  protocol = "http",
+  https = false,
   http2 = false,
   http1Allowed = true,
   redirectHttpToHttps,
@@ -5275,8 +4955,6 @@ const startServer = async ({
   port = 0,
   // assign a random available port
   portHint,
-  privateKey,
-  certificate,
   // when inside a worker, we should not try to stop server on SIGINT
   // otherwise it can create an EPIPE error while primary process tries
   // to kill the server
@@ -5307,39 +4985,52 @@ const startServer = async ({
   // 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
+  requestBodyLifetime = 60_000 * 2,
+  // 2s
+  ...rest
 } = {}) => {
+  // param validations
+  {
+    const unexpectedParamNames = Object.keys(rest);
+    if (unexpectedParamNames.length > 0) {
+      throw new TypeError(`${unexpectedParamNames.join(",")}: there is no such param`);
+    }
+    if (https) {
+      if (typeof https !== "object") {
+        throw new TypeError(`https must be an object, got ${https}`);
+      }
+      const {
+        certificate,
+        privateKey
+      } = https;
+      if (!certificate || !privateKey) {
+        throw new TypeError(`https must be an object with { certificate, privateKey }`);
+      }
+    }
+    if (http2 && !https) {
+      throw new Error(`http2 needs https`);
+    }
+  }
   const logger = createLogger({
     logLevel
   });
-  if (protocol !== "http" && protocol !== "https") {
-    throw new Error(`protocol must be http or https, got ${protocol}`);
-  }
-  if (protocol === "https") {
-    if (!certificate) {
-      throw new Error(`missing certificate for https server`);
+  // param warnings and normalization
+  {
+    if (redirectHttpToHttps === undefined && https && !allowHttpRequestOnHttps) {
+      redirectHttpToHttps = true;
     }
-    if (!privateKey) {
-      throw new Error(`missing privateKey for https server`);
+    if (redirectHttpToHttps && !https) {
+      logger.warn(`redirectHttpToHttps ignored because protocol is http`);
+      redirectHttpToHttps = false;
+    }
+    if (allowHttpRequestOnHttps && redirectHttpToHttps) {
+      logger.warn(`redirectHttpToHttps ignored because allowHttpRequestOnHttps is enabled`);
+      redirectHttpToHttps = false;
+    }
+    if (allowHttpRequestOnHttps && !https) {
+      logger.warn(`allowHttpRequestOnHttps ignored because protocol is http`);
+      allowHttpRequestOnHttps = false;
     }
-  }
-  if (http2 && protocol !== "https") {
-    throw new Error(`http2 needs "https" but protocol is "${protocol}"`);
-  }
-  if (redirectHttpToHttps === undefined && protocol === "https" && !allowHttpRequestOnHttps) {
-    redirectHttpToHttps = true;
-  }
-  if (redirectHttpToHttps && protocol === "http") {
-    logger.warn(`redirectHttpToHttps ignored because protocol is http`);
-    redirectHttpToHttps = false;
-  }
-  if (allowHttpRequestOnHttps && redirectHttpToHttps) {
-    logger.warn(`redirectHttpToHttps ignored because allowHttpRequestOnHttps is enabled`);
-    redirectHttpToHttps = false;
-  }
-  if (allowHttpRequestOnHttps && protocol === "http") {
-    logger.warn(`allowHttpRequestOnHttps ignored because protocol is http`);
-    allowHttpRequestOnHttps = false;
   }
   const server = {};
   const serviceController = createServiceController(services);
@@ -5370,11 +5061,9 @@ const startServer = async ({
     });
     startServerOperation.throwIfAborted();
     nodeServer = await createNodeServer({
-      protocol,
+      https,
       redirectHttpToHttps,
       allowHttpRequestOnHttps,
-      certificate,
-      privateKey,
       http2,
       http1Allowed
     });
@@ -5385,6 +5074,7 @@ const startServer = async ({
       nodeServer.unref();
     }
     const createOrigin = hostname => {
+      const protocol = https ? "https" : "http";
       if (isIP(hostname) === 6) {
         return `${protocol}://[${hostname}]`;
       }
@@ -6099,7 +5789,7 @@ const startServer = async ({
       let websocketServer = new WebSocketServer({
         noServer: true
       });
-      const websocketOrigin = protocol === "https" ? `wss://${hostname}:${port}` : `ws://${hostname}:${port}`;
+      const websocketOrigin = https ? `wss://${hostname}:${port}` : `ws://${hostname}:${port}`;
       server.websocketOrigin = websocketOrigin;
       const upgradeCallback = (nodeRequest, socket, head) => {
         websocketServer.handleUpgrade(nodeRequest, socket, head, async websocket => {
@@ -6158,32 +5848,37 @@ const startServer = async ({
   return server;
 };
 const createNodeServer = async ({
-  protocol,
+  https,
   redirectHttpToHttps,
   allowHttpRequestOnHttps,
-  certificate,
-  privateKey,
   http2,
   http1Allowed
 }) => {
-  if (protocol === "http") {
-    return http.createServer();
-  }
-  if (redirectHttpToHttps || allowHttpRequestOnHttps) {
-    return createPolyglotServer({
+  if (https) {
+    const {
       certificate,
-      privateKey,
-      http2,
-      http1Allowed
+      privateKey
+    } = https;
+    if (redirectHttpToHttps || allowHttpRequestOnHttps) {
+      return createPolyglotServer({
+        certificate,
+        privateKey,
+        http2,
+        http1Allowed
+      });
+    }
+    const {
+      createServer
+    } = await import("node:https");
+    return createServer({
+      cert: certificate,
+      key: privateKey
     });
   }
   const {
     createServer
-  } = await import("node:https");
-  return createServer({
-    cert: certificate,
-    key: privateKey
-  });
+  } = await import("node:http");
+  return createServer();
 };
 const testCanPushStream = http2Stream => {
   if (!http2Stream.pushAllowed) {
@@ -8578,7 +8273,7 @@ const createResolveUrlError = ({
     reason,
     ...details
   }) => {
-    const resolveError = new Error(createDetailedMessage$2(`Failed to resolve url reference`, {
+    const resolveError = new Error(createDetailedMessage$1(`Failed to resolve url reference`, {
       reason,
       ...details,
       "specifier": `"${reference.specifier}"`,
@@ -8612,7 +8307,7 @@ const createFetchUrlContentError = ({
     reason,
     ...details
   }) => {
-    const fetchError = new Error(createDetailedMessage$2(`Failed to fetch url content`, {
+    const fetchError = new Error(createDetailedMessage$1(`Failed to fetch url content`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -8679,7 +8374,7 @@ const createTransformUrlContentError = ({
     reason,
     ...details
   }) => {
-    const transformError = new Error(createDetailedMessage$2(`"transformUrlContent" error on "${urlInfo.type}"`, {
+    const transformError = new Error(createDetailedMessage$1(`"transformUrlContent" error on "${urlInfo.type}"`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -8732,7 +8427,7 @@ const createFinalizeUrlContentError = ({
   urlInfo,
   error
 }) => {
-  const finalizeError = new Error(createDetailedMessage$2(`"finalizeUrlContent" error on "${urlInfo.type}"`, {
+  const finalizeError = new Error(createDetailedMessage$1(`"finalizeUrlContent" error on "${urlInfo.type}"`, {
     ...detailsFromValueThrown(error),
     "url": urlInfo.url,
     "url reference trace": reference.trace.message,
@@ -8976,7 +8671,7 @@ const createKitchen = ({
   writeGeneratedFiles,
   outDirectoryUrl
 }) => {
-  const logger = createLogger$1({
+  const logger = createLogger({
     logLevel
   });
   const kitchenContext = {
@@ -9238,7 +8933,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
     try {
       const fetchUrlContentReturnValue = await pluginController.callAsyncHooksUntil("fetchUrlContent", urlInfo, contextDuringFetch);
       if (!fetchUrlContentReturnValue) {
-        logger.warn(createDetailedMessage$2(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
+        logger.warn(createDetailedMessage$1(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
           "url": urlInfo.url,
           "url reference trace": reference.trace.message
         }));
@@ -15417,10 +15112,7 @@ const jsenvPluginAsJsClassicLibrary = ({
           ...context,
           buildDirectoryUrl: context.outDirectoryUrl
         },
-        options: {
-          babelHelpersChunk: false,
-          preserveDynamicImport: true
-        }
+        preserveDynamicImport: true
       });
       const jsModuleBundledUrlInfo = bundleUrlInfos[jsModuleUrlInfo.url];
       if (context.dev) {
@@ -21036,8 +20728,26 @@ const build = async ({
   writeOnFileSystem = true,
   writeGeneratedFiles = false,
   assetManifest = versioningMethod === "filename",
-  assetManifestFileRelativeUrl = "asset-manifest.json"
+  assetManifestFileRelativeUrl = "asset-manifest.json",
+  ...rest
 }) => {
+  // param validation
+  {
+    const unexpectedParamNames = Object.keys(rest);
+    if (unexpectedParamNames.length > 0) {
+      throw new TypeError(`${unexpectedParamNames.join(",")}: there is no such param`);
+    }
+    const rootDirectoryUrlValidation = validateDirectoryUrl(rootDirectoryUrl);
+    if (!rootDirectoryUrlValidation.valid) {
+      throw new TypeError(`rootDirectoryUrl ${rootDirectoryUrlValidation.message}, got ${rootDirectoryUrl}`);
+    }
+    rootDirectoryUrl = rootDirectoryUrlValidation.value;
+    const buildDirectoryUrlValidation = validateDirectoryUrl(buildDirectoryUrl);
+    if (!buildDirectoryUrlValidation.valid) {
+      throw new TypeError(`buildDirectoryUrl ${buildDirectoryUrlValidation.message}, got ${buildDirectoryUrlValidation}`);
+    }
+    buildDirectoryUrl = buildDirectoryUrlValidation.value;
+  }
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -21047,8 +20757,6 @@ const build = async ({
       }, abort);
     });
   }
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
-  buildDirectoryUrl = assertAndNormalizeDirectoryUrl(buildDirectoryUrl);
   assertEntryPoints({
     entryPoints
   });
@@ -21081,7 +20789,7 @@ const build = async ({
     signal,
     logLevel
   }) => {
-    const logger = createLogger$1({
+    const logger = createLogger({
       logLevel
     });
     const buildOperation = Abort.startOperation();
@@ -21366,7 +21074,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             const rawUrl = buildDirectoryRedirections.get(url) || url;
             const rawUrlInfo = rawGraph.getUrlInfo(rawUrl);
             if (!rawUrlInfo) {
-              throw new Error(createDetailedMessage$2(`Cannot find url`, {
+              throw new Error(createDetailedMessage$1(`Cannot find url`, {
                 url,
                 "raw urls": Array.from(buildDirectoryRedirections.values()),
                 "build urls": Array.from(buildDirectoryRedirections.keys())
@@ -22996,12 +22704,10 @@ const startDevServer = async ({
   handleSIGINT = true,
   logLevel = "info",
   serverLogLevel = "warn",
-  protocol = "http",
+  https,
   // it's better to use http1 by default because it allows to get statusText in devtools
   // which gives valuable information when there is errors
   http2 = false,
-  certificate,
-  privateKey,
   hostname,
   port = 3456,
   acceptAnyIp,
@@ -23044,12 +22750,24 @@ const startDevServer = async ({
   sourcemapsSourcesContent,
   // no real need to write files during github workflow
   // and mitigates https://github.com/actions/runner-images/issues/3885
-  writeGeneratedFiles = !process.env.CI
+  writeGeneratedFiles = !process.env.CI,
+  ...rest
 }) => {
-  const logger = createLogger$1({
+  // params type checking
+  {
+    const unexpectedParamNames = Object.keys(rest);
+    if (unexpectedParamNames.length > 0) {
+      throw new TypeError(`${unexpectedParamNames.join(",")}: there is no such param`);
+    }
+    const rootDirectoryUrlValidation = validateDirectoryUrl(rootDirectoryUrl);
+    if (!rootDirectoryUrlValidation.valid) {
+      throw new TypeError(`rootDirectoryUrl ${rootDirectoryUrlValidation.message}, got ${rootDirectoryUrl}`);
+    }
+    rootDirectoryUrl = rootDirectoryUrlValidation.value;
+  }
+  const logger = createLogger({
     logLevel
   });
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -23139,10 +22857,8 @@ const startDevServer = async ({
     keepProcessAlive,
     logLevel: serverLogLevel,
     startLog: false,
-    protocol,
+    https,
     http2,
-    certificate,
-    privateKey,
     acceptAnyIp,
     hostname,
     port,
@@ -23225,14 +22941,14 @@ const startDevServer = async ({
     // default error handling
     jsenvServiceErrorHandler({
       sendErrorDetails: true
-    })],
-    onStop: reason => {
-      onStop();
-      serverStopCallbacks.forEach(serverStopCallback => {
-        serverStopCallback(reason);
-      });
-      serverStopCallbacks.length = 0;
-    }
+    })]
+  });
+  server.stoppedPromise.then(reason => {
+    onStop();
+    serverStopCallbacks.forEach(serverStopCallback => {
+      serverStopCallback(reason);
+    });
+    serverStopCallbacks.length = 0;
   });
   startDevServerTask.done();
   if (hostname) {
@@ -23369,7 +23085,7 @@ const readNodeV8CoverageDirectory = async ({
             timeSpentTrying += 200;
             return tryReadJsonFile();
           }
-          console.warn(createDetailedMessage$2(`Error while reading coverage file`, {
+          console.warn(createDetailedMessage$1(`Error while reading coverage file`, {
             "error stack": e.stack,
             "file": dirEntryUrl
           }));
@@ -23530,7 +23246,7 @@ const composeV8AndIstanbul = (v8FileByFileCoverage, istanbulFileByFileCoverage,
     const v8Coverage = v8FileByFileCoverage[key];
     if (v8Coverage) {
       if (coverageV8ConflictWarning) {
-        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.`, {
+        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.`, {
           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"
         }));
@@ -23924,7 +23640,7 @@ const run = async ({
             cb(runResult);
           } catch (e) {
             cb({
-              status: "errored",
+              status: "failed",
               errors: [e]
             });
           }
@@ -23955,7 +23671,7 @@ const run = async ({
         result.status = "aborted";
       }
     } else {
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(e);
     }
   } finally {
@@ -24043,7 +23759,7 @@ const generateFileExecutionSteps = ({
       return;
     }
     if (typeof stepConfig !== "object") {
-      throw new TypeError(createDetailedMessage$2(`found unexpected value in plan, they must be object`, {
+      throw new TypeError(createDetailedMessage$1(`found unexpected value in plan, they must be object`, {
         ["file relative path"]: fileRelativeUrl,
         ["execution name"]: executionName,
         ["value"]: stepConfig
@@ -24062,7 +23778,7 @@ const EXECUTION_COLORS = {
   executing: ANSI.BLUE,
   aborted: ANSI.MAGENTA,
   timedout: ANSI.MAGENTA,
-  errored: ANSI.RED,
+  failed: ANSI.RED,
   completed: ANSI.GREEN,
   cancelled: ANSI.GREY
 };
@@ -24195,8 +23911,8 @@ const createStatusSummary = ({
   if (counters.timedout === counters.total) {
     return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`;
   }
-  if (counters.errored === counters.total) {
-    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`;
+  if (counters.failed === counters.total) {
+    return `all ${ANSI.color(`failed`, EXECUTION_COLORS.failed)}`;
   }
   if (counters.completed === counters.total) {
     return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`;
@@ -24215,8 +23931,8 @@ const createMixedDetails = ({
   if (counters.timedout) {
     parts.push(`${counters.timedout} ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`);
   }
-  if (counters.errored) {
-    parts.push(`${counters.errored} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`);
+  if (counters.failed) {
+    parts.push(`${counters.failed} ${ANSI.color(`failed`, EXECUTION_COLORS.failed)}`);
   }
   if (counters.completed) {
     parts.push(`${counters.completed} ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`);
@@ -24249,11 +23965,11 @@ const descriptionFormatters = {
   }) => {
     return ANSI.color(`${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} timeout after ${executionParams.allocatedMs}ms`, EXECUTION_COLORS.timedout);
   },
-  errored: ({
+  efailedrrored: ({
     index,
     total
   }) => {
-    return ANSI.color(`${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} errored`, EXECUTION_COLORS.errored);
+    return ANSI.color(`${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} failed`, EXECUTION_COLORS.failed);
   },
   completed: ({
     index,
@@ -24456,7 +24172,7 @@ const executePlan = async (plan, {
       }
     });
   });
-  logger.debug(createDetailedMessage$2(`Prepare executing plan`, {
+  logger.debug(createDetailedMessage$1(`Prepare executing plan`, {
     runtimes: JSON.stringify(runtimes, null, "  ")
   }));
   const multipleExecutionsOperation = Abort.startOperation();
@@ -24483,7 +24199,7 @@ const executePlan = async (plan, {
         await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE);
       } else {
         coverageMethodForNodeJs = "Profiler";
-        logger.warn(createDetailedMessage$2(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
+        logger.warn(createDetailedMessage$1(`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`
         }));
@@ -24572,7 +24288,7 @@ const executePlan = async (plan, {
       total: executionSteps.length,
       aborted: 0,
       timedout: 0,
-      errored: 0,
+      failed: 0,
       completed: 0,
       done: 0
     };
@@ -24655,7 +24371,7 @@ const executePlan = async (plan, {
           });
         } else {
           executionResult = {
-            status: "errored",
+            status: "failed",
             errors: [new Error(`No file at ${fileRelativeUrl} for execution "${executionName}"`)]
           };
         }
@@ -24679,8 +24395,8 @@ const executePlan = async (plan, {
           counters.aborted++;
         } else if (executionResult.status === "timedout") {
           counters.timedout++;
-        } else if (executionResult.status === "errored") {
-          counters.errored++;
+        } else if (executionResult.status === "failed") {
+          counters.failed++;
         } else if (executionResult.status === "completed") {
           counters.completed++;
         }
@@ -24915,46 +24631,58 @@ const executeTestPlan = async ({
   coverageReportSkipFull = false,
   coverageReportTextLog = true,
   coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
-  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null
+  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null,
+  ...rest
 }) => {
-  const logger = createLogger$1({
-    logLevel
-  });
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
-  if (typeof testPlan !== "object") {
-    throw new Error(`testPlan must be an object, got ${testPlan}`);
-  }
-  if (coverageEnabled) {
-    if (typeof coverageConfig !== "object") {
-      throw new TypeError(`coverageConfig must be an object, got ${coverageConfig}`);
-    }
-    if (Object.keys(coverageConfig).length === 0) {
-      logger.warn(`coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`);
-    }
-    if (!coverageAndExecutionAllowed) {
-      const associationsForExecute = URL_META.resolveAssociations({
-        execute: testPlan
-      }, "file:///");
-      const associationsForCover = URL_META.resolveAssociations({
-        cover: coverageConfig
-      }, "file:///");
-      const patternsMatchingCoverAndExecute = Object.keys(associationsForExecute.execute).filter(testPlanPattern => {
-        const {
-          cover
-        } = URL_META.applyAssociations({
-          url: testPlanPattern,
-          associations: associationsForCover
+  // param validation
+  {
+    const unexpectedParamNames = Object.keys(rest);
+    if (unexpectedParamNames.length > 0) {
+      throw new TypeError(`${unexpectedParamNames.join(",")}: there is no such param`);
+    }
+    const rootDirectoryUrlValidation = validateDirectoryUrl(rootDirectoryUrl);
+    if (!rootDirectoryUrlValidation.valid) {
+      throw new TypeError(`rootDirectoryUrl ${rootDirectoryUrlValidation.message}, got ${rootDirectoryUrl}`);
+    }
+    rootDirectoryUrl = rootDirectoryUrlValidation.value;
+    if (typeof testPlan !== "object") {
+      throw new Error(`testPlan must be an object, got ${testPlan}`);
+    }
+    if (coverageEnabled) {
+      if (typeof coverageConfig !== "object") {
+        throw new TypeError(`coverageConfig must be an object, got ${coverageConfig}`);
+      }
+      if (!coverageAndExecutionAllowed) {
+        const associationsForExecute = URL_META.resolveAssociations({
+          execute: testPlan
+        }, "file:///");
+        const associationsForCover = URL_META.resolveAssociations({
+          cover: coverageConfig
+        }, "file:///");
+        const patternsMatchingCoverAndExecute = Object.keys(associationsForExecute.execute).filter(testPlanPattern => {
+          const {
+            cover
+          } = URL_META.applyAssociations({
+            url: testPlanPattern,
+            associations: associationsForCover
+          });
+          return cover;
         });
-        return cover;
-      });
-      if (patternsMatchingCoverAndExecute.length) {
-        // It would be strange, for a given file to be both covered and executed
-        throw new Error(createDetailedMessage$2(`some file will be both covered and executed`, {
-          patterns: patternsMatchingCoverAndExecute
-        }));
+        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`, {
+            patterns: patternsMatchingCoverAndExecute
+          }));
+        }
       }
     }
   }
+  const logger = createLogger({
+    logLevel
+  });
+  if (Object.keys(coverageConfig).length === 0) {
+    logger.warn(`coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`);
+  }
   const result = await executePlan(testPlan, {
     signal,
     handleSIGINT,
@@ -25334,12 +25062,12 @@ const createRuntimeFromPlaywright = ({
       }
       if (winner.name === "error") {
         let error = winner.data;
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(error);
         return;
       }
       if (winner.name === "closed") {
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(isBrowserDedicatedToExecution ? new Error(`browser disconnected during execution`) : new Error(`page closed during execution`));
         return;
       }
@@ -25351,8 +25079,8 @@ const createRuntimeFromPlaywright = ({
       result.namespace = executionResults;
       Object.keys(executionResults).forEach(key => {
         const executionResult = executionResults[key];
-        if (executionResult.status === "errored") {
-          result.status = "errored";
+        if (executionResult.status === "failed") {
+          result.status = "failed";
           result.errors.push({
             ...executionResult.exception,
             stack: executionResult.exception.text
@@ -25370,7 +25098,7 @@ const createRuntimeFromPlaywright = ({
         await callback();
       }, Promise.resolve());
     } catch (e) {
-      result.status = "errored";
+      result.status = "failed";
       result.errors = [e];
     }
     if (keepRunning) {
@@ -25452,7 +25180,7 @@ const importPlaywright = async ({
     return namespace;
   } catch (e) {
     if (e.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(createDetailedMessage$2(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
+      throw new Error(createDetailedMessage$1(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
         suggestion: `npm install --save-dev playwright`
       }), {
         cause: e
@@ -25610,7 +25338,7 @@ const createChildExecOptions = async ({
   debugModeInheritBreak = true
 } = {}) => {
   if (typeof debugMode === "string" && AVAILABLE_DEBUG_MODE.indexOf(debugMode) === -1) {
-    throw new TypeError(createDetailedMessage$2(`unexpected debug mode.`, {
+    throw new TypeError(createDetailedMessage$1(`unexpected debug mode.`, {
       ["debug mode"]: debugMode,
       ["allowed debug mode"]: AVAILABLE_DEBUG_MODE
     }));
@@ -25876,7 +25604,7 @@ nodeChildProcess.run = async ({
     stdio: ["pipe", "pipe", "pipe", "ipc"],
     env: envForChildProcess
   });
-  logger.debug(createDetailedMessage$2(`child process forked (pid ${childProcess.pid})`, {
+  logger.debug(createDetailedMessage$1(`child process forked (pid ${childProcess.pid})`, {
     "execArgv": execArgv.join(`\n`),
     "custom env": JSON.stringify(env, null, "  ")
   }));
@@ -25999,7 +25727,7 @@ nodeChildProcess.run = async ({
     if (winner.name === "error") {
       const error = winner.data;
       removeOutputListener();
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(error);
       return;
     }
@@ -26009,18 +25737,18 @@ nodeChildProcess.run = async ({
       } = winner.data;
       await cleanup("process exit");
       if (code === 12) {
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(new Error(`node process exited with 12 (the forked child process wanted to use a non-available port for debug)`));
         return;
       }
       if (code === null || code === 0 || code === EXIT_CODES.SIGINT || code === EXIT_CODES.SIGTERM || code === EXIT_CODES.SIGABORT) {
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(new Error(`node process exited during execution`));
         return;
       }
       // process.exit(1) in child process or process.exitCode = 1 + process.exit()
       // means there was an error even if we don't know exactly what.
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(new Error(`node process exited with code ${code} during execution`));
       return;
     }
@@ -26029,7 +25757,7 @@ nodeChildProcess.run = async ({
       value
     } = winner.data;
     if (status === "action-failed") {
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(value);
       return;
     }
@@ -26046,7 +25774,7 @@ nodeChildProcess.run = async ({
   try {
     await writeResult();
   } catch (e) {
-    result.status = "errored";
+    result.status = "failed";
     result.errors.push(e);
   }
   if (keepRunning) {
@@ -26272,7 +26000,7 @@ nodeWorkerThread.run = async ({
     if (winner.name === "error") {
       const error = winner.data;
       removeOutputListener();
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(error);
       return;
     }
@@ -26282,18 +26010,18 @@ nodeWorkerThread.run = async ({
       } = winner.data;
       await cleanup("process exit");
       if (code === 12) {
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(new Error(`node process exited with 12 (the forked child process wanted to use a non-available port for debug)`));
         return;
       }
       if (code === null || code === 0 || code === EXIT_CODES.SIGINT || code === EXIT_CODES.SIGTERM || code === EXIT_CODES.SIGABORT) {
-        result.status = "errored";
+        result.status = "failed";
         result.errors.push(new Error(`node worker thread exited during execution`));
         return;
       }
       // process.exit(1) in child process or process.exitCode = 1 + process.exit()
       // means there was an error even if we don't know exactly what.
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(new Error(`node worker thread exited with code ${code} during execution`));
     }
     const {
@@ -26301,7 +26029,7 @@ nodeWorkerThread.run = async ({
       value
     } = winner.data;
     if (status === "action-failed") {
-      result.status = "errored";
+      result.status = "failed";
       result.errors.push(value);
       return;
     }
@@ -26318,7 +26046,7 @@ nodeWorkerThread.run = async ({
   try {
     await writeResult();
   } catch (e) {
-    result.status = "errored";
+    result.status = "failed";
     result.errors.push(e);
   }
   if (keepRunning) {
@@ -26409,10 +26137,8 @@ const startBuildServer = async ({
   handleSIGINT = true,
   logLevel,
   serverLogLevel = "warn",
-  protocol = "http",
+  https,
   http2,
-  certificate,
-  privateKey,
   acceptAnyIp,
   hostname,
   port = 9779,
@@ -26429,7 +26155,7 @@ const startBuildServer = async ({
   buildServerMainFile = getCallerPosition().url,
   cooldownBetweenFileEvents
 }) => {
-  const logger = createLogger$1({
+  const logger = createLogger({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
@@ -26539,10 +26265,8 @@ const startBuildServer = async ({
     keepProcessAlive,
     logLevel: serverLogLevel,
     startLog: false,
-    protocol,
+    https,
     http2,
-    certificate,
-    privateKey,
     acceptAnyIp,
     hostname,
     port,
@@ -26638,7 +26362,7 @@ const execute = async ({
   runtimeParams,
   ignoreError = false
 }) => {
-  const logger = createLogger$1({
+  const logger = createLogger({
     logLevel
   });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
@@ -26682,7 +26406,7 @@ const execute = async ({
   });
   result = resultTransformer(result);
   try {
-    if (result.status === "errored") {
+    if (result.status === "failed") {
       if (ignoreError) {
         return result;
       }