qunitx-cli 0.19.1 → 0.19.3

package/dist/cli.js

@@ -55,68 +55,67 @@ var init_kill_process_group = __esm({
 
 // lib/utils/cleanup-browser-dir.ts
 import fs from "node:fs/promises";
-async function cleanupBrowserDir(dirPath) {
-  if (process.platform !== "linux") {
-    await fs.rm(dirPath, { recursive: true, force: true }).catch(() => {
-    });
-    return;
+async function processReferencesDir(entry, dirPath, dirName) {
+  try {
+    const [cwd, cmdline] = await Promise.all([
+      fs.readlink(`/proc/${entry}/cwd`).catch(() => ""),
+      fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "")
+    ]);
+    if (cwd.startsWith(dirPath) || cmdline.includes(dirName)) return true;
+    const fds = await fs.readdir(`/proc/${entry}/fd`).catch(() => []);
+    const fdTargets = await Promise.all(
+      fds.map((fd) => fs.readlink(`/proc/${entry}/fd/${fd}`).catch(() => ""))
+    );
+    return fdTargets.some((target) => target.startsWith(dirPath));
+  } catch {
+    return false;
   }
-  const dirName = dirPath.split("/").pop();
-  const killedPids = /* @__PURE__ */ new Set();
+}
+async function killAllReferencingProcesses(dirPath, dirName) {
   const procEntries = await fs.readdir("/proc").catch(() => []);
   await Promise.all(
     procEntries.map(async (entry) => {
       if (!/^\d+$/.test(entry)) return;
-      const pid = parseInt(entry);
+      if (!await processReferencesDir(entry, dirPath, dirName)) return;
       try {
-        const [cwd, cmdline] = await Promise.all([
-          fs.readlink(`/proc/${entry}/cwd`).catch(() => ""),
-          fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "")
-        ]);
-        if (!cwd.startsWith(dirPath) && !cmdline.includes(dirName)) return;
-        try {
-          process.kill(pid, "SIGKILL");
-          killedPids.add(pid);
-        } catch {
-        }
+        process.kill(parseInt(entry), "SIGKILL");
       } catch {
       }
     })
   );
-  while (killedPids.size > 0) {
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    for (const pid of killedPids) {
-      try {
-        process.kill(pid, 0);
-      } catch {
-        killedPids.delete(pid);
-      }
-    }
+}
+async function cleanupBrowserDir(dirPath) {
+  if (process.platform !== "linux") {
+    await fs.rm(dirPath, { recursive: true, force: true }).catch(() => {
+    });
+    return;
   }
+  const dirName = dirPath.split("/").pop();
+  await killAllReferencingProcesses(dirPath, dirName);
   const deadline = Date.now() + 5e3;
   while (Date.now() < deadline) {
     const removed = await fs.rm(dirPath, { recursive: true, force: true }).then(() => true).catch(() => false);
-    if (removed) break;
-    await new Promise((resolve) => setTimeout(resolve, 20));
+    if (removed) return;
+    await killAllReferencingProcesses(dirPath, dirName);
+    await new Promise((resolve) => setTimeout(resolve, 50));
   }
-  if (await fs.access(dirPath).then(() => true).catch(() => false)) {
-    const diagEntries = await fs.readdir("/proc").catch(() => []);
-    await Promise.all(
-      diagEntries.map(async (entry) => {
-        if (!/^\d+$/.test(entry)) return;
-        try {
-          const cwd = await fs.readlink(`/proc/${entry}/cwd`).catch(() => "");
-          if (!cwd.startsWith(dirPath)) return;
-          const cmdline = await fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "");
-          process.stderr.write(
-            `# [qunitx] cleanup failed: pid ${entry} still holds ${dirPath} as cwd (cmdline: ${cmdline.replace(/\0/g, " ").slice(0, 120)})
+  if (!await fs.access(dirPath).then(() => true).catch(() => false))
+    return;
+  const diagEntries = await fs.readdir("/proc").catch(() => []);
+  await Promise.all(
+    diagEntries.map(async (entry) => {
+      if (!/^\d+$/.test(entry)) return;
+      try {
+        if (!await processReferencesDir(entry, dirPath, dirName)) return;
+        const cmdline = await fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "");
+        process.stderr.write(
+          `# [qunitx] cleanup failed: pid ${entry} still references ${dirPath} (cmdline: ${cmdline.replace(/\0/g, " ").slice(0, 120)})
 `
-          );
-        } catch {
-        }
-      })
-    );
-  }
+        );
+      } catch {
+      }
+    })
+  );
 }
 var init_cleanup_browser_dir = __esm({
   "lib/utils/cleanup-browser-dir.ts"() {
@@ -168,36 +167,11 @@ async function preLaunchChrome(chromePath, args, headless = true) {
   });
   async function shutdown() {
     proc.ref();
-    const closed = new Promise((resolve) => {
-      if (proc.exitCode !== null) {
-        resolve();
-        return;
-      }
-      proc.once("close", resolve);
-    });
-    if (proc.exitCode === null) killProcessGroup(proc.pid);
-    await closed;
-    await rm(userDataDir, { recursive: true, force: true }).catch(async () => {
-      const pgid = proc.pid;
-      const warnTimer = setTimeout(
-        () => process.stderr.write(
-          `# [qunitx] warning: Chrome process group ${pgid} still alive 500ms after SIGKILL, waiting...
-`
-        ),
-        500
-      );
-      warnTimer.unref();
-      while (true) {
-        try {
-          process.kill(-pgid, 0);
-        } catch {
-          break;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 20));
-      }
-      clearTimeout(warnTimer);
-      await cleanupBrowserDir(userDataDir);
-    });
+    if (proc.exitCode === null) {
+      killProcessGroup(proc.pid);
+      await new Promise((resolve) => proc.once("close", resolve));
+    }
+    await cleanupBrowserDir(userDataDir);
   }
 }
 var CDP_URL_REGEX;
@@ -385,21 +359,6 @@ var init_color = __esm({
   }
 });
 
-// lib/utils/path-exists.ts
-import fs2 from "node:fs/promises";
-async function pathExists(path7) {
-  try {
-    await fs2.access(path7);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var init_path_exists = __esm({
-  "lib/utils/path-exists.ts"() {
-  }
-});
-
 // lib/utils/read-template.ts
 import fs3 from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
@@ -795,11 +754,13 @@ var init_http = __esm({
         if (!this.routes[method]) {
           this.routes[method] = {};
         }
+        const paramNames = this.#extractParamNames(path7);
         this.routes[method][path7] = {
           path: path7,
           handler,
-          paramNames: this.#extractParamNames(path7),
-          isWildcard: path7 === "/*"
+          paramNames,
+          isWildcard: path7 === "/*",
+          compiledRegex: paramNames.length > 0 ? new RegExp(`^${this.#buildRegexPattern(path7, paramNames)}$`) : null
         };
       }
       #handleRequest(req, res) {
@@ -842,10 +803,8 @@ var init_http = __esm({
             return false;
           }
           if (isWildcard || this.#matchPathSegments(path7, url)) {
-            if (route.paramNames.length > 0) {
-              const regexPattern = this.#buildRegexPattern(path7, route.paramNames);
-              const regex = new RegExp(`^${regexPattern}$`);
-              const regexMatches = regex.exec(url);
+            if (route.compiledRegex) {
+              const regexMatches = route.compiledRegex.exec(url);
               if (regexMatches) {
                 route.paramValues = regexMatches.slice(1);
               }
@@ -906,6 +865,21 @@ function setupWebServer(config, cachedContent) {
     cachedContent.mainHTML.filePath,
     config.projectRoot
   );
+  const runtimeScript = testRuntimeToInject(config);
+  const mainIndexHTML = escapeAndInjectTestsToHTML(
+    mainHTMLWithReplacedAssets,
+    runtimeScript,
+    "./tests.js"
+  );
+  const mainQunitxHTML = escapeAndInjectTestsToHTML(
+    mainHTMLWithReplacedAssets,
+    runtimeScript,
+    "./filtered-tests.js"
+  );
+  const saveHTML = (filePath, html) => fsPromise.writeFile(filePath, html).catch(
+    (err) => config.debug && process.stderr.write(`# [qunitx] writeFile ${filePath}: ${err.message}
+`)
+  );
   server.wss.on("connection", function connection(socket) {
     socket.on("message", function message(data) {
       const { event, details, qunitResult, abort } = JSON.parse(data);
@@ -915,17 +889,7 @@ function setupWebServer(config, cachedContent) {
       } else if (event === "connection") {
         config._phase = "running";
         if (!config._groupMode) process.stdout.write("TAP version 13\n");
-        if (config.debug && config._groupMode) {
-          const allFiles = Object.keys(config.fsTree);
-          const relFiles = allFiles.map(
-            (filePath) => filePath.replace(`${config.projectRoot}/`, "")
-          );
-          const shown = relFiles.slice(0, 2);
-          const rest = relFiles.length - shown.length;
-          const fileList = rest > 0 ? `${shown.join("  ")}  +${rest} more` : shown.join("  ");
-          process.stdout.write(`# ${blue(`\u2500\u2500 ${fileList} \u2500\u2500`)}
-`);
-        }
+        if (config.debug && config._groupMode) debugGroupHeader(config);
         config._resetTestTimeout?.();
       } else if (event === "testEnd" && !abort) {
         if (details.status === "failed") {
@@ -957,7 +921,7 @@ function setupWebServer(config, cachedContent) {
   });
   server.get("/tests.js", (_req, res) => {
     const bytes = cachedContent.allTestCode?.length ?? null;
-    process.stdout.write(
+    config.debug && process.stdout.write(
       `# [HTTPServer] GET /tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (allTestCode is null)"}
 `
     );
@@ -978,7 +942,7 @@ function setupWebServer(config, cachedContent) {
   });
   server.get("/filtered-tests.js", (_req, res) => {
     const bytes = cachedContent.filteredTestCode?.length ?? null;
-    process.stdout.write(
+    config.debug && process.stdout.write(
       `# [HTTPServer] GET /filtered-tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (filteredTestCode is null)"}
 `
     );
@@ -997,100 +961,74 @@ function setupWebServer(config, cachedContent) {
     });
     res.end(cachedContent.filteredTestCode);
   });
-  server.get("/", async (_req, res) => {
+  server.get("/", (_req, res) => {
     if (cachedContent._buildError) {
-      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
-      return await fsPromise.writeFile(
-        `${config.projectRoot}/${config.output}/index.html`,
-        htmlContent2
-      );
+      const htmlContent = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, HTML_HEADERS);
+      res.end(htmlContent);
+      saveHTML(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
+      return;
     }
     if (cachedContent._noTestsWarning) {
-      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
+      res.writeHead(200, HTML_HEADERS);
+      res.end(buildNoTestsHTML(cachedContent._noTestsWarning));
       return;
     }
-    const htmlContent = escapeAndInjectTestsToHTML(
-      mainHTMLWithReplacedAssets,
-      testRuntimeToInject(config.port, config),
-      "./tests.js"
-    );
-    res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-    res.write(htmlContent);
-    res.end();
-    return await fsPromise.writeFile(
-      `${config.projectRoot}/${config.output}/index.html`,
-      htmlContent
-    );
+    res.writeHead(200, HTML_HEADERS);
+    res.end(mainIndexHTML);
+    saveHTML(`${config.projectRoot}/${config.output}/index.html`, mainIndexHTML);
   });
-  server.get("/qunitx.html", async (_req, res) => {
+  server.get("/qunitx.html", (_req, res) => {
     if (cachedContent._buildError) {
-      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
-      return await fsPromise.writeFile(
-        `${config.projectRoot}/${config.output}/qunitx.html`,
-        htmlContent2
-      );
+      const htmlContent = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, HTML_HEADERS);
+      res.end(htmlContent);
+      saveHTML(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
+      return;
     }
     if (cachedContent._noTestsWarning) {
-      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
+      res.writeHead(200, HTML_HEADERS);
+      res.end(buildNoTestsHTML(cachedContent._noTestsWarning));
       return;
     }
-    const htmlContent = escapeAndInjectTestsToHTML(
-      mainHTMLWithReplacedAssets,
-      testRuntimeToInject(config.port, config),
-      "./filtered-tests.js"
-    );
-    res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-    res.write(htmlContent);
-    res.end();
-    return await fsPromise.writeFile(
-      `${config.projectRoot}/${config.output}/qunitx.html`,
-      htmlContent
-    );
+    res.writeHead(200, HTML_HEADERS);
+    res.end(mainQunitxHTML);
+    saveHTML(`${config.projectRoot}/${config.output}/qunitx.html`, mainQunitxHTML);
   });
-  server.get("/*", async (req, res) => {
+  server.get("/*", (req, res) => {
     const possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
     if (possibleDynamicHTML) {
       const htmlContent = escapeAndInjectTestsToHTML(
         possibleDynamicHTML,
-        testRuntimeToInject(config.port, config),
+        runtimeScript,
         "/tests.js"
       );
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent);
-      res.end();
-      return await fsPromise.writeFile(
-        `${config.projectRoot}/${config.output}${req.path}`,
-        htmlContent
-      );
+      res.writeHead(200, HTML_HEADERS);
+      res.end(htmlContent);
+      saveHTML(`${config.projectRoot}/${config.output}${req.path}`, htmlContent);
+      return;
     }
     const url = req.url;
-    const requestStartedAt = /* @__PURE__ */ new Date();
+    const requestStartedAt = Date.now();
     const filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join("");
-    const statusCode = await pathExists(filePath) ? 200 : 404;
-    res.writeHead(statusCode, {
-      "Content-Type": req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path4.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path4.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs8.createReadStream(filePath);
+    stream.on("open", () => {
+      res.writeHead(200, { "Content-Type": contentType });
+      stream.pipe(res);
+      config.debug && process.stdout.write(
+        `# [HTTPServer] GET ${url} 200 - ${Date.now() - requestStartedAt}ms
+`
+      );
     });
-    if (statusCode === 404) {
-      res.end();
-    } else {
-      fs8.createReadStream(filePath).pipe(res);
-    }
-    process.stdout.write(
-      `# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms
+    stream.on("error", () => {
+      res.writeHead(404, { "Content-Type": contentType });
+      res.end(contentType === MIME_TYPES.html ? NOT_FOUND_HTML : void 0);
+      config.debug && process.stdout.write(
+        `# [HTTPServer] GET ${url} 404 - ${Date.now() - requestStartedAt}ms
 `
-    );
+      );
+    });
   });
   return server;
 }
@@ -1102,7 +1040,8 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
     return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
-function testRuntimeToInject(port, config) {
+function testRuntimeToInject(config, groupId) {
+  const groupIdPart = groupId !== void 0 ? `, groupId: ${groupId}` : "";
   return `<script>
     window.testTimeout = 0;
     setInterval(() => {
@@ -1138,7 +1077,7 @@ function testRuntimeToInject(port, config) {
 
       function setupWebSocket() {
         try {
-          window.socket = new WebSocket('ws://localhost:${port}');
+          window.socket = new WebSocket(\`ws://localhost:\${location.port}\`);
         } catch (error) {
           console.log(error);
           retryOrFail();
@@ -1150,8 +1089,8 @@ function testRuntimeToInject(port, config) {
           // Notify Node.js that the WS socket is open. This fires immediately (< 1 s) because
           // this runtime script is tiny \u2014 tests.js background compilation hasn't finished yet.
           // Node.js uses this to distinguish "WS never connected" from "WS connected but bundle slow".
-          if (window.IS_PLAYWRIGHT) {
-            window.socket.send(JSON.stringify({ event: 'wsOpen' }));
+          if (navigator.webdriver) {
+            window.socket.send(JSON.stringify({ event: 'wsOpen'${groupIdPart} }));
           }
           maybeStart();
         });
@@ -1159,9 +1098,9 @@ function testRuntimeToInject(port, config) {
           retryOrFail();
         });
         window.socket.addEventListener('message', function(messageEvent) {
-          if (!window.IS_PLAYWRIGHT && messageEvent.data === 'refresh') {
+          if (!navigator.webdriver && messageEvent.data === 'refresh') {
             window.location.reload(true);
-          } else if (window.IS_PLAYWRIGHT && messageEvent.data === 'abort') {
+          } else if (navigator.webdriver && messageEvent.data === 'abort') {
             window.abortQUnit = true;
             window.QUnit.config.queue.length = 0;
             window.socket.send(JSON.stringify({ event: 'abort' }));
@@ -1204,7 +1143,7 @@ function testRuntimeToInject(port, config) {
 
       if (!window.QUnit) {
         console.log('QUnit not found after WebSocket connected');
-        if (window.IS_PLAYWRIGHT) {
+        if (navigator.webdriver) {
           // Signal the Playwright runner that the run is complete with 0 tests rather than
           // waiting for the inactivity timeout. The runner treats totalTests === 0 as a
           // "no tests registered" warning (not a failure), so this gives a fast, clean result.
@@ -1217,7 +1156,7 @@ function testRuntimeToInject(port, config) {
       }
 
       window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PLAYWRIGHT) {
+        if (navigator.webdriver) {
           window.socket.send(JSON.stringify({ event: 'connection' }));
         }
       });
@@ -1230,8 +1169,10 @@ function testRuntimeToInject(port, config) {
         window.QUNIT_RESULT.finishedTests++;
         if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
         window.QUNIT_RESULT.currentTest = null;
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'testEnd', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+        if (navigator.webdriver) {
+          const isFailed = details.status === 'failed';
+          const payload = isFailed ? details : { status: details.status, fullName: details.fullName, runtime: details.runtime };
+          window.socket.send(JSON.stringify({ event: 'testEnd', details: payload, abort: window.abortQUnit }, isFailed ? getCircularReplacer() : undefined));
 
           if (${config.failFast} && details.status === 'failed') {
             window.QUnit.config.queue.length = 0;
@@ -1239,7 +1180,7 @@ function testRuntimeToInject(port, config) {
         }
       });
       window.QUnit.done((details) => {
-        if (window.IS_PLAYWRIGHT) {
+        if (navigator.webdriver) {
           window.socket.send(JSON.stringify({ event: 'done', details: details, qunitResult: window.QUNIT_RESULT, abort: window.abortQUnit }, getCircularReplacer()));
           // Do NOT set testTimeout here. The WS 'done' event (testsDone promise) is the
           // canonical completion signal for Playwright runs. waitForFunction is reserved
@@ -1330,7 +1271,7 @@ function buildNoTestsHTML(files) {
 </head>
 <body>
   <div id="qunit">
-    <h1 id="qunit-header">qunitx</h1>
+    <h1 id="qunit-header"><a href="/" style="color:inherit;text-decoration:none">qunitx</a></h1>
     <h2 id="qunit-banner"></h2>
     <div id="qunit-userAgent">Warning: No Tests Registered</div>
     <ol id="qunit-tests">
@@ -1350,7 +1291,7 @@ function buildNoTestsHTML(files) {
       (function () {
         var retries = 0;
         function connect() {
-          var ws = new WebSocket('ws://' + location.hostname + ':' + location.port);
+          var ws = new WebSocket(\`ws://\${location.hostname}:\${location.port}\`);
           ws.addEventListener('message', function (e) { if (e.data === 'refresh') location.reload(true); });
           ws.addEventListener('close', function () { if (retries++ < 120) setTimeout(connect, 1000); });
           ws.addEventListener('error', function () { ws.close(); });
@@ -1432,7 +1373,7 @@ function buildErrorHTML(buildError) {
 </head>
 <body>
   <div id="qunit">
-    <h1 id="qunit-header">qunitx</h1>
+    <h1 id="qunit-header"><a href="/" style="color:inherit;text-decoration:none">qunitx</a></h1>
     <h2 id="qunit-banner"></h2>
     <div id="qunit-userAgent">Build Error: ${buildError.type}</div>
     <ol id="qunit-tests">
@@ -1452,7 +1393,7 @@ function buildErrorHTML(buildError) {
       (function () {
         var retries = 0;
         function connect() {
-          var ws = new WebSocket('ws://' + location.hostname + ':' + location.port);
+          var ws = new WebSocket(\`ws://\${location.hostname}:\${location.port}\`);
           ws.addEventListener('message', function (e) { if (e.data === 'refresh') location.reload(true); });
           ws.addEventListener('close', function () { if (retries++ < 120) setTimeout(connect, 1000); });
           ws.addEventListener('error', function () { ws.close(); });
@@ -1464,16 +1405,182 @@ function buildErrorHTML(buildError) {
 </body>
 </html>`;
 }
-var fsPromise;
+function registerGroupRoutes(server, groupConfig, groupCachedContent, groupId) {
+  const mainHTMLWithReplacedAssets = replaceAssetPaths(
+    groupCachedContent.mainHTML.html,
+    groupCachedContent.mainHTML.filePath,
+    groupConfig.projectRoot
+  );
+  const runtimeScript = testRuntimeToInject(groupConfig, groupId);
+  const mainGroupHTML = escapeAndInjectTestsToHTML(
+    mainHTMLWithReplacedAssets,
+    runtimeScript,
+    "./tests.js"
+  );
+  const saveHTML = (filePath, html) => fsPromise.writeFile(filePath, html).catch(
+    (err) => groupConfig.debug && process.stderr.write(`# [qunitx] writeFile ${filePath}: ${err.message}
+`)
+  );
+  server.get(`/group-${groupId}/`, (_req, res) => {
+    if (groupCachedContent._buildError) {
+      res.writeHead(200, HTML_HEADERS);
+      res.end(buildErrorHTML(groupCachedContent._buildError));
+      return;
+    }
+    if (groupCachedContent._noTestsWarning) {
+      res.writeHead(200, HTML_HEADERS);
+      res.end(buildNoTestsHTML(groupCachedContent._noTestsWarning));
+      return;
+    }
+    res.writeHead(200, HTML_HEADERS);
+    res.end(mainGroupHTML);
+    saveHTML(`${groupConfig.projectRoot}/${groupConfig.output}/index.html`, mainGroupHTML);
+  });
+  server.get(`/group-${groupId}/tests.js`, (_req, res) => {
+    const bytes = groupCachedContent.allTestCode?.length ?? null;
+    if (bytes === null) {
+      res.writeHead(503, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
+      res.end(
+        'console.error("[qunitx] /tests.js requested before bundle was built \u2014 allTestCode is null");'
+      );
+      return;
+    }
+    groupConfig._onTestsJsServed?.();
+    res.writeHead(200, {
+      "Content-Type": "application/javascript",
+      "Cache-Control": "no-store",
+      "Content-Length": bytes
+    });
+    res.end(groupCachedContent.allTestCode);
+  });
+}
+function debugGroupHeader(config) {
+  const files = Object.keys(config.fsTree);
+  const rel = files.map((f) => f.replace(`${config.projectRoot}/`, ""));
+  const shown = rel.slice(0, 2);
+  const rest = rel.length - shown.length;
+  process.stdout.write(
+    `# ${blue(`\u2500\u2500 ${shown.join("  ")}${rest > 0 ? `  +${rest} more` : ""} \u2500\u2500`)}
+`
+  );
+}
+function setupGroupWSHandler(server, groupConfigs) {
+  const socketToGroupId = /* @__PURE__ */ new WeakMap();
+  server.wss.on("connection", function connection(socket) {
+    socket.on("message", function message(data) {
+      const { event, groupId, details, qunitResult, abort } = JSON.parse(data);
+      let resolvedGroupId = socketToGroupId.get(socket);
+      if (event === "wsOpen" && typeof groupId === "number") {
+        resolvedGroupId = groupId;
+        socketToGroupId.set(socket, groupId);
+      }
+      if (resolvedGroupId === void 0) return;
+      const config = groupConfigs[resolvedGroupId];
+      if (!config) return;
+      if (event === "wsOpen") {
+        config._phase = "loading";
+        config._onWsOpen?.();
+      } else if (event === "connection") {
+        config._phase = "running";
+        if (config.debug) debugGroupHeader(config);
+        config._resetTestTimeout?.();
+      } else if (event === "testEnd" && !abort) {
+        if (details.status === "failed") {
+          config.lastFailedTestFiles = config.lastRanTestFiles;
+        }
+        if (config.debug && details.runtime > config.timeout * 0.8) {
+          process.stdout.write(
+            `# SLOW (${details.runtime.toFixed(0)}ms / ${config.timeout}ms timeout): ${details.fullName.join(" | ")}
+`
+          );
+        }
+        config._resetTestTimeout?.();
+        TAPDisplayTestResult(config.COUNTER, details);
+      } else if (event === "done") {
+        config._phase = "done";
+        config._lastQUnitResult = qunitResult ?? null;
+        if (config.debug) {
+          process.stdout.write(
+            `# group done: ${details.passed} passed, ${details.failed} failed (${details.runtime}ms)
+`
+          );
+        }
+        if (typeof config._testRunDone === "function") {
+          config._testRunDone();
+          config._testRunDone = null;
+        }
+      }
+    });
+  });
+}
+function registerSharedStaticHandler(server, groupConfigs) {
+  const groupUrlRegex = /^\/group-(\d+)(\/.*)?$/;
+  server.get("/*", (req, res) => {
+    const match = groupUrlRegex.exec(req.path);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+    const groupId = parseInt(match[1], 10);
+    const groupConfig = groupConfigs[groupId];
+    if (!groupConfig) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not found");
+      return;
+    }
+    const STATIC_FILES_PATH = path4.join(groupConfig.projectRoot, groupConfig.output);
+    const subPath = match[2] || "/";
+    const filePath = (subPath.endsWith("/") ? [STATIC_FILES_PATH, subPath, "index.html"] : [STATIC_FILES_PATH, subPath]).join("");
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path4.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs8.createReadStream(filePath);
+    stream.on("open", () => {
+      res.writeHead(200, { "Content-Type": contentType });
+      stream.pipe(res);
+    });
+    stream.on("error", () => {
+      res.writeHead(404, { "Content-Type": contentType });
+      res.end(contentType === MIME_TYPES.html ? NOT_FOUND_HTML : void 0);
+    });
+  });
+}
+var fsPromise, HTML_HEADERS, NOT_FOUND_HTML;
 var init_web_server = __esm({
   "lib/setup/web-server.ts"() {
     init_find_internal_assets_from_html();
     init_html();
     init_display_test_result();
     init_color();
-    init_path_exists();
     init_http();
     fsPromise = fs8.promises;
+    HTML_HEADERS = { "Content-Type": "text/html", "Cache-Control": "no-store" };
+    NOT_FOUND_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <title>404 Not Found \u2014 qunitx</title>
+  <style>
+    *{box-sizing:border-box;margin:0;padding:0}
+    body{font-family:"Helvetica Neue Light","HelveticaNeue-Light","Helvetica Neue",Calibri,Helvetica,Arial,sans-serif}
+    #qunit-header{padding:.5em 0 .5em 1em;color:#C2CCD1;background-color:#0D3349;font-size:1.5em;line-height:1em;font-weight:400;border-radius:5px 5px 0 0}
+    #qunit-banner{height:5px;background-color:#EE5757}
+    #qunit-userAgent{padding:.5em 1em;color:#fff;background-color:#2B81AF;text-shadow:rgba(0,0,0,.5) 2px 2px 1px;font-size:small}
+    #qunit-tests{list-style:none;font-size:smaller}
+    #qunit-tests li{display:list-item;padding:.4em 1em;color:#000;background-color:#EE5757;border-radius:0 0 5px 5px}
+  </style>
+</head>
+<body>
+  <div id="qunit">
+    <h1 id="qunit-header"><a href="/" style="color:inherit;text-decoration:none">qunitx</a></h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-userAgent">404 Not Found</div>
+    <ol id="qunit-tests">
+      <li id="qunit-testresult"><script>document.getElementById('qunit-testresult').prepend(location.pathname)</script> was not found on this server.</li>
+    </ol>
+  </div>
+</body>
+</html>`;
   }
 });
 
@@ -1522,22 +1629,43 @@ async function launchBrowser(config) {
     handleSIGHUP: false
   });
 }
-async function setupBrowser(config, cachedContent, existingBrowser = null) {
+async function setupBrowser(config, cachedContent, existingBrowser = null, sharedServer = null) {
   const setupStart = Date.now();
-  const [server, resolvedExistingBrowser] = await Promise.all([
-    setupWebServer(config, cachedContent),
-    Promise.resolve(existingBrowser)
-  ]);
-  perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
-  const browser = resolvedExistingBrowser || await launchBrowser(config);
-  const pageStart = Date.now();
-  const isHeadedWatchMode = config.open === true && config.watch;
-  const getPage = isHeadedWatchMode ? () => browser.contexts()[0]?.pages()[0] ?? browser.newPage() : () => browser.newPage();
-  const [page] = await Promise.all([getPage(), bindServerToPort(server, config)]);
-  perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
-  await page.addInitScript(() => {
-    window.IS_PLAYWRIGHT = true;
-  });
+  const [server, browser, page] = await (async () => {
+    if (sharedServer) {
+      const newPage2 = await existingBrowser.newPage();
+      perfLog(`browser.js: newPage (shared server) took ${Date.now() - setupStart}ms`);
+      return [sharedServer, existingBrowser, newPage2];
+    }
+    const [newServer, resolvedBrowser] = await Promise.all([
+      setupWebServer(config, cachedContent),
+      Promise.resolve(existingBrowser)
+    ]);
+    perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
+    const activeBrowser = resolvedBrowser ?? await launchBrowser(config);
+    const pageStart = Date.now();
+    const isHeadedWatchMode = config.open === true && config.watch;
+    const getPage = isHeadedWatchMode ? () => activeBrowser.contexts()[0]?.pages()[0] ?? activeBrowser.newPage() : () => activeBrowser.newPage();
+    const [newPage] = await Promise.all([getPage(), bindServerToPort(newServer, config)]);
+    perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
+    return [newServer, activeBrowser, newPage];
+  })();
+  if (config.browser === "firefox") {
+    await page.addInitScript(() => {
+      const preSerialize = (arg) => {
+        if (arg === null || typeof arg !== "object") return arg;
+        try {
+          return JSON.stringify(arg, (_key, v) => v instanceof Date ? v.toISOString() : v);
+        } catch {
+          return String(arg);
+        }
+      };
+      ["log", "warn", "error", "info", "debug"].forEach((method) => {
+        const orig = console[method].bind(console);
+        console[method] = (...args) => orig(...args.map(preSerialize));
+      });
+    });
+  }
   config._pendingConsoleHandlers = /* @__PURE__ */ new Set();
   page.on("console", (msg) => {
     const type = msg.type();
@@ -1545,11 +1673,7 @@ async function setupBrowser(config, cachedContent, existingBrowser = null) {
     if (!alwaysShow && !config.debug) return;
     const handler = (async () => {
       try {
-        const values = await Promise.all(
-          msg.args().map(
-            (arg) => arg.jsonValue().catch(() => arg.evaluate((v) => JSON.stringify(v)).then(JSON.parse))
-          )
-        );
+        const values = await Promise.all(msg.args().map((arg) => arg.jsonValue()));
         console.log(...values);
       } catch {
         console.log(msg.text());
@@ -1847,8 +1971,10 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
       fs9.writeFile(
         `${projectRoot}/${output}/qunitx.html`,
         buildErrorHTML(cachedContent._buildError)
-      ).catch(() => {
-      });
+      ).catch(
+        (err) => config.debug && process.stderr.write(`# [qunitx] writeFile qunitx.html: ${err.message}
+`)
+      );
     }
     if (config.watch) {
       console.log(`# ${exception}`);
@@ -1880,9 +2006,6 @@ function buildFilteredTests(filteredTests, outputPath, config) {
   );
 }
 async function runWithOverlayfsRetry(getContents, needsDisk) {
-  const RETRY_DELAY_MS = 100;
-  const MAX_RETRIES = 3;
-  const EMPTY_BUNDLE_THRESHOLD = 500;
   let { result, js } = await getContents();
   const initialSize = js.length;
   for (let retry = 1; retry <= MAX_RETRIES; retry++) {
@@ -2032,7 +2155,110 @@ async function flushConsoleHandlers(handlers, deadline = Date.now() + 2e3) {
   await Promise.allSettled([...handlers]);
   return flushConsoleHandlers(handlers, deadline);
 }
-var BundleError, ancestorNodeModules, ANCESTOR_NODE_MODULES;
+async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
+  groupCachedContents.forEach((cachedContent) => {
+    cachedContent._buildError = null;
+    cachedContent._noTestsWarning = null;
+  });
+  const { projectRoot, debug, watch, browser } = groupConfigs[0];
+  const activeGroups = groupConfigs.reduce(
+    (acc, groupConfig, groupIndex) => {
+      const files = Object.keys(groupConfig.fsTree);
+      if (files.length > 0)
+        acc.push({
+          groupIndex,
+          config: groupConfig,
+          cachedContent: groupCachedContents[groupIndex],
+          files
+        });
+      return acc;
+    },
+    []
+  );
+  if (activeGroups.length === 0)
+    return console.log(
+      "# [buildAllGroupBundles] all groups empty \u2014 skipping build (no test files found)"
+    );
+  await Promise.all(
+    activeGroups.map(
+      (group) => fs9.mkdir(`${group.config.projectRoot}/${group.config.output}`, { recursive: true })
+    )
+  );
+  const sourcemap = debug ? "inline" : watch ? "linked" : false;
+  const groupEntryPlugin = {
+    name: "group-entry-loader",
+    setup(build) {
+      build.onResolve({ filter: /^group-entry-\d+$/ }, (args) => ({
+        path: args.path,
+        namespace: "group-entry"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "group-entry" }, (args) => {
+        const slotIndex = parseInt(args.path.replace("group-entry-", ""));
+        return {
+          contents: activeGroups[slotIndex].files.map((filePath) => `import "${filePath}";`).join(""),
+          resolveDir: process.cwd()
+        };
+      });
+    }
+  };
+  const buildOptions = {
+    entryPoints: activeGroups.map((_, slotIndex) => ({
+      in: `group-entry-${slotIndex}`,
+      out: `group-${slotIndex}`
+    })),
+    plugins: [groupEntryPlugin],
+    nodePaths: ANCESTOR_NODE_MODULES,
+    bundle: true,
+    logLevel: "silent",
+    // outdir only labels the paths in outputFiles[].path — nothing is written to disk
+    // (write:false). Use projectRoot/tmp as a stable sentinel; mkdir is not required.
+    outdir: path5.join(projectRoot, "tmp"),
+    keepNames: true,
+    legalComments: "none",
+    target: esbuildTarget(browser),
+    sourcemap,
+    write: false,
+    footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
+  };
+  const hasSmallOutput = (result) => (result.outputFiles ?? []).some(
+    (outputFile) => GROUP_OUTPUT_REGEX.test(outputFile.path) && !outputFile.path.endsWith(".map") && outputFile.contents.length < EMPTY_BUNDLE_THRESHOLD
+  );
+  const buildWithRetry = async (retriesLeft) => {
+    const result = await esbuild.build(buildOptions);
+    if (!hasSmallOutput(result) || retriesLeft === 0) return result;
+    await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+    return buildWithRetry(retriesLeft - 1);
+  };
+  try {
+    const result = await buildWithRetry(MAX_RETRIES);
+    await Promise.all(
+      (result.outputFiles ?? []).map((outputFile) => {
+        const match = GROUP_OUTPUT_REGEX.exec(outputFile.path);
+        if (!match) return Promise.resolve();
+        const slotIndex = parseInt(match[1]);
+        const isMap = Boolean(match[2]);
+        const { config, cachedContent } = activeGroups[slotIndex];
+        const destPath = `${config.projectRoot}/${config.output}/tests.js${isMap ? ".map" : ""}`;
+        if (!isMap) cachedContent.allTestCode = Buffer.from(outputFile.contents);
+        return fs9.writeFile(destPath, outputFile.contents);
+      })
+    );
+  } catch (error) {
+    const buildError = { type: deriveBuildErrorType(error), formatted: formatBuildErrors(error) };
+    const errorHtml = buildErrorHTML(buildError);
+    await Promise.all(
+      activeGroups.map((group) => {
+        group.cachedContent._buildError = buildError;
+        return fs9.writeFile(`${group.config.projectRoot}/${group.config.output}/index.html`, errorHtml).catch(
+          (err) => debug && process.stderr.write(`# [qunitx] writeFile index.html: ${err.message}
+`)
+        );
+      })
+    );
+    throw error;
+  }
+}
+var BundleError, ancestorNodeModules, ANCESTOR_NODE_MODULES, RETRY_DELAY_MS, MAX_RETRIES, EMPTY_BUNDLE_THRESHOLD, GROUP_OUTPUT_REGEX;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -2052,6 +2278,10 @@ var init_tests_in_browser = __esm({
       (_, i, parts) => path5.join(parts.slice(0, parts.length - i).join(path5.sep) || path5.sep, "node_modules")
     );
     ANCESTOR_NODE_MODULES = ancestorNodeModules(process.cwd());
+    RETRY_DELAY_MS = 100;
+    MAX_RETRIES = 3;
+    EMPTY_BUNDLE_THRESHOLD = 500;
+    GROUP_OUTPUT_REGEX = /group-(\d+)\.js(\.map)?$/;
   }
 });
 
@@ -2346,7 +2576,9 @@ var init_write_output_static_files = __esm({
 // lib/commands/run.ts
 var run_exports = {};
 __export(run_exports, {
+  computeFileTimes: () => computeFileTimes,
   default: () => run,
+  readTimingCache: () => readTimingCache,
   run: () => run
 });
 import fs12 from "node:fs/promises";
@@ -2422,7 +2654,8 @@ async function run(config) {
   } else {
     const allFiles = Object.keys(config.fsTree);
     const groupCount = Math.min(allFiles.length, availableParallelism());
-    const groups = await splitIntoGroups(allFiles, groupCount);
+    const timings = await readTimingCache(config.projectRoot);
+    const { groups, weights } = await splitIntoGroups(allFiles, groupCount, timings);
     config.COUNTER = {
       testCount: 0,
       failCount: 0,
@@ -2441,6 +2674,13 @@ async function run(config) {
       _phase: "bundling"
     }));
     const groupCachedContents = groups.map(() => ({ ...cachedContent }));
+    const sharedServer = groupCount > 1 && cachedContent.htmlPathsToRunTests[0] === "/" && cachedContent.htmlPathsToRunTests.length === 1 ? (() => {
+      const s = new HTTPServer();
+      setupGroupWSHandler(s, groupConfigs);
+      groupConfigs.forEach((gc, i) => registerGroupRoutes(s, gc, groupCachedContents[i], i));
+      registerSharedStaticHandler(s, groupConfigs);
+      return s;
+    })() : null;
     process.stdout.write("TAP version 13\n");
     process.stdout.write(
       `# Running ${allFiles.length} test file${allFiles.length === 1 ? "" : "s"} across ${groupCount} group${groupCount === 1 ? "" : "s"}
@@ -2448,22 +2688,27 @@ async function run(config) {
     );
     const [browser] = await Promise.all([
       launchBrowser(config),
-      Promise.all(
-        groupConfigs.map(
-          (groupConfig, i) => Promise.all([
-            buildTestBundle(groupConfig, groupCachedContents[i]),
-            writeOutputStaticFiles(groupConfig, groupCachedContents[i])
-          ])
+      sharedServer ? bindServerToPort(sharedServer, config).then(
+        () => groupConfigs.forEach((gc, i) => {
+          gc.port = config.port;
+          groupCachedContents[i].htmlPathsToRunTests = [`/group-${i}/`];
+        })
+      ) : Promise.resolve(),
+      Promise.all([
+        groupCount > 1 ? buildAllGroupBundles(groupConfigs, groupCachedContents) : buildTestBundle(groupConfigs[0], groupCachedContents[0]),
+        Promise.all(
+          groupConfigs.map((gc, i) => writeOutputStaticFiles(gc, groupCachedContents[i]))
         )
-      )
+      ])
     ]);
     if (config.open) {
       void openOutputInBrowser(config);
     }
     const TIME_COUNTER = timeCounter();
+    const wallTimes = /* @__PURE__ */ new Map();
     const GROUP_TIMEOUT_MS = 3 * 60 * 1e3;
     const keepAlive = setInterval(() => {
-    }, 1e3);
+    }, 1e4);
     const groupResults = await Promise.allSettled(
       groupConfigs.map((groupConfig, i) => {
         const groupTimeout = new Promise((_, reject) => {
@@ -2480,35 +2725,41 @@ async function run(config) {
           }, GROUP_TIMEOUT_MS);
           timeoutId.unref();
         });
-        return Promise.race([
-          (async () => {
-            groupConfig._phase = "connecting";
-            const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
-            groupConfig.expressApp = connections.server;
-            if (config.before) {
-              await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, "before");
-            }
-            try {
-              await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
-            } finally {
-              await flushConsoleHandlers(groupConfig._pendingConsoleHandlers);
-              await Promise.all([
-                connections.server && connections.server.close(),
-                connections.page && // Unref'd: the keepAlive interval above holds the event loop open, so this
-                // timer still fires if page.close() hangs, without preventing process exit later.
-                Promise.race([
-                  connections.page.close(),
-                  new Promise((resolve) => {
-                    const pageCloseTimeoutId = setTimeout(resolve, 1e4);
-                    pageCloseTimeoutId.unref();
-                  })
-                ]).catch(() => {
+        const startMs = Date.now();
+        const work = (async () => {
+          groupConfig._phase = "connecting";
+          const connections = await setupBrowser(
+            groupConfig,
+            groupCachedContents[i],
+            browser,
+            sharedServer
+          );
+          groupConfig.expressApp = connections.server;
+          if (config.before) {
+            await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, "before");
+          }
+          try {
+            await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
+          } finally {
+            await flushConsoleHandlers(groupConfig._pendingConsoleHandlers);
+            await Promise.all([
+              !sharedServer && connections.server?.close(),
+              connections.page && // Unref'd: the keepAlive interval above holds the event loop open, so this
+              // timer still fires if page.close() hangs, without preventing process exit later.
+              Promise.race([
+                connections.page.close(),
+                new Promise((resolve) => {
+                  const pageCloseTimeoutId = setTimeout(resolve, 1e4);
+                  pageCloseTimeoutId.unref();
                 })
-              ]);
-            }
-          })(),
-          groupTimeout
-        ]);
+              ]).catch(() => {
+              })
+            ]);
+          }
+        })();
+        const record = () => wallTimes.set(i, Date.now() - startMs);
+        work.then(record, record);
+        return Promise.race([work, groupTimeout]);
       })
     );
     const exitCode = groupResults.reduce(
@@ -2527,6 +2778,12 @@ async function run(config) {
       );
     }
     TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
+    const fileTimes = computeFileTimes(groups, weights, wallTimes);
+    persistTimings(fileTimes, config.projectRoot).catch(
+      (err) => config.debug && process.stderr.write(`# [qunitx] persistTimings: ${err.message}
+`)
+    );
+    printFileTimings(fileTimes, config.projectRoot);
     if (config.after) {
       await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
     }
@@ -2535,8 +2792,16 @@ async function run(config) {
     process.stdout.write("\n", async () => {
       clearTimeout(exitTimer);
       clearInterval(keepAlive);
-      await browser.close().catch(() => {
-      });
+      await Promise.all([
+        sharedServer?.close().catch(
+          (err) => config.debug && process.stderr.write(`# [qunitx] server.close: ${err.message}
+`)
+        ),
+        browser.close().catch(
+          (err) => config.debug && process.stderr.write(`# [qunitx] browser.close: ${err.message}
+`)
+        )
+      ]);
       await shutdownPrelaunch();
       process.exit(exitCode);
     });
@@ -2597,24 +2862,57 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
   }
   return cachedContent;
 }
-async function splitIntoGroups(files, groupCount) {
-  const withSizes = await Promise.all(
+async function readTimingCache(projectRoot) {
+  try {
+    const parsed = JSON.parse(await fs12.readFile(`${projectRoot}/tmp/test-timings.json`, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function computeFileTimes(groups, weights, wallTimes) {
+  const result = /* @__PURE__ */ new Map();
+  groups.forEach((group, i) => {
+    const wallMs = wallTimes.get(i);
+    if (wallMs === void 0) return;
+    const total = group.reduce((sum, f) => sum + (weights.get(f) ?? 0), 0);
+    group.forEach(
+      (f) => result.set(f, total > 0 ? wallMs * ((weights.get(f) ?? 0) / total) : wallMs / group.length)
+    );
+  });
+  return result;
+}
+async function persistTimings(fileTimes, projectRoot) {
+  await fs12.writeFile(
+    `${projectRoot}/tmp/test-timings.json`,
+    JSON.stringify(Object.fromEntries(fileTimes), null, 2)
+  );
+}
+function printFileTimings(fileTimes, projectRoot) {
+  if (fileTimes.size === 0) return;
+  const lines = [...fileTimes.entries()].sort(([, a], [, b]) => b - a).map(([f, ms]) => `#   ${ms.toFixed(0)}ms  ${f.replace(`${projectRoot}/`, "")}`);
+  process.stdout.write(`# File execution times:
+${lines.join("\n")}
+`);
+}
+async function splitIntoGroups(files, groupCount, timings) {
+  const sizes = await Promise.all(
     files.map(
-      (f) => fs12.stat(f).then(({ size }) => ({ f, size })).catch(() => ({ f, size: 0 }))
+      (f) => timings[f] > 0 ? Promise.resolve(0) : fs12.stat(f).then((s) => s.size).catch(() => 0)
     )
   );
-  return withSizes.sort((a, b) => b.size - a.size).reduce(
-    (groups, { f, size }) => {
-      const { idx } = groups.reduce(
-        (min, { total }, i) => total < min.total ? { idx: i, total } : min,
-        { idx: 0, total: groups[0].total }
-      );
-      groups[idx].files.push(f);
-      groups[idx].total += size;
-      return groups;
-    },
-    Array.from({ length: groupCount }, () => ({ files: [], total: 0 }))
-  ).flatMap((g) => g.files.length > 0 ? [g.files] : []);
+  const knownRates = files.map((f, i) => ({ ms: timings[f], size: sizes[i] })).filter(({ ms, size }) => ms > 0 && size > 0);
+  const msPerByte = knownRates.length > 0 ? knownRates.reduce((sum, { ms, size }) => sum + ms / size, 0) / knownRates.length : 1;
+  const weights = new Map(
+    files.map((f, i) => [f, timings[f] > 0 ? timings[f] : sizes[i] * msPerByte])
+  );
+  const buckets = Array.from({ length: groupCount }, () => ({ files: [], total: 0 }));
+  [...files].sort((a, b) => (weights.get(b) ?? 0) - (weights.get(a) ?? 0)).forEach((f) => {
+    const min = buckets.reduce((m, _, i) => buckets[i].total < buckets[m].total ? i : m, 0);
+    buckets[min].files.push(f);
+    buckets[min].total += weights.get(f) ?? 0;
+  });
+  return { groups: buckets.filter((b) => b.files.length > 0).map((b) => b.files), weights };
 }
 function logWatcherAndKeyboardShortcutInfo(config, _server) {
   const prefix = "Watching files...";
@@ -2637,6 +2935,9 @@ var init_run = __esm({
   "lib/commands/run.ts"() {
     init_browser();
     init_chrome_prelaunch();
+    init_http();
+    init_bind_server_to_port();
+    init_web_server();
     init_open_output_in_browser();
     init_color();
     init_tests_in_browser();
@@ -2663,7 +2964,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.19.1",
+  version: "0.19.3",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2779,8 +3080,18 @@ import path2 from "node:path";
 // lib/utils/find-project-root.ts
 import process2 from "node:process";
 
+// lib/utils/path-exists.ts
+import fs2 from "node:fs/promises";
+async function pathExists(path7) {
+  try {
+    await fs2.access(path7);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // lib/utils/search-in-parent-directories.ts
-init_path_exists();
 async function searchInParentDirectories(directory, targetEntry) {
   const resolvedDirectory = directory === "." ? process.cwd() : directory;
   if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
@@ -2808,9 +3119,6 @@ async function findProjectRoot() {
   }
 }
 
-// lib/commands/init.ts
-init_path_exists();
-
 // lib/setup/default-project-config-values.ts
 var defaultProjectConfigValues = {
   output: "tmp",
@@ -2877,7 +3185,6 @@ async function writeTSConfigIfNeeded(projectRoot) {
 // lib/commands/generate.ts
 init_color();
 import fs5 from "node:fs/promises";
-init_path_exists();
 init_read_template();
 
 // lib/utils/convert-to-pascal-case.ts
@@ -3162,6 +3469,7 @@ process4.title = "qunitx";
   } catch (error) {
     console.error(error);
     process4.exitCode = 1;
+    await shutdownPrelaunch();
     process4.stdout.write("\n", () => process4.exit(1));
   }
 })();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",