qunitx-cli 0.21.2 → 0.21.3

package/dist/cli.js

@@ -12,6 +12,9 @@ var __export = (target, all) => {
 // lib/utils/find-chrome.ts
 import { accessSync, constants } from "node:fs";
 import { join } from "node:path";
+function findChrome() {
+  return Promise.resolve(findChromeSync());
+}
 function findChromeSync() {
   if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
   for (const dir of PATH_DIRS) {
@@ -26,9 +29,6 @@ function findChromeSync() {
   }
   return null;
 }
-function findChrome() {
-  return Promise.resolve(findChromeSync());
-}
 var CANDIDATES, PATH_DIRS;
 var init_find_chrome = __esm({
   "lib/utils/find-chrome.ts"() {
@@ -56,35 +56,6 @@ var init_kill_process_group = __esm({
 
 // lib/utils/cleanup-browser-dir.ts
 import fs from "node:fs/promises";
-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;
-  }
-}
-async function killAllReferencingProcesses(dirPath, dirName) {
-  const procEntries = await fs.readdir("/proc").catch(() => []);
-  await Promise.all(
-    procEntries.map(async (entry) => {
-      if (!/^\d+$/.test(entry)) return;
-      if (!await processReferencesDir(entry, dirPath, dirName)) return;
-      try {
-        process.kill(parseInt(entry), "SIGKILL");
-      } catch {
-      }
-    })
-  );
-}
 async function cleanupBrowserDir(dirPath) {
   if (process.platform !== "linux") {
     await fs.rm(dirPath, { recursive: true, force: true }).catch(() => {
@@ -123,6 +94,35 @@ async function cleanupBrowserDir(dirPath) {
     })
   );
 }
+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;
+  }
+}
+async function killAllReferencingProcesses(dirPath, dirName) {
+  const procEntries = await fs.readdir("/proc").catch(() => []);
+  await Promise.all(
+    procEntries.map(async (entry) => {
+      if (!/^\d+$/.test(entry)) return;
+      if (!await processReferencesDir(entry, dirPath, dirName)) return;
+      try {
+        process.kill(parseInt(entry), "SIGKILL");
+      } catch {
+      }
+    })
+  );
+}
 var CLEANUP_DEADLINE_MS, CLEANUP_RETRY_MS;
 var init_cleanup_browser_dir = __esm({
   "lib/utils/cleanup-browser-dir.ts"() {
@@ -447,6 +447,18 @@ var init_html = __esm({
 });
 
 // lib/tap/dump-yaml.ts
+function dumpYaml({
+  name,
+  actual,
+  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) : "") + (source !== null ? yamlLine("source", source) : "") + (at !== null ? yamlLine("at", at) : "");
+}
 function needsQuoting(str) {
   return NEEDS_QUOTING.test(str);
 }
@@ -484,18 +496,6 @@ function yamlLine(key, value) {
 ` : `${key}: ${serialized}
 `;
 }
-function dumpYaml({
-  name,
-  actual,
-  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) : "") + (source !== null ? yamlLine("source", source) : "") + (at !== null ? yamlLine("at", at) : "");
-}
 var NEEDS_QUOTING;
 var init_dump_yaml = __esm({
   "lib/tap/dump-yaml.ts"() {
@@ -518,43 +518,35 @@ 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;
+  const result = [];
+  const cursor = { position: 0 };
+  const mappingsLength = mappings.length;
+  let segments = [];
+  let generatedCol = 0, sourceIndex = 0, sourceLine = 0, sourceCol = 0;
+  for (; ; ) {
+    if (cursor.position >= mappingsLength) break;
+    const charCode = mappings.charCodeAt(cursor.position);
+    if (charCode !== COMMA && charCode !== SEMICOLON) {
+      generatedCol += readVlqAt(mappings, cursor);
+      if (atFieldStart(mappings, cursor.position)) {
+        sourceIndex += readVlqAt(mappings, cursor);
+        sourceLine += readVlqAt(mappings, cursor);
+        sourceCol += readVlqAt(mappings, cursor);
+        segments.push({ generatedCol, sourceIndex, sourceLine, sourceCol });
+        if (atFieldStart(mappings, cursor.position)) readVlqAt(mappings, cursor);
       }
-      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;
-  });
+    } else if (charCode === COMMA) {
+      cursor.position++;
+    } else {
+      result.push(segments);
+      segments = [];
+      generatedCol = 0;
+      cursor.position++;
+    }
+  }
+  result.push(segments);
+  return result;
 }
 function parseSourceMap(json, outDir) {
   const map = JSON.parse(json);
@@ -566,151 +558,185 @@ function parseSourceMap(json, 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;
+  const base64Payload = readMarkerPayload(bundle);
+  if (!base64Payload) return null;
   try {
-    return parseSourceMap(base64DecodeUtf8(match[1]), outDir);
+    return parseSourceMap(decodeBase64Utf8(base64Payload), 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];
+  const targetCol = generatedCol - 1;
+  const segment = segments.findLast((s) => s.generatedCol <= targetCol);
+  if (!segment) return null;
+  const rawSource = decoder.sources[segment.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
+    line: segment.sourceLine + 1,
+    col: segment.sourceCol + 1,
+    sourceText: extractSourceLine(decoder.sourcesContent[segment.sourceIndex], segment.sourceLine)
   };
 }
-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 parseFrameLocation(text) {
+  const match = FRAME_LOCATION_RE.exec(text);
+  return match ? { url: match[1], line: +match[2], col: +match[3] } : null;
 }
 function isBundleUrl(url) {
-  const normalized = url.startsWith("async ") ? url.slice(6) : url;
-  return /^https?:\/\//.test(normalized) && /\/(tests|filtered-tests)\.js$/.test(normalized);
+  return BUNDLE_URL_RE.test(url);
+}
+function resolveFrame(frame, decoder, projectRoot) {
+  const hit = FRAME_FORMATS.map((format) => ({ format, match: frame.match(format.pattern) })).find(
+    ({ match }) => match !== null
+  );
+  if (!hit?.match) return null;
+  const original = tryResolve(hit.match[hit.format.urlGroup], decoder, projectRoot);
+  return original && {
+    resolved: hit.format.format(hit.match, original.display),
+    userPath: original.userPath,
+    sourceText: original.sourceText
+  };
+}
+function resolveStack(stack, decoder, projectRoot) {
+  const decoratedFrames = stack.split("\n").map((frame) => {
+    const resolution = resolveFrame(frame, decoder, projectRoot);
+    return {
+      line: resolution?.resolved ?? frame,
+      userPath: resolution?.userPath ?? null,
+      sourceText: resolution?.sourceText ?? null
+    };
+  });
+  const firstUser = decoratedFrames.find((entry) => entry.userPath !== null);
+  return {
+    resolvedStack: decoratedFrames.map((entry) => entry.line).join("\n"),
+    firstUserFrame: firstUser?.userPath ?? null,
+    firstUserSourceText: firstUser?.sourceText ?? null
+  };
+}
+function readVlqAt(text, cursor) {
+  let value = 0, bitShift = 0, position = cursor.position;
+  for (; ; ) {
+    const digit = BASE64_LOOKUP[text.charCodeAt(position++)];
+    value |= (digit & VLQ_DATA_MASK) << bitShift;
+    if (!(digit & VLQ_CONTINUATION)) break;
+    bitShift += 5;
+  }
+  cursor.position = position;
+  return value & 1 ? -(value >>> 1) : value >>> 1;
+}
+function atFieldStart(text, position) {
+  if (position >= text.length) return false;
+  const charCode = text.charCodeAt(position);
+  return charCode !== COMMA && charCode !== SEMICOLON;
+}
+function decodeBase64Utf8(base64) {
+  if (Buffer2) return Buffer2.from(base64, "base64").toString("utf8");
+  return UTF8_DECODER.decode(Uint8Array.from(atob(base64), (char) => char.charCodeAt(0)));
+}
+function readMarkerPayload(bundle) {
+  if (typeof bundle === "string") return sliceMarkerFromString(bundle);
+  if (Buffer2) return sliceMarkerFromBuffer(asBuffer(bundle, Buffer2));
+  return sliceMarkerFromString(UTF8_DECODER.decode(bundle));
+}
+function asBuffer(view, BufferCtor) {
+  return BufferCtor.isBuffer(view) ? view : BufferCtor.from(view.buffer, view.byteOffset, view.byteLength);
+}
+function sliceMarkerFromString(text) {
+  const markerStart = text.lastIndexOf(SOURCE_MAP_MARKER);
+  if (markerStart < 0) return null;
+  const payloadStart = markerStart + SOURCE_MAP_MARKER.length;
+  const payloadEnd = text.indexOf("\n", payloadStart);
+  return (payloadEnd < 0 ? text.slice(payloadStart) : text.slice(payloadStart, payloadEnd)).trim();
+}
+function sliceMarkerFromBuffer(buffer) {
+  const markerBytes = SOURCE_MAP_MARKER_BYTES;
+  const markerStart = buffer.lastIndexOf(markerBytes);
+  if (markerStart < 0) return null;
+  const payloadStart = markerStart + markerBytes.length;
+  const newlineIndex = buffer.indexOf(NEWLINE, payloadStart);
+  const payloadEnd = newlineIndex < 0 ? buffer.length : newlineIndex;
+  return buffer.toString("latin1", payloadStart, payloadEnd).trim();
+}
+function extractSourceLine(content, lineIndex) {
+  if (!content || lineIndex < 0) return null;
+  const line = content.split("\n", lineIndex + 1)[lineIndex];
+  return line?.trim() || null;
+}
+function normalizePosix(path10) {
+  const parts = path10.split("/").reduce((acc, part) => {
+    if (part === "..") acc.pop();
+    else if (part && part !== ".") acc.push(part);
+    return acc;
+  }, []);
+  return (path10.startsWith("/") ? "/" : "") + parts.join("/");
+}
+function toAbsolutePath(rawSource, outDir, sourceRoot) {
+  if (rawSource.startsWith("file://")) return rawSource.slice(7);
+  if (rawSource.startsWith("/")) return rawSource;
+  const base = sourceRoot ? normalizePosix(`${outDir}/${sourceRoot}`) : outDir;
+  return normalizePosix(`${base}/${rawSource}`);
 }
-function isNodeModulesPath(absolutePath) {
-  return absolutePath.includes("/node_modules/") || absolutePath.includes("\\node_modules\\");
+function isNodeModulesPath(path10) {
+  return path10.includes("/node_modules/") || path10.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}`;
+  const location = parseFrameLocation(urlLineCol);
+  if (!location || !isBundleUrl(location.url)) return null;
+  const original = lookupPosition(decoder, location.line, location.col);
+  if (!original) return null;
+  const display = `${makeDisplayPath(original.absolutePath, projectRoot)}:${original.line}:${original.col}`;
   return {
     display,
-    userPath: isNodeModulesPath(orig.absolutePath) ? null : display,
-    sourceText: orig.sourceText
+    userPath: isNodeModulesPath(original.absolutePath) ? null : display,
+    sourceText: original.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 BASE64_ALPHABET, BASE64_LOOKUP, COMMA, SEMICOLON, NEWLINE, VLQ_CONTINUATION, VLQ_DATA_MASK, SOURCE_MAP_MARKER, FRAME_LOCATION_RE, BUNDLE_URL_RE, FRAME_FORMATS, Buffer2, SOURCE_MAP_MARKER_BYTES, UTF8_DECODER;
 var init_source_map_decoder = __esm({
   "lib/utils/source-map-decoder.ts"() {
-    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     BASE64_LOOKUP = new Uint8Array(128);
-    [...BASE64].forEach((ch, i) => {
-      BASE64_LOOKUP[ch.charCodeAt(0)] = i;
-    });
-    UTF8 = new TextDecoder();
+    [...BASE64_ALPHABET].forEach((char, index) => BASE64_LOOKUP[char.charCodeAt(0)] = index);
+    COMMA = 44;
+    SEMICOLON = 59;
+    NEWLINE = 10;
+    VLQ_CONTINUATION = 32;
+    VLQ_DATA_MASK = 31;
+    SOURCE_MAP_MARKER = "//# sourceMappingURL=data:application/json;base64,";
+    FRAME_LOCATION_RE = /^(.+):(\d+):(\d+)$/;
+    BUNDLE_URL_RE = /^(?:async )?https?:\/\/.*\/(?:tests|filtered-tests)\.js$/;
+    FRAME_FORMATS = [
+      // Chrome named: "    at FUNC (URL:LINE:COL)"
+      {
+        pattern: /^(\s*at\s+)(.*?)\s+\(([^)]+)\)\s*$/,
+        urlGroup: 3,
+        format: (match, displayPath) => `${match[1]}${match[2]} (${displayPath})`
+      },
+      // Chrome anonymous (incl. async): "    at [async] URL:LINE:COL"
+      {
+        pattern: /^(\s*at\s+(?:async\s+)?)(.+)/,
+        urlGroup: 2,
+        format: (match, displayPath) => `${match[1]}${displayPath}`
+      },
+      // Firefox / WebKit: "FUNC@URL:LINE:COL"
+      {
+        pattern: /^([^@]*)@(.+)$/,
+        urlGroup: 2,
+        format: (match, displayPath) => `${match[1]}@${displayPath}`
+      }
+    ];
+    Buffer2 = globalThis.Buffer;
+    SOURCE_MAP_MARKER_BYTES = Buffer2 ? Buffer2.from(SOURCE_MAP_MARKER, "utf8") : null;
+    UTF8_DECODER = new TextDecoder();
   }
 });
 
@@ -836,12 +862,12 @@ var init_bind_server_to_port = __esm({
   }
 });
 
-// lib/servers/http.ts
+// lib/servers/web.ts
 import http from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
 var MIME_TYPES, HTTPServer;
-var init_http = __esm({
-  "lib/servers/http.ts"() {
+var init_web = __esm({
+  "lib/servers/web.ts"() {
     init_bind_server_to_port();
     MIME_TYPES = {
       html: "text/html; charset=UTF-8",
@@ -1298,166 +1324,18 @@ function setupWebServer(config, cachedContent) {
   });
   return server;
 }
-function replaceAssetPaths(html, htmlPath, projectRoot) {
-  const assetPaths = findInternalAssetsFromHTML(html);
-  const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
-  return assetPaths.reduce((result, assetPath) => {
-    const normalizedFullAbsolutePath = path5.normalize(`${htmlDirectory}/${assetPath}`);
-    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
-  }, html);
-}
-function testRuntimeToInject(config, groupId) {
-  const groupIdPart = groupId !== void 0 ? `, groupId: ${groupId}` : "";
-  return `<script>
-    (function() {
-      // setupQUnit runs exactly once, after both the WebSocket is open and tests.js has loaded.
-      // Promise.all is naturally idempotent \u2014 resolving a Promise a second time is a no-op,
-      // so WebKit firing WS error after open (causing a retry that re-opens) cannot double-start.
-      let resolveWsReady = () => {};
-      const wsReadyPromise = window.location.protocol === 'file:'
-        ? Promise.resolve()
-        : new Promise(resolve => { resolveWsReady = resolve; });
-
-      // { once: true } auto-removes the listener after the first fire.
-      const testsReadyPromise = new Promise(resolve => {
-        window.addEventListener('qunitx:tests-ready', resolve, { once: true });
-      });
-
-      Promise.all([wsReadyPromise, testsReadyPromise]).then(setupQUnit);
-
-      // For static files (file:// protocol) there is no WebSocket server; wsReadyPromise
-      // is already resolved above, so setupQUnit fires as soon as tests load.
-      if (window.location.protocol === 'file:') return;
-
-      let wsRetryCount = 0;
-      const WS_MAX_RETRIES = Math.ceil(${config.timeout} / ${WS_RETRY_INTERVAL_MS}); // retry for the full test timeout window
-
-      function setupWebSocket() {
-        try {
-          window.socket = new WebSocket(\`ws://localhost:\${location.port}\`);
-        } catch (error) {
-          console.log(error);
-          retryOrFail();
-          return;
-        }
-
-        window.socket.addEventListener('open', function() {
-          resolveWsReady();
-          // 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 (navigator.webdriver) {
-            window.socket.send(JSON.stringify({ event: 'wsOpen'${groupIdPart} }));
-          }
-        });
-        window.socket.addEventListener('error', function() {
-          retryOrFail();
-        });
-        window.socket.addEventListener('message', function(messageEvent) {
-          if (!navigator.webdriver && messageEvent.data === 'refresh') {
-            window.location.reload(true);
-          } else if (navigator.webdriver && messageEvent.data === 'abort') {
-            window.abortQUnit = true;
-            window.QUnit.config.queue.length = 0;
-            window.socket.send(JSON.stringify({ event: 'abort' }));
-          }
-        });
-      }
-
-      function retryOrFail() {
-        wsRetryCount++;
-        if (wsRetryCount > WS_MAX_RETRIES) {
-          console.log('WebSocket connection failed after ' + WS_MAX_RETRIES + ' retries');
-          return;
-        }
-        window.setTimeout(setupWebSocket, ${WS_RETRY_INTERVAL_MS});
-      }
-
-      setupWebSocket();
-    })();
-
-    function getCircularReplacer() {
-      const ancestors = [];
-      return function (key, value) {
-        if (typeof value !== "object" || value === null) {
-          return value;
-        }
-        while (ancestors.length > 0 && ancestors.at(-1) !== this) {
-          ancestors.pop();
-        }
-        if (ancestors.includes(value)) {
-          return "[Circular]";
-        }
-        ancestors.push(value);
-        return value;
-      };
-    }
-
-    function setupQUnit() {
-      window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, failedTests: 0, currentTest: '' };
-
-      if (!window.QUnit) {
-        console.log('QUnit not found after WebSocket connected');
-        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.
-          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 } }));
-        }
-        return;
-      }
-
-      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
-        if (navigator.webdriver) {
-          window.socket.send(JSON.stringify({ event: 'connection' }));
-        }
-      });
-      window.QUnit.on('testStart', (details) => {
-        window.QUNIT_RESULT.totalTests++;
-        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.QUNIT_RESULT.finishedTests++;
-        if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
-        window.QUNIT_RESULT.currentTest = null;
-        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;
-          }
-        }
-      });
-      window.QUnit.done((details) => {
-        if (navigator.webdriver) {
-          window.socket.send(JSON.stringify({ event: 'done', details: details, qunitResult: window.QUNIT_RESULT, abort: window.abortQUnit }, getCircularReplacer()));
-        }
-      });
-
-      window.QUnit.config.testTimeout = ${config.timeout};
-      window.QUnit.start();
-    }
-  </script>`;
-}
-function escapeAndInjectTestsToHTML(html, testRuntimeCode, testBundleUrl) {
-  return injectScript(html, `${testRuntimeCode}
-<script src="${testBundleUrl}" async></script>`);
-}
-function buildNoTestsHTML(files) {
-  const escaped = files.map((f) => f.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("\n");
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width">
-  <title>No Tests Registered \u2014 qunitx</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-tests, #qunit-tests li {
-      font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+function buildNoTestsHTML(files) {
+  const escaped = files.map((f) => f.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <title>No Tests Registered \u2014 qunitx</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-tests, #qunit-tests li {
+      font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
     }
     #qunit-header {
       padding: 0.5em 0 0.5em 1em;
@@ -1700,16 +1578,6 @@ function registerGroupRoutes(server, groupConfig, groupCachedContent, groupId) {
     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) {
@@ -1790,6 +1658,164 @@ function registerSharedStaticHandler(server, groupConfigs) {
     });
   });
 }
+function replaceAssetPaths(html, htmlPath, projectRoot) {
+  const assetPaths = findInternalAssetsFromHTML(html);
+  const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
+  return assetPaths.reduce((result, assetPath) => {
+    const normalizedFullAbsolutePath = path5.normalize(`${htmlDirectory}/${assetPath}`);
+    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
+  }, html);
+}
+function testRuntimeToInject(config, groupId) {
+  const groupIdPart = groupId !== void 0 ? `, groupId: ${groupId}` : "";
+  return `<script>
+    (function() {
+      // setupQUnit runs exactly once, after both the WebSocket is open and tests.js has loaded.
+      // Promise.all is naturally idempotent \u2014 resolving a Promise a second time is a no-op,
+      // so WebKit firing WS error after open (causing a retry that re-opens) cannot double-start.
+      let resolveWsReady = () => {};
+      const wsReadyPromise = window.location.protocol === 'file:'
+        ? Promise.resolve()
+        : new Promise(resolve => { resolveWsReady = resolve; });
+
+      // { once: true } auto-removes the listener after the first fire.
+      const testsReadyPromise = new Promise(resolve => {
+        window.addEventListener('qunitx:tests-ready', resolve, { once: true });
+      });
+
+      Promise.all([wsReadyPromise, testsReadyPromise]).then(setupQUnit);
+
+      // For static files (file:// protocol) there is no WebSocket server; wsReadyPromise
+      // is already resolved above, so setupQUnit fires as soon as tests load.
+      if (window.location.protocol === 'file:') return;
+
+      let wsRetryCount = 0;
+      const WS_MAX_RETRIES = Math.ceil(${config.timeout} / ${WS_RETRY_INTERVAL_MS}); // retry for the full test timeout window
+
+      function setupWebSocket() {
+        try {
+          window.socket = new WebSocket(\`ws://localhost:\${location.port}\`);
+        } catch (error) {
+          console.log(error);
+          retryOrFail();
+          return;
+        }
+
+        window.socket.addEventListener('open', function() {
+          resolveWsReady();
+          // 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 (navigator.webdriver) {
+            window.socket.send(JSON.stringify({ event: 'wsOpen'${groupIdPart} }));
+          }
+        });
+        window.socket.addEventListener('error', function() {
+          retryOrFail();
+        });
+        window.socket.addEventListener('message', function(messageEvent) {
+          if (!navigator.webdriver && messageEvent.data === 'refresh') {
+            window.location.reload(true);
+          } else if (navigator.webdriver && messageEvent.data === 'abort') {
+            window.abortQUnit = true;
+            window.QUnit.config.queue.length = 0;
+            window.socket.send(JSON.stringify({ event: 'abort' }));
+          }
+        });
+      }
+
+      function retryOrFail() {
+        wsRetryCount++;
+        if (wsRetryCount > WS_MAX_RETRIES) {
+          console.log('WebSocket connection failed after ' + WS_MAX_RETRIES + ' retries');
+          return;
+        }
+        window.setTimeout(setupWebSocket, ${WS_RETRY_INTERVAL_MS});
+      }
+
+      setupWebSocket();
+    })();
+
+    function getCircularReplacer() {
+      const ancestors = [];
+      return function (key, value) {
+        if (typeof value !== "object" || value === null) {
+          return value;
+        }
+        while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+          ancestors.pop();
+        }
+        if (ancestors.includes(value)) {
+          return "[Circular]";
+        }
+        ancestors.push(value);
+        return value;
+      };
+    }
+
+    function setupQUnit() {
+      window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, failedTests: 0, currentTest: '' };
+
+      if (!window.QUnit) {
+        console.log('QUnit not found after WebSocket connected');
+        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.
+          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 } }));
+        }
+        return;
+      }
+
+      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
+        if (navigator.webdriver) {
+          window.socket.send(JSON.stringify({ event: 'connection' }));
+        }
+      });
+      window.QUnit.on('testStart', (details) => {
+        window.QUNIT_RESULT.totalTests++;
+        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.QUNIT_RESULT.finishedTests++;
+        if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
+        window.QUNIT_RESULT.currentTest = null;
+        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;
+          }
+        }
+      });
+      window.QUnit.done((details) => {
+        if (navigator.webdriver) {
+          window.socket.send(JSON.stringify({ event: 'done', details: details, qunitResult: window.QUNIT_RESULT, abort: window.abortQUnit }, getCircularReplacer()));
+        }
+      });
+
+      window.QUnit.config.testTimeout = ${config.timeout};
+      window.QUnit.start();
+    }
+  </script>`;
+}
+function escapeAndInjectTestsToHTML(html, testRuntimeCode, testBundleUrl) {
+  return injectScript(html, `${testRuntimeCode}
+<script src="${testBundleUrl}" async></script>`);
+}
+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`)}
+`
+  );
+}
 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"() {
@@ -1797,7 +1823,7 @@ var init_web_server = __esm({
     init_html();
     init_display_test_result();
     init_color();
-    init_http();
+    init_web();
     fsPromise = fs8.promises;
     HTML_HEADERS = { "Content-Type": "text/html", "Cache-Control": "no-store" };
     WATCH_WS_RECONNECT_INTERVAL_MS = 1e3;
@@ -2058,12 +2084,6 @@ var init_display_final_result = __esm({
 import fs9 from "node:fs/promises";
 import path7 from "node:path";
 import esbuild from "esbuild";
-function toEsbuildImportPath(filePath) {
-  const rel = path7.relative(process.cwd(), filePath);
-  const normalized = rel.replace(/\\/g, "/");
-  if (path7.isAbsolute(rel)) return filePath.replace(/\\/g, "/");
-  return normalized.startsWith(".") ? normalized : "./" + normalized;
-}
 function deriveBuildErrorType(error) {
   const msgs = error?.errors ?? [];
   const text = msgs[0]?.text ?? (error instanceof Error ? error.message : String(error));
@@ -2264,7 +2284,130 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
       throw exception;
     }
   }
-  return connections;
+  return connections;
+}
+async function flushConsoleHandlers(handlers, deadline = Date.now() + CONSOLE_FLUSH_TIMEOUT_MS) {
+  if (!handlers || Date.now() >= deadline) return;
+  await new Promise((resolve) => setImmediate(resolve));
+  if (handlers.size === 0) return;
+  await Promise.allSettled([...handlers]);
+  return flushConsoleHandlers(handlers, deadline);
+}
+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(path7.resolve(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 "${toEsbuildImportPath(filePath)}";`).join(""),
+          resolveDir: process.cwd()
+        };
+      });
+    }
+  };
+  const esbuildOutdir = path7.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 = path7.join(
+          path7.resolve(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(
+          path7.join(path7.resolve(group.config.projectRoot, group.config.output), "index.html"),
+          errorHtml
+        ).catch(
+          (err) => debug && process.stderr.write(`# [qunitx] writeFile index.html: ${err.message}
+`)
+        );
+      })
+    );
+    throw error;
+  }
 }
 function buildFilteredTests(filteredTests, outputPath, config) {
   const sourcemap = "inline";
@@ -2342,7 +2485,7 @@ 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 + NAV_GRACE_MS;
+    const navMs = Math.max(config.timeout + NAV_GRACE_MS, MIN_NAV_MS);
     const startupMs = Math.max(config.timeout * STARTUP_TIMEOUT_FACTOR, navMs);
     const testsJsMs = Math.max(config.timeout * TESTS_JS_TIMEOUT_FACTOR, navMs);
     let resolveTestRace;
@@ -2432,128 +2575,13 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
     process.exit(1);
   }
 }
-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);
-}
-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(path7.resolve(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 "${toEsbuildImportPath(filePath)}";`).join(""),
-          resolveDir: process.cwd()
-        };
-      });
-    }
-  };
-  const esbuildOutdir = path7.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 = path7.join(
-          path7.resolve(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(
-          path7.join(path7.resolve(group.config.projectRoot, group.config.output), "index.html"),
-          errorHtml
-        ).catch(
-          (err) => debug && process.stderr.write(`# [qunitx] writeFile index.html: ${err.message}
-`)
-        );
-      })
-    );
-    throw error;
-  }
+function toEsbuildImportPath(filePath) {
+  const rel = path7.relative(process.cwd(), filePath);
+  const normalized = rel.replace(/\\/g, "/");
+  if (path7.isAbsolute(rel)) return filePath.replace(/\\/g, "/");
+  return normalized.startsWith(".") ? normalized : "./" + normalized;
 }
-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 ancestorNodeModules, ANCESTOR_NODE_MODULES, RETRY_DELAY_MS, MAX_RETRIES, EMPTY_BUNDLE_THRESHOLD, NAV_GRACE_MS, MIN_NAV_MS, STARTUP_TIMEOUT_FACTOR, TESTS_JS_TIMEOUT_FACTOR, CONSOLE_FLUSH_TIMEOUT_MS, TEST_STALL_BUFFER_MS, GROUP_OUTPUT_REGEX, BundleError;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -2563,13 +2591,6 @@ var init_tests_in_browser = __esm({
     init_display_final_result();
     init_web_server();
     init_source_map_decoder();
-    BundleError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "BundleError";
-        this.message = `esbuild Bundle Error: ${message}`.split("\n").join("\n# ");
-      }
-    };
     ancestorNodeModules = (dir) => dir.split(path7.sep).map(
       (_, i, parts) => path7.join(parts.slice(0, parts.length - i).join(path7.sep) || path7.sep, "node_modules")
     );
@@ -2578,11 +2599,19 @@ var init_tests_in_browser = __esm({
     MAX_RETRIES = 3;
     EMPTY_BUNDLE_THRESHOLD = 500;
     NAV_GRACE_MS = 1e4;
+    MIN_NAV_MS = 3e4;
     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)?$/;
+    BundleError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "BundleError";
+        this.message = `esbuild Bundle Error: ${message}`.split("\n").join("\n# ");
+      }
+    };
   }
 });
 
@@ -2594,6 +2623,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
   const extensions = config.extensions || ["js", "ts"];
   const readyPromises = [];
   const parentWatchers = [];
+  const rescanTimers = [];
   const fileWatchers = {};
   const symlinkPollers = /* @__PURE__ */ new Map();
   function trackSymlink(filePath) {
@@ -2620,20 +2650,24 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
   }
   for (const watchPath of testFileLookupPaths) {
     let ready = false;
+    let rescanInProgress = false;
     const lastEventMs = {};
     const seenMtimeMs = {};
     const childWatcher = fs10.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready) return;
       if (!filename) {
-        if (process.platform === "darwin") {
-          await rescanDirectoryForDelta(
+        if (process.platform === "darwin" && !rescanInProgress) {
+          rescanInProgress = true;
+          rescanDirectoryForDelta(
             watchPath,
             config,
             extensions,
             onEventFunc,
             onFinishFunc,
             trackSymlink
-          );
+          ).finally(() => {
+            rescanInProgress = false;
+          });
         }
         return;
       }
@@ -2693,6 +2727,24 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         })
       )
     );
