qunitx-cli 0.19.2 → 0.20.0

package/dist/cli.js

@@ -55,71 +55,78 @@ 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 deadline = Date.now() + 5e3;
+  const dirName = dirPath.split("/").pop();
+  await killAllReferencingProcesses(dirPath, dirName);
+  const deadline = Date.now() + CLEANUP_DEADLINE_MS;
   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));
+    const removed = await fs.rm(dirPath, { recursive: true, force: true }).then(
+      () => fs.access(dirPath).then(
+        () => false,
+        () => true
+      )
+    ).catch(() => false);
+    if (removed) return;
+    await killAllReferencingProcesses(dirPath, dirName);
+    await new Promise((resolve) => setTimeout(resolve, CLEANUP_RETRY_MS));
   }
-  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 CLEANUP_DEADLINE_MS, CLEANUP_RETRY_MS;
 var init_cleanup_browser_dir = __esm({
   "lib/utils/cleanup-browser-dir.ts"() {
+    CLEANUP_DEADLINE_MS = 5e3;
+    CLEANUP_RETRY_MS = 50;
   }
 });
 
@@ -168,36 +175,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;
@@ -498,10 +480,11 @@ function dumpYaml({
   expected,
   message,
   stack,
+  source,
   at
 }) {
   return `name: ${dumpString(name, "")}
-` + yamlLine("actual", actual) + yamlLine("expected", expected) + (message !== null ? yamlLine("message", message) : "") + (stack !== null ? yamlLine("stack", stack) : "") + (at !== null ? yamlLine("at", at) : "");
+` + yamlLine("actual", actual) + yamlLine("expected", expected) + (message !== null ? yamlLine("message", message) : "") + (stack !== null ? yamlLine("stack", stack) : "") + (source !== null ? yamlLine("source", source) : "") + (at !== null ? yamlLine("at", at) : "");
 }
 var NEEDS_QUOTING;
 var init_dump_yaml = __esm({
@@ -524,8 +507,205 @@ var init_indent_string = __esm({
   }
 });
 
+// lib/utils/source-map-decoder.ts
+function readVLQ(s, pos) {
+  let accumulated = 0;
+  let shift = 0;
+  let digit;
+  do {
+    digit = BASE64_LOOKUP[s.charCodeAt(pos++)];
+    accumulated |= (digit & 31) << shift;
+    shift += 5;
+  } while (digit & 32);
+  return [accumulated & 1 ? -(accumulated >>> 1) : accumulated >>> 1, pos];
+}
+function decodeMappings(mappings) {
+  let sourceIndex = 0, sourceLine = 0, sourceCol = 0;
+  return mappings.split(";").map((lineStr) => {
+    const segments = [];
+    let generatedCol = 0;
+    let pos = 0;
+    while (pos < lineStr.length) {
+      if (lineStr[pos] === ",") {
+        pos++;
+        continue;
+      }
+      let delta;
+      [delta, pos] = readVLQ(lineStr, pos);
+      generatedCol += delta;
+      if (pos >= lineStr.length || lineStr[pos] === ",") continue;
+      [delta, pos] = readVLQ(lineStr, pos);
+      sourceIndex += delta;
+      [delta, pos] = readVLQ(lineStr, pos);
+      sourceLine += delta;
+      [delta, pos] = readVLQ(lineStr, pos);
+      sourceCol += delta;
+      if (pos < lineStr.length && lineStr[pos] !== ",") [, pos] = readVLQ(lineStr, pos);
+      segments.push({ generatedCol, sourceIndex, sourceLine, sourceCol });
+    }
+    return segments;
+  });
+}
+function parseSourceMap(json, outDir) {
+  const map = JSON.parse(json);
+  return {
+    segmentsByLine: decodeMappings(map.mappings),
+    sources: map.sources ?? [],
+    sourceRoot: map.sourceRoot ?? "",
+    outDir,
+    sourcesContent: map.sourcesContent ?? []
+  };
+}
+function base64DecodeUtf8(b64) {
+  const binary = atob(b64);
+  return UTF8.decode(Uint8Array.from(binary, (c) => c.charCodeAt(0)));
+}
+function extractInlineSourceMap(bundle, outDir) {
+  if (!bundle) return null;
+  const text = typeof bundle === "string" ? bundle : UTF8.decode(bundle);
+  const match = text.match(
+    /\/\/# sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/
+  );
+  if (!match) return null;
+  try {
+    return parseSourceMap(base64DecodeUtf8(match[1]), outDir);
+  } catch {
+    return null;
+  }
+}
+function normalizePosix(p) {
+  const abs = p.startsWith("/");
+  const parts = p.split("/");
+  const out = [];
+  for (const part of parts) {
+    if (part === "..") out.pop();
+    else if (part !== "" && part !== ".") out.push(part);
+  }
+  return (abs ? "/" : "") + out.join("/");
+}
+function posixResolve(base, relative) {
+  if (relative.startsWith("/")) return normalizePosix(relative);
+  return normalizePosix(base + "/" + relative);
+}
+function toAbsolutePath(raw, outDir, sourceRoot) {
+  if (raw.startsWith("file://")) return raw.slice(7);
+  if (raw.startsWith("/")) return raw;
+  const base = sourceRoot ? normalizePosix(outDir + "/" + sourceRoot) : outDir;
+  return posixResolve(base, raw);
+}
+function lookupPosition(decoder, generatedLine, generatedCol) {
+  const segments = decoder.segmentsByLine[generatedLine - 1];
+  if (!segments?.length) return null;
+  const col0 = generatedCol - 1;
+  let lo = 0, hi = segments.length - 1, best = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    if (segments[mid].generatedCol <= col0) {
+      best = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  if (best === -1) return null;
+  const { sourceIndex, sourceLine, sourceCol } = segments[best];
+  const rawSource = decoder.sources[sourceIndex];
+  if (!rawSource) return null;
+  const content = decoder.sourcesContent[sourceIndex];
+  const sourceText = content ? content.split("\n", sourceLine + 1)[sourceLine]?.trim() || null : null;
+  return {
+    absolutePath: toAbsolutePath(rawSource, decoder.outDir, decoder.sourceRoot),
+    line: sourceLine + 1,
+    // 0-based → 1-based
+    col: sourceCol + 1,
+    // 0-based → 1-based
+    sourceText
+  };
+}
+function parseFrameLocation(s) {
+  const colSep = s.lastIndexOf(":");
+  if (colSep < 0) return null;
+  const colStr = s.slice(colSep + 1);
+  if (!/^\d+$/.test(colStr)) return null;
+  const lineSep = s.lastIndexOf(":", colSep - 1);
+  if (lineSep < 0) return null;
+  const lineStr = s.slice(lineSep + 1, colSep);
+  if (!/^\d+$/.test(lineStr)) return null;
+  return { url: s.slice(0, lineSep), line: +lineStr, col: +colStr };
+}
+function isBundleUrl(url) {
+  const normalized = url.startsWith("async ") ? url.slice(6) : url;
+  return /^https?:\/\//.test(normalized) && /\/(tests|filtered-tests)\.js$/.test(normalized);
+}
+function isNodeModulesPath(absolutePath) {
+  return absolutePath.includes("/node_modules/") || absolutePath.includes("\\node_modules\\");
+}
+function makeDisplayPath(absolutePath, projectRoot) {
+  const prefix = projectRoot + "/";
+  return absolutePath.startsWith(prefix) ? absolutePath.slice(prefix.length) : absolutePath;
+}
+function tryResolve(urlLineCol, decoder, projectRoot) {
+  const loc = parseFrameLocation(urlLineCol);
+  if (!loc || !isBundleUrl(loc.url)) return null;
+  const orig = lookupPosition(decoder, loc.line, loc.col);
+  if (!orig) return null;
+  const display = `${makeDisplayPath(orig.absolutePath, projectRoot)}:${orig.line}:${orig.col}`;
+  return {
+    display,
+    userPath: isNodeModulesPath(orig.absolutePath) ? null : display,
+    sourceText: orig.sourceText
+  };
+}
+function resolveFrame(frame, decoder, projectRoot) {
+  const chromeName = frame.match(/^(\s*at\s+)(.*?)\s+\(([^)]+)\)\s*$/);
+  if (chromeName) {
+    const r = tryResolve(chromeName[3], decoder, projectRoot);
+    return r ? {
+      resolved: `${chromeName[1]}${chromeName[2]} (${r.display})`,
+      userPath: r.userPath,
+      sourceText: r.sourceText
+    } : null;
+  }
+  const chromeAnon = frame.match(/^(\s*at\s+(?:async\s+)?)(.+)/);
+  if (chromeAnon) {
+    const r = tryResolve(chromeAnon[2], decoder, projectRoot);
+    return r ? { resolved: `${chromeAnon[1]}${r.display}`, userPath: r.userPath, sourceText: r.sourceText } : null;
+  }
+  const gecko = frame.match(/^([^@]*)@(.+)$/);
+  if (gecko) {
+    const r = tryResolve(gecko[2], decoder, projectRoot);
+    return r ? { resolved: `${gecko[1]}@${r.display}`, userPath: r.userPath, sourceText: r.sourceText } : null;
+  }
+  return null;
+}
+function resolveStack(stack, decoder, projectRoot) {
+  let firstUserFrame = null;
+  let firstUserSourceText = null;
+  const resolvedLines = stack.split("\n").map((frame) => {
+    const result = resolveFrame(frame, decoder, projectRoot);
+    if (!result) return frame;
+    if (!firstUserFrame && result.userPath) {
+      firstUserFrame = result.userPath;
+      firstUserSourceText = result.sourceText;
+    }
+    return result.resolved;
+  });
+  return { resolvedStack: resolvedLines.join("\n"), firstUserFrame, firstUserSourceText };
+}
+var BASE64, BASE64_LOOKUP, UTF8;
+var init_source_map_decoder = __esm({
+  "lib/utils/source-map-decoder.ts"() {
+    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    BASE64_LOOKUP = new Uint8Array(128);
+    [...BASE64].forEach((ch, i) => {
+      BASE64_LOOKUP[ch.charCodeAt(0)] = i;
+    });
+    UTF8 = new TextDecoder();
+  }
+});
+
 // lib/tap/display-test-result.ts
-function TAPDisplayTestResult(COUNTER, details) {
+function TAPDisplayTestResult(COUNTER, details, decoder, projectRoot) {
   COUNTER.testCount++;
   if (details.status === "skipped") {
     COUNTER.skipCount++;
@@ -545,6 +725,19 @@ function TAPDisplayTestResult(COUNTER, details) {
       if (!assertion.passed && assertion.todo === false) {
         COUNTER.errorCount = (COUNTER.errorCount ?? 0) + 1;
         process.stdout.write("  ---\n");
+        let stackStr = assertion.stack?.trim() || null;
+        let atStr = extractStackAt(assertion.stack);
+        let sourceText = null;
+        if (decoder && projectRoot && assertion.stack) {
+          const { resolvedStack, firstUserFrame, firstUserSourceText } = resolveStack(
+            assertion.stack,
+            decoder,
+            projectRoot
+          );
+          stackStr = resolvedStack.trim() || null;
+          atStr = firstUserFrame;
+          sourceText = firstUserSourceText;
+        }
         process.stdout.write(
           indentString(
             dumpYaml({
@@ -552,10 +745,9 @@ function TAPDisplayTestResult(COUNTER, details) {
               actual: assertion.actual !== null && typeof assertion.actual === "object" ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
               expected: assertion.expected !== null && typeof assertion.expected === "object" ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
               message: assertion.message || null,
-              // Trim leading/trailing whitespace: Chrome stacks start with "    at ..."
-              // (4 spaces per frame) which would otherwise render as "stack:     at ..." in YAML.
-              stack: assertion.stack?.trim() || null,
-              at: extractStackAt(assertion.stack)
+              stack: stackStr,
+              source: sourceText,
+              at: atStr
             }),
             4
           )
@@ -599,6 +791,7 @@ var init_display_test_result = __esm({
   "lib/tap/display-test-result.ts"() {
     init_dump_yaml();
     init_indent_string();
+    init_source_map_decoder();
   }
 });
 
@@ -780,11 +973,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) {
@@ -827,10 +1022,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);
               }
@@ -838,7 +1031,7 @@ var init_http = __esm({
             return true;
           }
           return false;
-        }) || routes["/*"] || null;
+        }) || null;
       }
       #matchPathSegments(path7, url) {
         const pathSegments = path7.split("/");
@@ -892,6 +1085,20 @@ function setupWebServer(config, cachedContent) {
     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);
@@ -901,17 +1108,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") {
@@ -924,7 +1121,7 @@ function setupWebServer(config, cachedContent) {
           );
         }
         config._resetTestTimeout?.();
-        TAPDisplayTestResult(config.COUNTER, details);
+        TAPDisplayTestResult(config.COUNTER, details, config._sourceMapDecoder, config.projectRoot);
       } else if (event === "done") {
         config._phase = "done";
         config._lastQUnitResult = qunitResult ?? null;
@@ -941,7 +1138,26 @@ function setupWebServer(config, cachedContent) {
       }
     });
   });
-  server.get("/tests.js", (_req, res) => {
+  server.get("/tests.js", async (_req, res) => {
+    if (cachedContent._activeRebuild) {
+      await cachedContent._activeRebuild.catch(() => {
+      });
+      if (!cachedContent.allTestCode) {
+        config._lastQUnitResult = {
+          totalTests: 0,
+          finishedTests: 0,
+          failedTests: 0,
+          currentTest: null
+        };
+        config._testRunDone?.();
+        config._testRunDone = null;
+        res.writeHead(200, {
+          "Content-Type": "application/javascript",
+          "Cache-Control": "no-store"
+        });
+        return void res.end();
+      }
+    }
     const bytes = cachedContent.allTestCode?.length ?? null;
     config.debug && process.stdout.write(
       `# [HTTPServer] GET /tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (allTestCode is null)"}
@@ -949,10 +1165,9 @@ function setupWebServer(config, cachedContent) {
     );
     if (bytes === null) {
       res.writeHead(503, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
-      res.end(
+      return void res.end(
         'console.error("[qunitx] /tests.js requested before bundle was built \u2014 allTestCode is null");'
       );
-      return;
     }
     config._onTestsJsServed?.();
     res.writeHead(200, {
@@ -970,10 +1185,9 @@ function setupWebServer(config, cachedContent) {
     );
     if (bytes === null) {
       res.writeHead(503, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
-      res.end(
+      return res.end(
         'console.error("[qunitx] /filtered-tests.js requested before bundle was built \u2014 filteredTestCode is null");'
       );
-      return;
     }
     config._onTestsJsServed?.();
     res.writeHead(200, {
@@ -984,68 +1198,48 @@ function setupWebServer(config, cachedContent) {
     res.end(cachedContent.filteredTestCode);
   });
   server.get("/", async (_req, res) => {
+    await cachedContent._activeRebuild?.catch(() => {
+    });
     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);
+      if (cachedContent._activeRebuild) {
+        config._lastQUnitResult = {
+          totalTests: 0,
+          finishedTests: 0,
+          failedTests: 0,
+          currentTest: null
+        };
+        config._testRunDone?.();
+        config._testRunDone = null;
+      }
+      return saveHTML(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
     }
     if (cachedContent._noTestsWarning) {
-      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
-      return;
+      res.writeHead(200, HTML_HEADERS);
+      return res.end(buildNoTestsHTML(cachedContent._noTestsWarning));
     }
-    const htmlContent = escapeAndInjectTestsToHTML(
-      mainHTMLWithReplacedAssets,
-      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}/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);
+      return saveHTML(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
     }
     if (cachedContent._noTestsWarning) {
-      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
-      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
-      res.write(htmlContent2);
-      res.end();
-      return;
+      res.writeHead(200, HTML_HEADERS);
+      return res.end(buildNoTestsHTML(cachedContent._noTestsWarning));
     }
-    const htmlContent = escapeAndInjectTestsToHTML(
-      mainHTMLWithReplacedAssets,
-      runtimeScript,
-      "./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(
@@ -1053,13 +1247,10 @@ function setupWebServer(config, cachedContent) {
         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 = Date.now();
@@ -1093,13 +1284,9 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
     return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
-function testRuntimeToInject(config) {
+function testRuntimeToInject(config, groupId) {
+  const groupIdPart = groupId !== void 0 ? `, groupId: ${groupId}` : "";
   return `<script>
-    window.testTimeout = 0;
-    setInterval(() => {
-      window.testTimeout = window.testTimeout + 1000;
-    }, 1000);
-
     (function() {
       // wsOpenStatus: true once the WebSocket 'open' event fires (or immediately for static files).
       // testsLoaded: true once tests.js has executed and dispatched 'qunitx:tests-ready'.
@@ -1125,7 +1312,7 @@ function testRuntimeToInject(config) {
       if (window.location.protocol === 'file:') return;
 
       let wsRetryCount = 0;
-      const WS_MAX_RETRIES = Math.ceil(${config.timeout} / 10); // retry for the full test timeout window
+      const WS_MAX_RETRIES = Math.ceil(${config.timeout} / ${WS_RETRY_INTERVAL_MS}); // retry for the full test timeout window
 
       function setupWebSocket() {
         try {
@@ -1142,7 +1329,7 @@ function testRuntimeToInject(config) {
           // 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 (navigator.webdriver) {
-            window.socket.send(JSON.stringify({ event: 'wsOpen' }));
+            window.socket.send(JSON.stringify({ event: 'wsOpen'${groupIdPart} }));
           }
           maybeStart();
         });
@@ -1164,10 +1351,9 @@ function testRuntimeToInject(config) {
         wsRetryCount++;
         if (wsRetryCount > WS_MAX_RETRIES) {
           console.log('WebSocket connection failed after ' + WS_MAX_RETRIES + ' retries');
-          window.testTimeout = ${config.timeout};
           return;
         }
-        window.setTimeout(setupWebSocket, 10);
+        window.setTimeout(setupWebSocket, ${WS_RETRY_INTERVAL_MS});
       }
 
       setupWebSocket();
@@ -1201,8 +1387,6 @@ function testRuntimeToInject(config) {
           // "no tests registered" warning (not a failure), so this gives a fast, clean result.
           window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, failedTests: 0, currentTest: null };
           window.socket.send(JSON.stringify({ event: 'done', details: { passed: 0, failed: 0, runtime: 0 } }));
-        } else {
-          window.testTimeout = ${config.timeout};
         }
         return;
       }
@@ -1217,7 +1401,6 @@ function testRuntimeToInject(config) {
         window.QUNIT_RESULT.currentTest = details.fullName.join(' | ');
       });
       window.QUnit.on('testEnd', (details) => { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
-        window.testTimeout = 0;
         window.QUNIT_RESULT.finishedTests++;
         if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
         window.QUNIT_RESULT.currentTest = null;
@@ -1234,16 +1417,10 @@ function testRuntimeToInject(config) {
       window.QUnit.done((details) => {
         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
-          // for true timeouts (test hangs) where testTimeout increments naturally via setInterval.
-          // Setting testTimeout after done caused a race: under CI load, waitForFunction could
-          // win before Node.js processed the WS done message, dropping all testEnd events.
-        } else {
-          window.testTimeout = ${config.timeout};
         }
       });
 
+      window.QUnit.config.testTimeout = ${config.timeout};
       window.QUnit.start();
     }
   </script>`;
@@ -1344,8 +1521,8 @@ function buildNoTestsHTML(files) {
         var retries = 0;
         function connect() {
           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('message', function (e) { if (e.data === 'refresh' && !navigator.webdriver) location.reload(true); });
+          ws.addEventListener('close', function () { if (retries++ < ${WATCH_WS_RECONNECT_MAX_RETRIES}) setTimeout(connect, ${WATCH_WS_RECONNECT_INTERVAL_MS}); });
           ws.addEventListener('error', function () { ws.close(); });
         }
         connect();
@@ -1446,8 +1623,8 @@ function buildErrorHTML(buildError) {
         var retries = 0;
         function connect() {
           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('message', function (e) { if (e.data === 'refresh' && !navigator.webdriver) location.reload(true); });
+          ws.addEventListener('close', function () { if (retries++ < ${WATCH_WS_RECONNECT_MAX_RETRIES}) setTimeout(connect, ${WATCH_WS_RECONNECT_INTERVAL_MS}); });
           ws.addEventListener('error', function () { ws.close(); });
         }
         connect();
@@ -1457,7 +1634,143 @@ function buildErrorHTML(buildError) {
 </body>
 </html>`;
 }
-var fsPromise, NOT_FOUND_HTML;
+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);
+      return res.end(buildErrorHTML(groupCachedContent._buildError));
+    }
+    if (groupCachedContent._noTestsWarning) {
+      res.writeHead(200, HTML_HEADERS);
+      return res.end(buildNoTestsHTML(groupCachedContent._noTestsWarning));
+    }
+    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" });
+      return res.end(
+        'console.error("[qunitx] /tests.js requested before bundle was built \u2014 allTestCode is null");'
+      );
+    }
+    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, config._sourceMapDecoder, config.projectRoot);
+      } 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, WATCH_WS_RECONNECT_INTERVAL_MS, WATCH_WS_RECONNECT_MAX_RETRIES, WS_RETRY_INTERVAL_MS, NOT_FOUND_HTML;
 var init_web_server = __esm({
   "lib/setup/web-server.ts"() {
     init_find_internal_assets_from_html();
@@ -1466,6 +1779,10 @@ var init_web_server = __esm({
     init_color();
     init_http();
     fsPromise = fs8.promises;
+    HTML_HEADERS = { "Content-Type": "text/html", "Cache-Control": "no-store" };
+    WATCH_WS_RECONNECT_INTERVAL_MS = 1e3;
+    WATCH_WS_RECONNECT_MAX_RETRIES = 120;
+    WS_RETRY_INTERVAL_MS = 10;
     NOT_FOUND_HTML = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -1541,19 +1858,24 @@ 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`);
+  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 = setupWebServer(config, cachedContent);
+    perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
+    const activeBrowser = existingBrowser ?? 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) => {
@@ -1740,7 +2062,7 @@ async function buildTestBundle(config, cachedContent) {
   }
   const outfile = `${projectRoot}/${output}/tests.js`;
   await fs9.mkdir(`${projectRoot}/${output}`, { recursive: true });
-  const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
+  const sourcemap = "inline";
   const needsDisk = true;
   const buildOptions = {
     stdin: {
@@ -1780,6 +2102,7 @@ async function buildTestBundle(config, cachedContent) {
       )
     ]);
     cachedContent.allTestCode = allTestCode;
+    config._sourceMapDecoder = extractInlineSourceMap(allTestCode, `${projectRoot}/${output}`);
   } catch (error) {
     cachedContent._buildError = {
       type: deriveBuildErrorType(error),
@@ -1811,9 +2134,13 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
     const preBuildPromise = cachedContent._preBuildPromise;
     cachedContent._preBuildPromise = null;
     if (!cachedContent.allTestCode) {
-      await (preBuildPromise ?? buildTestBundle(config, cachedContent));
+      if (preBuildPromise) {
+        cachedContent._activeRebuild = preBuildPromise;
+      } else {
+        await buildTestBundle(config, cachedContent);
+      }
     }
-    if (!cachedContent.allTestCode) {
+    if (!cachedContent.allTestCode && !cachedContent._activeRebuild) {
       return connections;
     }
     if (runHasFilter) {
@@ -1823,6 +2150,10 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         outputPath,
         config
       );
+      config._sourceMapDecoder = extractInlineSourceMap(
+        cachedContent.filteredTestCode,
+        `${projectRoot}/${output}`
+      );
     }
     const TIME_COUNTER = timeCounter();
     if (runHasFilter) {
@@ -1834,6 +2165,17 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         )
       );
     }
+    if (cachedContent._activeRebuild) {
+      await cachedContent._activeRebuild.catch(() => {
+      });
+      cachedContent._activeRebuild = null;
+      if (!cachedContent.allTestCode) {
+        config.watch && cachedContent._buildError && console.log(
+          `# esbuild Bundle Error: ${cachedContent._buildError.formatted}`.split("\n").join("\n# ")
+        );
+        return connections;
+      }
+    }
     const TIME_TAKEN = TIME_COUNTER.stop();
     if (!config._groupMode) {
       if (config.COUNTER.testCount === 0 && !cachedContent._buildError) {
@@ -1865,6 +2207,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
       }
     }
   } catch (error) {
+    cachedContent._activeRebuild = null;
     config.lastFailedTestFiles = config.lastRanTestFiles;
     const exception = new BundleError(error);
     if (!cachedContent._buildError && error.errors?.length) {
@@ -1875,8 +2218,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}`);
@@ -1887,8 +2232,8 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
   return connections;
 }
 function buildFilteredTests(filteredTests, outputPath, config) {
-  const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
-  const needsDisk = sourcemap === "linked" || Boolean(config.open);
+  const sourcemap = "inline";
+  const needsDisk = Boolean(config.open);
   return buildWithOverlayfsRetry(
     {
       stdin: {
@@ -1908,9 +2253,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++) {
@@ -1965,9 +2307,9 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
   let wsConnected = false;
   try {
     console.log("#", blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
-    const navMs = config.timeout + 1e4;
-    const startupMs = Math.max(config.timeout * 3, navMs);
-    const testsJsMs = Math.max(config.timeout * 4, navMs);
+    const navMs = config.timeout + NAV_GRACE_MS;
+    const startupMs = Math.max(config.timeout * STARTUP_TIMEOUT_FACTOR, navMs);
+    const testsJsMs = Math.max(config.timeout * TESTS_JS_TIMEOUT_FACTOR, navMs);
     let resolveTestRace;
     const testRaceResult = new Promise((resolve) => {
       resolveTestRace = resolve;
@@ -1985,7 +2327,7 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     config._resetTestTimeout = () => {
       wsConnected = true;
       clearTimeout(timeoutHandle);
-      timeoutHandle = setTimeout(resolveTestRace, config.timeout);
+      timeoutHandle = setTimeout(resolveTestRace, config.timeout + TEST_STALL_BUFFER_MS);
     };
     const targetUrl = `http://localhost:${config.port}${filePath}`;
     const navOptions = { timeout: navMs, waitUntil: "commit" };
@@ -2055,12 +2397,122 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
     process.exit(1);
   }
 }
-async function flushConsoleHandlers(handlers, deadline = Date.now() + 2e3) {
+async function flushConsoleHandlers(handlers, deadline = Date.now() + CONSOLE_FLUSH_TIMEOUT_MS) {
   if (!handlers || handlers.size === 0 || Date.now() >= deadline) return;
   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, 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 = "inline";
+  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 esbuildOutdir = path5.join(projectRoot, "tmp");
+  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: esbuildOutdir,
+    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);
+          config._sourceMapDecoder = extractInlineSourceMap(
+            cachedContent.allTestCode,
+            esbuildOutdir
+          );
+        }
+        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, NAV_GRACE_MS, STARTUP_TIMEOUT_FACTOR, TESTS_JS_TIMEOUT_FACTOR, CONSOLE_FLUSH_TIMEOUT_MS, TEST_STALL_BUFFER_MS, GROUP_OUTPUT_REGEX;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -2069,6 +2521,7 @@ var init_tests_in_browser = __esm({
     init_run_user_module();
     init_display_final_result();
     init_web_server();
+    init_source_map_decoder();
     BundleError = class extends Error {
       constructor(message) {
         super(message);
@@ -2080,6 +2533,15 @@ 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;
+    NAV_GRACE_MS = 1e4;
+    STARTUP_TIMEOUT_FACTOR = 3;
+    TESTS_JS_TIMEOUT_FACTOR = 4;
+    CONSOLE_FLUSH_TIMEOUT_MS = 2e3;
+    TEST_STALL_BUFFER_MS = 5e3;
+    GROUP_OUTPUT_REGEX = /group-(\d+)\.js(\.map)?$/;
   }
 });
 
@@ -2104,7 +2566,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         }
       }
     };
-    fs10.watchFile(filePath, { interval: 500, persistent: false }, handler);
+    fs10.watchFile(filePath, { interval: SYMLINK_POLL_INTERVAL_MS, persistent: false }, handler);
     symlinkPollers.set(filePath, () => fs10.unwatchFile(filePath, handler));
   }
   function untrackSymlink(filePath) {
@@ -2118,13 +2580,17 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
       if (!ready || !filename) return;
       const fullPath = filename === path6.basename(watchPath) ? watchPath : path6.join(watchPath, filename);
       if (eventType === "change") {
-        if (!config._building) {
-          const now = Date.now();
-          const last = lastChangeMs[fullPath] ?? 0;
-          if (now - last < CHANGE_DEDUPE_MS) {
-            if (!config._lastBuildEndMs || config._lastBuildEndMs <= last) return;
+        const now = Date.now();
+        const last = lastChangeMs[fullPath] ?? 0;
+        lastChangeMs[fullPath] = now;
+        if (now - last < CHANGE_DEDUPE_MS && (config._building || !config._lastBuildEndMs || config._lastBuildEndMs <= last))
+          return;
+        if (config._lastBuildEndMs) {
+          try {
+            const { mtimeMs } = await stat(fullPath);
+            if (mtimeMs < Math.floor(config._lastBuildEndMs / 1e3) * 1e3) return;
+          } catch {
           }
-          lastChangeMs[fullPath] = now;
         }
         return handleWatchEvent(config, extensions, "change", fullPath, onEventFunc, onFinishFunc);
       }
@@ -2194,7 +2660,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
   };
 }
 async function classifyRenameEvent(fullPath, fsTree) {
-  for (const delay of [0, 50]) {
+  for (const delay of [0, OVERLAYFS_RENAME_RETRY_MS]) {
     if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
     try {
       const statResult = await stat(fullPath);
@@ -2262,11 +2728,13 @@ function colorEvent(event) {
   if (event === "add" || event === "addDir") return green("ADDED:");
   return red("REMOVED:");
 }
-var CHANGE_DEDUPE_MS;
+var CHANGE_DEDUPE_MS, SYMLINK_POLL_INTERVAL_MS, OVERLAYFS_RENAME_RETRY_MS;
 var init_file_watcher = __esm({
   "lib/setup/file-watcher.ts"() {
     init_color();
     CHANGE_DEDUPE_MS = 10;
+    SYMLINK_POLL_INTERVAL_MS = 500;
+    OVERLAYFS_RENAME_RETRY_MS = 50;
   }
 });
 
@@ -2383,7 +2851,11 @@ import fs12 from "node:fs/promises";
 import { normalize } from "node:path";
 import { availableParallelism } from "node:os";
 async function run(config) {
-  const cachedContent = await buildCachedContent(config, config.htmlPaths);
+  const browserPromise = config.watch ? null : launchBrowser(config);
+  const [cachedContent, timings] = await Promise.all([
+    buildCachedContent(config, config.htmlPaths),
+    config.watch ? Promise.resolve(null) : readTimingCache(config.projectRoot)
+  ]);
   if (config.watch) {
     const preBuildPromise = buildTestBundle(config, cachedContent);
     preBuildPromise.catch(() => {
@@ -2393,7 +2865,7 @@ async function run(config) {
       setupBrowser(config, cachedContent),
       writeOutputStaticFiles(config, cachedContent)
     ]);
-    config.expressApp = connections.server;
+    config.webServer = connections.server;
     setupKeyboardEvents(config, cachedContent, connections);
     const isHeadedWatchMode = config.open === true && config.watch;
     if (config.open && !isHeadedWatchMode) {
@@ -2412,7 +2884,10 @@ async function run(config) {
       throw error;
     }
     if (isHeadedWatchMode && (cachedContent._buildError || cachedContent._noTestsWarning)) {
-      await connections.page.goto(`http://localhost:${config.port}/`, { waitUntil: "commit", timeout: 5e3 }).catch(() => {
+      await connections.page.goto(`http://localhost:${config.port}/`, {
+        waitUntil: "commit",
+        timeout: WATCH_NAV_TIMEOUT_MS
+      }).catch(() => {
       });
     }
     if (config.watch) {
@@ -2429,6 +2904,10 @@ async function run(config) {
                 `# Rerun triggered: ${event} \u2192 ${file.replace(`${config.projectRoot}/`, "")}`
               );
             }
+            const rebuildPromise = buildTestBundle(config, cachedContent);
+            rebuildPromise.catch(() => {
+            });
+            cachedContent._preBuildPromise = rebuildPromise;
             return await runTestsInBrowser(config, cachedContent, connections);
           }
           if (config.debug) {
@@ -2441,7 +2920,10 @@ async function run(config) {
         async (_path, _event) => {
           connections.server.publish("refresh");
           if (isHeadedWatchMode && (cachedContent._buildError || cachedContent._noTestsWarning)) {
-            await connections.page.goto(`http://localhost:${config.port}/`, { waitUntil: "commit", timeout: 5e3 }).catch(() => {
+            await connections.page.goto(`http://localhost:${config.port}/`, {
+              waitUntil: "commit",
+              timeout: WATCH_NAV_TIMEOUT_MS
+            }).catch(() => {
             });
           }
         }
@@ -2452,8 +2934,7 @@ async function run(config) {
   } else {
     const allFiles = Object.keys(config.fsTree);
     const groupCount = Math.min(allFiles.length, availableParallelism());
-    const timings = await readTimingCache(config.projectRoot);
-    const { groups, weights } = await splitIntoGroups(allFiles, groupCount, timings);
+    const { groups, weights } = await splitIntoGroups(allFiles, groupCount, timings ?? {});
     config.COUNTER = {
       testCount: 0,
       failCount: 0,
@@ -2472,21 +2953,32 @@ 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"}
 `
     );
     const [browser] = await Promise.all([
-      launchBrowser(config),
-      Promise.all(
-        groupConfigs.map(
-          (groupConfig, i) => Promise.all([
-            buildTestBundle(groupConfig, groupCachedContents[i]),
-            writeOutputStaticFiles(groupConfig, groupCachedContents[i])
-          ])
+      browserPromise,
+      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);
@@ -2495,7 +2987,7 @@ async function run(config) {
     const wallTimes = /* @__PURE__ */ new Map();
     const GROUP_TIMEOUT_MS = 3 * 60 * 1e3;
     const keepAlive = setInterval(() => {
-    }, 1e3);
+    }, KEEP_ALIVE_INTERVAL_MS);
     const groupResults = await Promise.allSettled(
       groupConfigs.map((groupConfig, i) => {
         const groupTimeout = new Promise((_, reject) => {
@@ -2515,8 +3007,13 @@ async function run(config) {
         const startMs = Date.now();
         const work = (async () => {
           groupConfig._phase = "connecting";
-          const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
-          groupConfig.expressApp = connections.server;
+          const connections = await setupBrowser(
+            groupConfig,
+            groupCachedContents[i],
+            browser,
+            sharedServer
+          );
+          groupConfig.webServer = connections.server;
           if (config.before) {
             await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, "before");
           }
@@ -2525,13 +3022,13 @@ async function run(config) {
           } finally {
             await flushConsoleHandlers(groupConfig._pendingConsoleHandlers);
             await Promise.all([
-              connections.server && connections.server.close(),
+              !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);
+                  const pageCloseTimeoutId = setTimeout(resolve, PAGE_CLOSE_GRACE_MS);
                   pageCloseTimeoutId.unref();
                 })
               ]).catch(() => {
@@ -2561,20 +3058,30 @@ async function run(config) {
     }
     TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
     const fileTimes = computeFileTimes(groups, weights, wallTimes);
-    persistTimings(fileTimes, config.projectRoot).catch(() => {
-    });
+    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");
     }
-    const exitTimer = setTimeout(() => process.exit(exitCode), 5e3);
+    const exitTimer = setTimeout(() => process.exit(exitCode), STDOUT_FLUSH_GRACE_MS);
     exitTimer.unref();
     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();
+      clearInterval(keepAlive);
       process.exit(exitCode);
     });
   }
@@ -2670,7 +3177,7 @@ ${lines.join("\n")}
 async function splitIntoGroups(files, groupCount, timings) {
   const sizes = await Promise.all(
     files.map(
-      (f) => fs12.stat(f).then((s) => s.size).catch(() => 0)
+      (f) => timings[f] > 0 ? Promise.resolve(0) : fs12.stat(f).then((s) => s.size).catch(() => 0)
     )
   );
   const knownRates = files.map((f, i) => ({ ms: timings[f], size: sizes[i] })).filter(({ ms, size }) => ms > 0 && size > 0);
@@ -2703,10 +3210,14 @@ function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
   const currentDirectory = htmlPath ? htmlPath.split("/").slice(0, -1).join("/") : projectRoot;
   return assetPath.startsWith("./") ? normalize(`${currentDirectory}/${assetPath.slice(2)}`) : normalize(`${currentDirectory}/${assetPath}`);
 }
+var WATCH_NAV_TIMEOUT_MS, PAGE_CLOSE_GRACE_MS, STDOUT_FLUSH_GRACE_MS, KEEP_ALIVE_INTERVAL_MS;
 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();
@@ -2719,6 +3230,10 @@ var init_run = __esm({
     init_display_final_result();
     init_read_template();
     init_html();
+    WATCH_NAV_TIMEOUT_MS = 5e3;
+    PAGE_CLOSE_GRACE_MS = 1e4;
+    STDOUT_FLUSH_GRACE_MS = 5e3;
+    KEEP_ALIVE_INTERVAL_MS = 1e4;
   }
 });
 
@@ -2733,7 +3248,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.19.2",
+  version: "0.20.0",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2788,8 +3303,6 @@ var package_default = {
     ws: "^8.20.0"
   },
   devDependencies: {
-    cors: "^2.8.6",
-    express: "^5.2.1",
     "js-yaml": "^4.1.1",
     prettier: "^3.8.2",
     qunitx: "^1.2.7",
@@ -3099,6 +3612,7 @@ function buildGlobFormat(path7) {
 }
 
 // lib/utils/parse-cli-flags.ts
+var FALLBACK_TIMEOUT_MS = 1e4;
 function parseCliFlags(projectRoot) {
   const providedFlags = process.argv.slice(2).reduce(
     (result, arg) => {
@@ -3113,7 +3627,7 @@ function parseCliFlags(projectRoot) {
       } else if (arg.startsWith("--failfast") || arg.startsWith("--failFast")) {
         return Object.assign(result, { failFast: parseBoolean(arg.split("=")[1]) });
       } else if (arg.startsWith("--timeout")) {
-        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || 1e4 });
+        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || FALLBACK_TIMEOUT_MS });
       } else if (arg.startsWith("--output")) {
         return Object.assign(result, { output: arg.split("=")[1] });
       } else if (arg.endsWith(".html")) {
@@ -3238,6 +3752,7 @@ process4.title = "qunitx";
   } catch (error) {
     console.error(error);
     process4.exitCode = 1;
+    await shutdownPrelaunch();
     process4.stdout.write("\n", () => process4.exit(1));
   }
 })();