@marko/run 0.5.12 → 0.5.14

package/dist/adapter/index.cjs

@@ -43,20 +43,381 @@ var import_url = require("url");
 var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
 // src/adapter/index.ts
-var import_path2 = __toESM(require("path"), 1);
+var import_run_explorer = require("@marko/run-explorer");
 var import_fs2 = __toESM(require("fs"), 1);
 var import_inspector2 = __toESM(require("inspector"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 
-// src/adapter/dev-server.ts
-var import_path = __toESM(require("path"), 1);
-var import_vite = require("vite");
+// src/vite/utils/server.ts
+var import_child_process = __toESM(require("child_process"), 1);
+var import_cluster = __toESM(require("cluster"), 1);
+var import_dotenv = require("dotenv");
+var import_fs = __toESM(require("fs"), 1);
+var import_net = __toESM(require("net"), 1);
+async function parseEnv(envFile) {
+  if (import_fs.default.existsSync(envFile)) {
+    const content = await import_fs.default.promises.readFile(envFile, "utf8");
+    return (0, import_dotenv.parse)(content);
+  }
+}
+function loadEnv(envFile) {
+  (0, import_dotenv.config)({ path: envFile });
+}
+async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), wait = 3e4, stdio = ["ignore", "inherit", "inherit"]) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const proc = import_child_process.default.spawn(cmd, args, {
+    cwd,
+    shell: true,
+    stdio,
+    windowsHide: true,
+    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
+  });
+  const close = () => {
+    proc.unref();
+    proc.kill();
+  };
+  try {
+    await Promise.race([waitForError(proc, port), waitForServer(port, wait)]);
+  } catch (err) {
+    close();
+    throw err;
+  }
+  return {
+    port,
+    close
+  };
+}
+async function spawnServerWorker(module2, args = [], port = 0, env, wait = true) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const originalExec = import_cluster.default.settings.exec;
+  const originalArgs = import_cluster.default.settings.execArgv;
+  try {
+    import_cluster.default.settings.exec = module2;
+    import_cluster.default.settings.execArgv = args;
+    const worker = import_cluster.default.fork({
+      ...env,
+      NODE_ENV: "development",
+      ...process.env,
+      PORT: `${port}`
+    });
+    if (wait) {
+      return new Promise((resolve) => {
+        function ready(message) {
+          if (message === "ready") {
+            worker.off("message", ready);
+            resolve(worker);
+          }
+        }
+        worker.on("message", ready);
+      });
+    }
+    return worker;
+  } finally {
+    import_cluster.default.settings.exec = originalExec;
+    import_cluster.default.settings.execArgv = originalArgs;
+  }
+}
+async function waitForError(proc, port) {
+  return new Promise((_, reject) => {
+    proc.once("error", reject);
+    proc.once("exit", (code) => {
+      reject(
+        new Error(
+          `Process exited with code ${code} while waiting for server to start on port "${port}".`
+        )
+      );
+    });
+  });
+}
+async function waitForServer(port, wait = 0) {
+  let remaining = wait > 0 ? wait : Infinity;
+  let connection;
+  while (!(connection = await getConnection(port))) {
+    if (remaining >= 100) {
+      remaining -= 100;
+      await sleep(100);
+    } else {
+      throw new Error(
+        `Timeout while wating for server to start on port "${port}".`
+      );
+    }
+  }
+  return connection;
+}
+async function waitForWorker(worker, port) {
+  return new Promise((resolve, reject) => {
+    function listening(address) {
+      if (address.port === port) {
+        worker.off("listening", listening);
+        resolve();
+      }
+    }
+    worker.on("listening", listening).once("error", reject).once("exit", (code) => {
+      reject(
+        new Error(
+          `Worker exited with code ${code} while waiting for dev server to start on port "${port}".`
+        )
+      );
+    });
+  });
+}
+async function getConnection(port) {
+  return new Promise((resolve) => {
+    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
+      connection.end();
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
+  });
+}
+async function isPortInUse(port) {
+  return Boolean(await getConnection(port));
+}
+async function getAvailablePort(port) {
+  if (port && !await isPortInUse(port)) {
+    return port;
+  }
+  return new Promise((resolve) => {
+    const server = import_net.default.createServer().listen(0, () => {
+      const { port: port2 } = server.address();
+      server.close(() => resolve(port2));
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getInspectOptions(args) {
+  for (const arg of args) {
+    const match = arg.match(/^--inspect(-brk)?(?:=(?:(.+):)?(.+))?$/);
+    if (match) {
+      return {
+        host: match[2],
+        port: parseInt(match[3], 10) || void 0,
+        wait: !!match[1]
+      };
+    }
+  }
+}
+
+// src/adapter/dev-server.ts
+var import_path = __toESM(require("path"), 1);
+var import_vite = require("vite");
+
+// src/adapter/logger.ts
+var import_draftlog = __toESM(require("draftlog"), 1);
+var import_human_format = __toESM(require("human-format"), 1);
+var import_inspector = __toESM(require("inspector"), 1);
+var import_kleur = __toESM(require("kleur"), 1);
+if (!import_inspector.default.url()) {
+  import_draftlog.default.into(console);
+  import_draftlog.default.defaults.canReWrite = false;
+}
+var HttpStatusColors = [
+  "",
+  // Unused
+  "green",
+  // 1xx
+  "green",
+  // 2xx
+  "cyan",
+  // 3xx
+  "yellow",
+  // 4xx
+  "red"
+  // 5xx
+];
+var IdChars = [
+  "",
+  import_kleur.default.cyan("\xB9"),
+  import_kleur.default.magenta("\xB2"),
+  import_kleur.default.green("\xB3"),
+  import_kleur.default.red("\u2074"),
+  import_kleur.default.cyan("\u2075"),
+  import_kleur.default.magenta("\u2076"),
+  import_kleur.default.green("\u2077"),
+  import_kleur.default.red("\u2078"),
+  import_kleur.default.cyan("\u2079"),
+  import_kleur.default.red("\u207A")
+];
+var ArrowSteps = ["   ", "  \u25C0", " \u25C0\u2501", "\u25C0\u2501\u2501", "\u2501\u2501 ", "\u2501  ", "   "];
+function logger_default(_options = {}) {
+  let inFlight = 0;
+  return function logger(req, res, next) {
+    const startTime = Date.now();
+    const handleFinish = () => done("finish");
+    const handleClose = () => done("close");
+    res.on("finish", handleFinish);
+    res.on("close", handleClose);
+    const bitMask = ~inFlight & inFlight + 1;
+    const index = Math.log2(bitMask);
+    const id = IdChars[index];
+    if (index < IdChars.length) {
+      inFlight |= bitMask;
+    }
+    const finalizeLog = logRequest(id, req);
+    let bodyLength = 0;
+    const _write = res.write;
+    const _end = res.end;
+    res.write = (...args) => {
+      if (args[0]) {
+        if (typeof args[1] !== "function") {
+          bodyLength += Buffer.byteLength(args[0], args[1]);
+        } else {
+          bodyLength += args[0].length;
+        }
+      }
+      return _write.apply(res, args);
+    };
+    res.end = (...args) => {
+      if (args[0] && typeof args[0] !== "function") {
+        if (typeof args[1] !== "function") {
+          bodyLength += Buffer.byteLength(args[0], args[1]);
+        } else {
+          bodyLength += args[0].length;
+        }
+      }
+      return _end.apply(res, args);
+    };
+    next == null ? void 0 : next();
+    function done(event) {
+      res.off("finish", handleFinish);
+      res.off("close", handleClose);
+      finalizeLog();
+      if (index < 10) {
+        inFlight ^= bitMask;
+      }
+      let contentLength = res.getHeader("content-length") || 0;
+      if (Array.isArray(contentLength)) {
+        contentLength = parseInt(contentLength[0], 10) || 0;
+      } else if (typeof contentLength === "string") {
+        contentLength = parseInt(contentLength, 10) || 0;
+      }
+      logResponse(
+        id,
+        req,
+        res,
+        startTime,
+        contentLength || bodyLength,
+        event === "finish"
+      );
+    }
+  };
+}
+var spinners;
+function logRequest(id, req) {
+  const info = id + " " + import_kleur.default.bold(req.method) + " " + import_kleur.default.dim(req.url);
+  const final = import_kleur.default.dim(requestArrow(id)) + info;
+  if (console.draft) {
+    spinners ?? (spinners = createAnimationManager({ steps: ArrowSteps.length }));
+    const update = console.draft();
+    const stop = spinners.add((step) => {
+      update(import_kleur.default.cyan(requestArrow(id, step)) + info);
+    });
+    return () => {
+      stop();
+      update(final);
+    };
+  }
+  console.log(final);
+  return () => {
+  };
+}
+function logResponse(id, req, res, startTime, contentLength, success) {
+  const status = res.statusCode;
+  const color = HttpStatusColors[status / 100 | 0] || "red";
+  let length;
+  if (req.method === "HEAD" || [204, 205, 304].includes(status)) {
+    length = "";
+  } else if (!contentLength) {
+    length = import_kleur.default.dim("-");
+  } else {
+    length = formatMeasurement(bytes(contentLength));
+  }
+  let arrow = id ? "\u2501" : "\u2501\u2501";
+  if (success) {
+    arrow = import_kleur.default.dim(arrow + "\u25B6");
+  } else {
+    arrow = import_kleur.default.red(import_kleur.default.dim(arrow) + import_kleur.default.bold("x"));
+  }
+  console.log(
+    arrow + id + " " + import_kleur.default.bold(req.method) + " " + import_kleur.default.dim(req.url) + " " + import_kleur.default[color](status) + " " + formatMeasurement(time(startTime)) + " " + length
+  );
+}
+function requestArrow(id, step = 3) {
+  const arrow = ArrowSteps[step];
+  return id ? arrow.slice(0, -1) : arrow;
+}
+function time(start) {
+  const delta = Date.now() - start;
+  return delta < 5e3 ? [delta, "ms"] : [(delta / 1e3).toFixed(1), "s"];
+}
+function bytes(size) {
+  const { value, prefix } = import_human_format.default.raw(size, { maxDecimals: 2, unit: "b" });
+  return [value.toFixed(2), (prefix + "b").toLowerCase()];
+}
+function formatMeasurement([value, unit]) {
+  return import_kleur.default.dim(value + import_kleur.default.yellow(import_kleur.default.bold(unit)));
+}
+function createAnimationManager(options = {}) {
+  const { steps = 1e4, ms = 100 } = options;
+  const fns = /* @__PURE__ */ new Set();
+  let step = 0;
+  let isRunning = false;
+  let interval;
+  function start() {
+    step = 0;
+    isRunning = true;
+    interval = setInterval(() => {
+      if (isRunning) {
+        for (const fn of fns) {
+          fn(step);
+        }
+        step = (step + 1) % steps;
+      }
+    }, ms);
+  }
+  function stop() {
+    isRunning = false;
+    clearInterval(interval);
+  }
+  return {
+    add(fn) {
+      fns.add(fn);
+      if (!isRunning) {
+        start();
+      }
+      fn(step);
+      return () => {
+        fns.delete(fn);
+        if (!fns.size) {
+          stop();
+        }
+      };
+    }
+  };
+}
+
+// src/adapter/middleware.ts
+var import_node_stream = require("node:stream");
 
 // src/adapter/polyfill.ts
-var webStream = __toESM(require("stream/web"), 1);
 var import_crypto = require("crypto");
-var undici = __toESM(require("undici"), 1);
 var import_http = require("http");
+var webStream = __toESM(require("stream/web"), 1);
+var undici = __toESM(require("undici"), 1);
 globalThis.crypto ?? (globalThis.crypto = import_crypto.webcrypto);
 globalThis.fetch ?? (globalThis.fetch = undici.fetch);
 globalThis.Response ?? (globalThis.Response = undici.Response);
@@ -121,7 +482,6 @@ function getSetCookie_fallback(headers) {
 }
 
 // src/adapter/middleware.ts
-var import_node_stream = require("node:stream");
 function getForwardedHeader(req, name) {
   const value = req.headers["x-forwarded-" + name];
   if (value) {
@@ -232,277 +592,83 @@ function createMiddleware(fetch2, options) {
         } else {
           body = req;
         }
-        break;
-    }
-    const request = new Request(url, {
-      method: req.method,
-      headers: req.headers,
-      body,
-      // @ts-expect-error: Node requires this for streams
-      duplex: "half",
-      signal
-    });
-    const platform = createPlatform({
-      request: req,
-      response: res
-    });
-    let response;
-    try {
-      response = await fetch2(request, platform);
-    } catch (err) {
-      normalizeError(err);
-      if (next) {
-        next(err);
-      } else {
-        console.error(err);
-      }
-      return;
-    }
-    if (!response) {
-      if (next) {
-        next();
-      }
-      return;
-    }
-    res.statusCode = response.status;
-    copyResponseHeaders(res, response.headers);
-    if (!response.body) {
-      if (!response.headers.has("content-length")) {
-        res.setHeader("content-length", "0");
-      }
-      res.end();
-      return;
-    } else if (res.destroyed) {
-      controller.abort(new Error("Response stream destroyed"));
-      return;
-    }
-    writeResponse(response.body.getReader(), res, controller);
-  };
-}
-async function writeResponse(reader, res, controller) {
-  try {
-    while (!controller.signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        res.end();
-        return;
-      }
-      res.write(value);
-      if (res.flush) {
-        res.flush();
-      }
-    }
-  } catch (err) {
-    controller.abort(err);
-  }
-}
-var bodyConsumedErrorStream = new ReadableStream({
-  pull(controller) {
-    controller.error(
-      new Error(
-        "The request body stream has been destroyed or consumed by something before Marko Run."
-      )
-    );
-  }
-});
-
-// src/adapter/logger.ts
-var import_kleur = __toESM(require("kleur"), 1);
-var import_draftlog = __toESM(require("draftlog"), 1);
-var import_human_format = __toESM(require("human-format"), 1);
-var import_inspector = __toESM(require("inspector"), 1);
-if (!import_inspector.default.url()) {
-  import_draftlog.default.into(console);
-  import_draftlog.default.defaults.canReWrite = false;
-}
-var HttpStatusColors = [
-  "",
-  // Unused
-  "green",
-  // 1xx
-  "green",
-  // 2xx
-  "cyan",
-  // 3xx
-  "yellow",
-  // 4xx
-  "red"
-  // 5xx
-];
-var IdChars = [
-  "",
-  import_kleur.default.cyan("\xB9"),
-  import_kleur.default.magenta("\xB2"),
-  import_kleur.default.green("\xB3"),
-  import_kleur.default.red("\u2074"),
-  import_kleur.default.cyan("\u2075"),
-  import_kleur.default.magenta("\u2076"),
-  import_kleur.default.green("\u2077"),
-  import_kleur.default.red("\u2078"),
-  import_kleur.default.cyan("\u2079"),
-  import_kleur.default.red("\u207A")
-];
-var ArrowSteps = ["   ", "  \u25C0", " \u25C0\u2501", "\u25C0\u2501\u2501", "\u2501\u2501 ", "\u2501  ", "   "];
-function logger_default(_options = {}) {
-  let inFlight = 0;
-  return function logger(req, res, next) {
-    let startTime = Date.now();
-    const handleFinish = () => done("finish");
-    const handleClose = () => done("close");
-    res.on("finish", handleFinish);
-    res.on("close", handleClose);
-    const bitMask = ~inFlight & inFlight + 1;
-    const index = Math.log2(bitMask);
-    const id = IdChars[index];
-    if (index < IdChars.length) {
-      inFlight |= bitMask;
-    }
-    const finalizeLog = logRequest(id, req);
-    let bodyLength = 0;
-    const _write = res.write;
-    const _end = res.end;
-    res.write = (...args) => {
-      if (args[0]) {
-        if (typeof args[1] !== "function") {
-          bodyLength += Buffer.byteLength(args[0], args[1]);
-        } else {
-          bodyLength += args[0].length;
-        }
-      }
-      return _write.apply(res, args);
-    };
-    res.end = (...args) => {
-      if (args[0] && typeof args[0] !== "function") {
-        if (typeof args[1] !== "function") {
-          bodyLength += Buffer.byteLength(args[0], args[1]);
-        } else {
-          bodyLength += args[0].length;
-        }
-      }
-      return _end.apply(res, args);
-    };
-    next == null ? void 0 : next();
-    function done(event) {
-      res.off("finish", handleFinish);
-      res.off("close", handleClose);
-      finalizeLog();
-      if (index < 10) {
-        inFlight ^= bitMask;
-      }
-      let contentLength = res.getHeader("content-length") || 0;
-      if (Array.isArray(contentLength)) {
-        contentLength = parseInt(contentLength[0], 10) || 0;
-      } else if (typeof contentLength === "string") {
-        contentLength = parseInt(contentLength, 10) || 0;
-      }
-      logResponse(
-        id,
-        req,
-        res,
-        startTime,
-        contentLength || bodyLength,
-        event === "finish"
-      );
-    }
-  };
-}
-var spinners;
-function logRequest(id, req) {
-  const info = id + " " + import_kleur.default.bold(req.method) + " " + import_kleur.default.dim(req.url);
-  const final = import_kleur.default.dim(requestArrow(id)) + info;
-  if (console.draft) {
-    spinners ?? (spinners = createAnimationManager({ steps: ArrowSteps.length }));
-    const update = console.draft();
-    const stop = spinners.add((step) => {
-      update(import_kleur.default.cyan(requestArrow(id, step)) + info);
-    });
-    return () => {
-      stop();
-      update(final);
-    };
-  }
-  console.log(final);
-  return () => {
-  };
-}
-function logResponse(id, req, res, startTime, contentLength, success) {
-  const status = res.statusCode;
-  const color = HttpStatusColors[status / 100 | 0] || "red";
-  let length;
-  if (req.method === "HEAD" || [204, 205, 304].includes(status)) {
-    length = "";
-  } else if (!contentLength) {
-    length = import_kleur.default.dim("-");
-  } else {
-    length = formatMeasurement(bytes(contentLength));
-  }
-  let arrow = id ? "\u2501" : "\u2501\u2501";
-  if (success) {
-    arrow = import_kleur.default.dim(arrow + "\u25B6");
-  } else {
-    arrow = import_kleur.default.red(import_kleur.default.dim(arrow) + import_kleur.default.bold("x"));
-  }
-  console.log(
-    arrow + id + " " + import_kleur.default.bold(req.method) + " " + import_kleur.default.dim(req.url) + " " + import_kleur.default[color](status) + " " + formatMeasurement(time(startTime)) + " " + length
-  );
-}
-function requestArrow(id, step = 3) {
-  const arrow = ArrowSteps[step];
-  return id ? arrow.slice(0, -1) : arrow;
-}
-function time(start) {
-  const delta = Date.now() - start;
-  return delta < 5e3 ? [delta, "ms"] : [(delta / 1e3).toFixed(1), "s"];
-}
-function bytes(size) {
-  const { value, prefix } = import_human_format.default.raw(size, { maxDecimals: 2, unit: "b" });
-  return [value.toFixed(2), (prefix + "b").toLowerCase()];
-}
-function formatMeasurement([value, unit]) {
-  return import_kleur.default.dim(value + import_kleur.default.yellow(import_kleur.default.bold(unit)));
-}
-function createAnimationManager(options = {}) {
-  const { steps = 1e4, ms = 100 } = options;
-  const fns = /* @__PURE__ */ new Set();
-  let step = 0;
-  let isRunning = false;
-  let interval;
-  function start() {
-    step = 0;
-    isRunning = true;
-    interval = setInterval(() => {
-      if (isRunning) {
-        for (const fn of fns) {
-          fn(step);
-        }
-        step = (step + 1) % steps;
+        break;
+    }
+    const request = new Request(url, {
+      method: req.method,
+      headers: req.headers,
+      body,
+      // @ts-expect-error: Node requires this for streams
+      duplex: "half",
+      signal
+    });
+    const platform = createPlatform({
+      request: req,
+      response: res
+    });
+    let response;
+    try {
+      response = await fetch2(request, platform);
+    } catch (err) {
+      normalizeError(err);
+      if (next) {
+        next(err);
+      } else {
+        console.error(err);
       }
-    }, ms);
-  }
-  function stop() {
-    isRunning = false;
-    clearInterval(interval);
-  }
-  return {
-    add(fn) {
-      fns.add(fn);
-      if (!isRunning) {
-        start();
+      return;
+    }
+    if (!response) {
+      if (next) {
+        next();
       }
-      fn(step);
-      return () => {
-        fns.delete(fn);
-        if (!fns.size) {
-          stop();
-        }
-      };
+      return;
+    }
+    res.statusCode = response.status;
+    copyResponseHeaders(res, response.headers);
+    if (!response.body) {
+      if (!response.headers.has("content-length")) {
+        res.setHeader("content-length", "0");
+      }
+      res.end();
+      return;
+    } else if (res.destroyed) {
+      controller.abort(new Error("Response stream destroyed"));
+      return;
     }
+    writeResponse(response.body.getReader(), res, controller);
   };
 }
+async function writeResponse(reader, res, controller) {
+  try {
+    while (!controller.signal.aborted) {
+      const { done, value } = await reader.read();
+      if (done) {
+        res.end();
+        return;
+      }
+      res.write(value);
+      if (res.flush) {
+        res.flush();
+      }
+    }
+  } catch (err) {
+    controller.abort(err);
+  }
+}
+var bodyConsumedErrorStream = new ReadableStream({
+  pull(controller) {
+    controller.error(
+      new Error(
+        "The request body stream has been destroyed or consumed by something before Marko Run."
+      )
+    );
+  }
+});
 
 // src/adapter/utils.ts
-var import_supports_color = __toESM(require("supports-color"), 1);
 var import_kleur2 = __toESM(require("kleur"), 1);
+var import_supports_color = __toESM(require("supports-color"), 1);
 function stripAnsi(string) {
   return string.replace(
     /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
@@ -528,7 +694,7 @@ function logInfoBox(address, explorer) {
   const color = !!import_supports_color.default.stdout;
   let message = import_kleur2.default.bold("Marko Run");
   if (true) {
-    message += ` v${"0.5.12"}`;
+    message += ` v${"0.5.14"}`;
   }
   message += "\n\n";
   message += import_kleur2.default.dim("Server listening at");
@@ -575,7 +741,7 @@ function drawMarkoBox(message, options) {
     }
     line += textPadding;
     if (i >= textStartLine && i < textEndLine) {
-      let index = i - textStartLine;
+      const index = i - textStartLine;
       line += textLines[index];
       line += " ".repeat(textWidth - textWidths[index]);
     } else {
@@ -610,13 +776,16 @@ B\u2572   \u2572 GG\u203E\u203E\u203E\u203E O\u2571   \u2571 P\u2571   \u2571
     O: "#ff9500",
     R: "#f3154d",
     P: "#ce176c"
-  }).reduce((acc, [key, hex]) => {
-    const r = parseInt(hex.slice(1, 3), 16);
-    const g = parseInt(hex.slice(3, 5), 16);
-    const b = parseInt(hex.slice(5, 7), 16);
-    acc[key] = `\x1B[38;2;${r};${g};${b}m`;
-    return acc;
-  }, {});
+  }).reduce(
+    (acc, [key, hex]) => {
+      const r = parseInt(hex.slice(1, 3), 16);
+      const g = parseInt(hex.slice(3, 5), 16);
+      const b = parseInt(hex.slice(5, 7), 16);
+      acc[key] = `\x1B[38;2;${r};${g};${b}m`;
+      return acc;
+    },
+    {}
+  );
   const lines = [];
   const lineWidths = [];
   let line = "";
@@ -761,7 +930,11 @@ function getDevGlobal() {
 function createErrorMiddleware(devServer) {
   return function errorMiddleware(error, _req, res, _next) {
     if (!error.id) {
-      devServer.config.logger.error((0, import_vite.buildErrorMessage)(error, [`\x1B[31;1mRequest failed with error: ${error.message}\x1B[0m`]));
+      devServer.config.logger.error(
+        (0, import_vite.buildErrorMessage)(error, [
+          `\x1B[31;1mRequest failed with error: ${error.message}\x1B[0m`
+        ])
+      );
     }
     res.statusCode = 500;
     res.end(`
@@ -798,171 +971,7 @@ function createErrorMiddleware(devServer) {
   };
 }
 
-// src/vite/utils/server.ts
-var import_net = __toESM(require("net"), 1);
-var import_child_process = __toESM(require("child_process"), 1);
-var import_dotenv = require("dotenv");
-var import_fs = __toESM(require("fs"), 1);
-var import_cluster = __toESM(require("cluster"), 1);
-async function parseEnv(envFile) {
-  if (import_fs.default.existsSync(envFile)) {
-    const content = await import_fs.default.promises.readFile(envFile, "utf8");
-    return (0, import_dotenv.parse)(content);
-  }
-}
-function loadEnv(envFile) {
-  (0, import_dotenv.config)({ path: envFile });
-}
-async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), wait = 3e4, stdio = ["ignore", "inherit", "inherit"]) {
-  if (port <= 0) {
-    port = await getAvailablePort();
-  }
-  if (typeof env === "string") {
-    env = await parseEnv(env);
-  }
-  const proc = import_child_process.default.spawn(cmd, args, {
-    cwd,
-    shell: true,
-    stdio,
-    windowsHide: true,
-    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
-  });
-  const close = () => {
-    proc.unref();
-    proc.kill();
-  };
-  try {
-    await Promise.race([waitForError(proc, port), waitForServer(port, wait)]);
-  } catch (err) {
-    close();
-    throw err;
-  }
-  return {
-    port,
-    close
-  };
-}
-async function spawnServerWorker(module2, args = [], port = 0, env, wait = true) {
-  if (port <= 0) {
-    port = await getAvailablePort();
-  }
-  if (typeof env === "string") {
-    env = await parseEnv(env);
-  }
-  const originalExec = import_cluster.default.settings.exec;
-  const originalArgs = import_cluster.default.settings.execArgv;
-  try {
-    import_cluster.default.settings.exec = module2;
-    import_cluster.default.settings.execArgv = args;
-    const worker = import_cluster.default.fork({
-      ...env,
-      NODE_ENV: "development",
-      ...process.env,
-      PORT: `${port}`
-    });
-    if (wait) {
-      return new Promise((resolve) => {
-        function ready(message) {
-          if (message === "ready") {
-            worker.off("message", ready);
-            resolve(worker);
-          }
-        }
-        worker.on("message", ready);
-      });
-    }
-    return worker;
-  } finally {
-    import_cluster.default.settings.exec = originalExec;
-    import_cluster.default.settings.execArgv = originalArgs;
-  }
-}
-async function waitForError(proc, port) {
-  return new Promise((_, reject) => {
-    proc.once("error", reject);
-    proc.once("exit", (code) => {
-      reject(
-        new Error(
-          `Process exited with code ${code} while waiting for server to start on port "${port}".`
-        )
-      );
-    });
-  });
-}
-async function waitForServer(port, wait = 0) {
-  let remaining = wait > 0 ? wait : Infinity;
-  let connection;
-  while (!(connection = await getConnection(port))) {
-    if (remaining >= 100) {
-      remaining -= 100;
-      await sleep(100);
-    } else {
-      throw new Error(
-        `Timeout while wating for server to start on port "${port}".`
-      );
-    }
-  }
-  return connection;
-}
-async function waitForWorker(worker, port) {
-  return new Promise((resolve, reject) => {
-    function listening(address) {
-      if (address.port === port) {
-        worker.off("listening", listening);
-        resolve();
-      }
-    }
-    worker.on("listening", listening).once("error", reject).once("exit", (code) => {
-      reject(
-        new Error(
-          `Worker exited with code ${code} while waiting for dev server to start on port "${port}".`
-        )
-      );
-    });
-  });
-}
-async function getConnection(port) {
-  return new Promise((resolve) => {
-    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
-      connection.end();
-      resolve(null);
-    }).on("connect", () => {
-      resolve(connection);
-    });
-  });
-}
-async function isPortInUse(port) {
-  return Boolean(await getConnection(port));
-}
-async function getAvailablePort(port) {
-  if (port && !await isPortInUse(port)) {
-    return port;
-  }
-  return new Promise((resolve) => {
-    const server = import_net.default.createServer().listen(0, () => {
-      const { port: port2 } = server.address();
-      server.close(() => resolve(port2));
-    });
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getInspectOptions(args) {
-  for (const arg of args) {
-    const match = arg.match(/^--inspect(-brk)?(?:=(?:(.+):)?(.+))?$/);
-    if (match) {
-      return {
-        host: match[2],
-        port: parseInt(match[3], 10) || void 0,
-        wait: !!match[1]
-      };
-    }
-  }
-}
-
 // src/adapter/index.ts
-var import_run_explorer = require("@marko/run-explorer");
 var import_parse_node_args = __toESM(require("parse-node-args"), 1);
 
 // src/vite/constants.ts
@@ -1001,13 +1010,12 @@ function adapter() {
           await waitForWorker(nextWorker, port);
           if (worker) {
             const prevWorker = worker;
-            let timeout;
             worker.once("disconnect", () => {
               clearTimeout(timeout);
             });
             worker.send({ type: "shutdown" });
             worker.disconnect();
-            timeout = setTimeout(() => {
+            const timeout = setTimeout(() => {
               prevWorker.kill();
             }, 2e3);
           }
@@ -1017,7 +1025,7 @@ function adapter() {
         return {
           port,
           async close() {
-            await Promise.all([worker.kill(), explorer2 == null ? void 0 : explorer2.close()]);
+            await Promise.allSettled([worker.kill(), explorer2 == null ? void 0 : explorer2.close()]);
           }
         };
       }
@@ -1027,12 +1035,16 @@ function adapter() {
       if (inspect) {
         import_inspector2.default.open(inspect.port, inspect.host, inspect.wait);
       }
-      const listen = new Promise((resolve) => {
-        const listener = devServer.middlewares.listen(port, () => {
-          resolve(listener.address());
+      const listenerPromise = new Promise((resolve) => {
+        const listener2 = devServer.middlewares.listen(port, () => {
+          resolve(listener2);
         });
       });
-      const [explorer, address] = await Promise.all([explorerPromise, listen]);
+      const [explorer, listener] = await Promise.all([
+        explorerPromise,
+        listenerPromise
+      ]);
+      const address = listener.address();
       logInfoBox(
         `http://localhost:${address.port}`,
         explorer && `http://localhost:${explorer.port}`
@@ -1040,7 +1052,11 @@ function adapter() {
       return {
         port: address.port,
         async close() {
-          await Promise.all([devServer.close(), explorer == null ? void 0 : explorer.close()]);
+          await Promise.allSettled([
+            devServer.close(),
+            listener.close(),
+            explorer == null ? void 0 : explorer.close()
+          ]);
         }
       };
     },
@@ -1061,7 +1077,7 @@ function adapter() {
       return explorer ? {
         port: server.port,
         async close() {
-          await Promise.all([server.close(), explorer.close()]);
+          await Promise.allSettled([server.close(), explorer.close()]);
         }
       } : server;
     },
@@ -1083,7 +1099,7 @@ function adapter() {
       };
       for (const [name, code] of virtualFiles) {
         let fileName = "";
-        let index = name.indexOf(markoRunFilePrefix);
+        const index = name.indexOf(markoRunFilePrefix);
         if (index >= 0) {
           fileName = name.slice(index);
           data.files[fileName] = `${virtualFilePrefix}/${fileName}`;