+    if (process.platform === "darwin") {
+      rescanTimers.push(
+        setInterval(() => {
+          if (!ready || rescanInProgress) return;
+          rescanInProgress = true;
+          rescanDirectoryForDelta(
+            watchPath,
+            config,
+            extensions,
+            onEventFunc,
+            onFinishFunc,
+            trackSymlink
+          ).finally(() => {
+            rescanInProgress = false;
+          });
+        }, RESCAN_INTERVAL_MS).unref()
+      );
+    }
   }
   readyPromises.push(
     (async () => {
@@ -2712,28 +2764,13 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     killFileWatchers() {
       Object.keys(fileWatchers).forEach((key) => fileWatchers[key].close());
       parentWatchers.forEach((pw) => pw.close());
+      rescanTimers.forEach((t) => clearInterval(t));
       symlinkPollers.forEach((cancel) => cancel());
       symlinkPollers.clear();
       return fileWatchers;
     }
   };
 }
-async function classifyRenameEvent(fullPath, fsTree) {
-  for (const delay of [0, OVERLAYFS_RENAME_RETRY_MS]) {
-    if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
-    try {
-      const statResult = await stat(fullPath);
-      if (statResult.isDirectory()) return "addDir";
-      return fsTree && fullPath in fsTree ? "change" : "add";
-    } catch {
-    }
-  }
-  if (!fsTree) return null;
-  if (fullPath in fsTree) return "unlink";
-  return Object.keys(fsTree).some(
-    (trackedPath) => trackedPath.startsWith(fullPath + "/") || trackedPath.startsWith(fullPath + "\\")
-  ) ? "unlinkDir" : null;
-}
 function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc) {
   if (event !== "unlinkDir" && !extensions.some((ext) => filePath.endsWith(`.${ext}`)))
     return Promise.resolve();
@@ -2776,9 +2813,16 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
   try {
     const entries = await readdir(watchPath, { withFileTypes: true, recursive: true });
     const presentPaths = /* @__PURE__ */ new Set();
+    const presentDirs = /* @__PURE__ */ new Set();
+    presentDirs.add(watchPath);
     for (const entry of entries) {
+      if (entry.isDirectory()) {
+        presentDirs.add(path8.join(entry.parentPath, entry.name));
+        continue;
+      }
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
       const entryPath = path8.join(entry.parentPath, entry.name);
+      presentDirs.add(entry.parentPath);
       if (!extensions.some((ext) => entryPath.endsWith(`.${ext}`))) continue;
       presentPaths.add(entryPath);
       if (!(entryPath in config.fsTree)) {
@@ -2787,9 +2831,18 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
       }
     }
     const watchPrefix = watchPath + path8.sep;
+    const firedDirPrefixes = [];
     for (const trackedPath of Object.keys(config.fsTree)) {
-      if (trackedPath.startsWith(watchPrefix) && !presentPaths.has(trackedPath))
+      if (!trackedPath.startsWith(watchPrefix) || presentPaths.has(trackedPath)) continue;
+      if (firedDirPrefixes.some((p) => trackedPath.startsWith(p + path8.sep))) continue;
+      const parts = trackedPath.slice(watchPrefix.length).split(path8.sep);
+      const goneDirPath = parts.slice(0, -1).map((_, i) => watchPrefix + parts.slice(0, i + 1).join(path8.sep)).find((p) => !presentDirs.has(p)) ?? null;
+      if (goneDirPath !== null) {
+        firedDirPrefixes.push(goneDirPath);
+        handleWatchEvent(config, extensions, "unlinkDir", goneDirPath, onEventFunc, onFinishFunc);
+      } else {
         handleWatchEvent(config, extensions, "unlink", trackedPath, onEventFunc, onFinishFunc);
+      }
     }
   } catch {
   }
@@ -2806,18 +2859,35 @@ function mutateFSTree(fsTree, event, filePath) {
     }
   }
 }
+async function classifyRenameEvent(fullPath, fsTree) {
+  for (const delay of [0, OVERLAYFS_RENAME_RETRY_MS]) {
+    if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
+    try {
+      const statResult = await stat(fullPath);
+      if (statResult.isDirectory()) return "addDir";
+      return fsTree && fullPath in fsTree ? "change" : "add";
+    } catch {
+    }
+  }
+  if (!fsTree) return null;
+  if (fullPath in fsTree) return "unlink";
+  return Object.keys(fsTree).some(
+    (trackedPath) => trackedPath.startsWith(fullPath + "/") || trackedPath.startsWith(fullPath + "\\")
+  ) ? "unlinkDir" : null;
+}
 function colorEvent(event) {
   if (event === "change") return yellow("CHANGED:");
   if (event === "add" || event === "addDir") return green("ADDED:");
   return red("REMOVED:");
 }
-var CHANGE_DEDUPE_MS, SYMLINK_POLL_INTERVAL_MS, OVERLAYFS_RENAME_RETRY_MS;
+var CHANGE_DEDUPE_MS, SYMLINK_POLL_INTERVAL_MS, OVERLAYFS_RENAME_RETRY_MS, RESCAN_INTERVAL_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;
+    RESCAN_INTERVAL_MS = 1e3;
   }
 });
 
@@ -3304,7 +3374,7 @@ var init_run = __esm({
   "lib/commands/run.ts"() {
     init_browser();
     init_chrome_prelaunch();
-    init_http();
+    init_web();
     init_bind_server_to_port();
     init_web_server();
     init_open_output_in_browser();
@@ -3338,7 +3408,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.21.2",
+  version: "0.21.3",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -3565,12 +3635,6 @@ function convertToPascalCase(str) {
 }
 
 // lib/commands/generate.ts
-function pathToModuleName(filePath) {
-  const withoutExt = filePath.replace(/\.(js|ts)$/, "");
-  const segments = withoutExt.split("/");
-  const targetNames = segments[0] === "test" || segments[0] === "tests" ? segments.slice(1) : segments;
-  return targetNames.map(convertToPascalCase).join(" | ");
-}
 async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
   const moduleName = pathToModuleName(process.argv[3]);
@@ -3586,6 +3650,12 @@ async function generateTestFiles() {
   await fs5.writeFile(path10, testJSContent.replace("{{moduleName}}", moduleName));
   console.log(green(`${path10} written`));
 }
+function pathToModuleName(filePath) {
+  const withoutExt = filePath.replace(/\.(js|ts)$/, "");
+  const segments = withoutExt.split("/");
+  const targetNames = segments[0] === "test" || segments[0] === "tests" ? segments.slice(1) : segments;
+  return targetNames.map(convertToPascalCase).join(" | ");
+}
 
 // lib/setup/config.ts
 import fs7 from "node:fs/promises";
@@ -3593,28 +3663,6 @@ import fs7 from "node:fs/promises";
 // lib/setup/fs-tree.ts
 import fs6, { glob as fsGlob } from "node:fs/promises";
 import path3 from "node:path";
-function isGlob(str) {
-  return /[*?{[]/.test(str);
-}
-async function readDirRecursive(dir, filter) {
-  const entries = await fs6.readdir(dir, { recursive: true, withFileTypes: true });
-  const candidates = entries.filter(
-    (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
-  );
-  const resolvedPaths = await Promise.all(
-    candidates.map(async (dirent) => {
-      const fullPath = path3.join(dirent.parentPath, dirent.name);
-      if (dirent.isFile()) return fullPath;
-      try {
-        const statResult = await fs6.stat(fullPath);
-        return statResult.isFile() ? fullPath : null;
-      } catch {
-        return null;
-      }
-    })
-  );
-  return resolvedPaths.filter((resolvedPath) => resolvedPath !== null);
-}
 async function buildFSTree(fileAbsolutePaths, config = {}) {
   const targetExtensions = config.extensions || ["js", "ts"];
   const fsTree = {};
@@ -3648,57 +3696,65 @@ async function buildFSTree(fileAbsolutePaths, config = {}) {
   );
   return fsTree;
 }
-
-// lib/setup/test-file-paths.ts
-import { matchesGlob } from "node:path";
-function isGlob2(str) {
+function isGlob(str) {
   return /[*?{[]/.test(str);
 }
-function setupTestFilePaths(_projectRoot, inputs2) {
-  const [folders, filesWithGlob, filesWithoutGlob] = inputs2.reduce(
-    (result2, input) => {
-      const glob = isGlob2(input);
-      if (!pathIsFile(input)) {
-        result2[0].push({ input, isFile: false, isGlob: glob });
-      } else {
-        result2[glob ? 1 : 2].push({ input, isFile: true, isGlob: glob });
+async function readDirRecursive(dir, filter) {
+  const entries = await fs6.readdir(dir, { recursive: true, withFileTypes: true });
+  const candidates = entries.filter(
+    (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
+  );
+  const resolvedPaths = await Promise.all(
+    candidates.map(async (dirent) => {
+      const fullPath = path3.join(dirent.parentPath, dirent.name);
+      if (dirent.isFile()) return fullPath;
+      try {
+        const statResult = await fs6.stat(fullPath);
+        return statResult.isFile() ? fullPath : null;
+      } catch {
+        return null;
       }
-      return result2;
-    },
-    [[], [], []]
+    })
   );
-  const result = folders.reduce((folderResult, folder) => {
-    if (!pathIsIncludedInPaths(folders, folder)) {
-      folderResult.push(folder);
-    }
-    return folderResult;
-  }, []);
-  filesWithGlob.forEach((file) => {
-    if (!pathIsIncludedInPaths(result, file) && !pathIsIncludedInPaths(filesWithGlob, file)) {
-      result.push(file);
+  return resolvedPaths.filter((resolvedPath) => resolvedPath !== null);
+}
+
+// lib/setup/test-file-paths.ts
+import { matchesGlob } from "node:path";
+var GLOB_CHARS = /[*?{[]/;
+function setupTestFilePaths(inputs2) {
+  const folders = [];
+  const filesWithGlob = [];
+  const filesWithoutGlob = [];
+  inputs2.forEach((input) => {
+    if (!pathIsFile(input)) {
+      folders.push({ input, globFormat: `${input}/**` });
+    } else if (isGlob2(input)) {
+      filesWithGlob.push({ input, globFormat: input });
+    } else {
+      filesWithoutGlob.push({ input, globFormat: input });
     }
   });
-  filesWithoutGlob.forEach((file) => {
-    if (!pathIsIncludedInPaths(result, file)) {
-      result.push(file);
+  const dedupedFolders = folders.filter((folder) => !isIncludedIn(folders, folder));
+  const dedupedGlobFiles = filesWithGlob.filter(
+    (file) => !isIncludedIn(dedupedFolders, file) && !isIncludedIn(filesWithGlob, file)
+  );
+  const dedupedPlainFiles = filesWithoutGlob.reduce((acc, file) => {
+    if (!isIncludedIn(dedupedFolders, file) && !isIncludedIn(dedupedGlobFiles, file) && !isIncludedIn(acc, file)) {
+      acc.push(file);
     }
-  });
-  return result.map((metaItem) => metaItem.input);
+    return acc;
+  }, []);
+  return dedupedFolders.concat(dedupedGlobFiles, dedupedPlainFiles).map((meta) => meta.input);
 }
 function pathIsFile(path10) {
-  const inputs2 = path10.split("/");
-  return inputs2[inputs2.length - 1].includes(".");
+  return path10.includes(".", path10.lastIndexOf("/") + 1);
 }
-function pathIsIncludedInPaths(paths, targetPath) {
-  return paths.some((path10) => {
-    if (path10 === targetPath) {
-      return false;
-    }
-    return matchesGlob(targetPath.input, buildGlobFormat(path10));
-  });
+function isIncludedIn(paths, target) {
+  return paths.some((path10) => path10 !== target && matchesGlob(target.input, path10.globFormat));
 }
-function buildGlobFormat(path10) {
-  return path10.isFile ? path10.input : `${path10.input}/**`;
+function isGlob2(str) {
+  return GLOB_CHARS.test(str);
 }
 
 // lib/utils/parse-cli-flags.ts
@@ -3801,7 +3857,7 @@ async function setupConfig() {
     ...cliConfigFlags,
     projectRoot,
     inputs: inputs2,
-    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs2),
+    testFileLookupPaths: setupTestFilePaths(inputs2),
     lastFailedTestFiles: null,
     lastRanTestFiles: null,
     COUNTER: {