qunitx-cli 0.11.0 → 0.16.0

package/README.md

@@ -188,6 +188,13 @@ All CLI flags can also be set in `package.json` under the `qunitx` key, so you d
 
 CLI flags always override `package.json` values when both are present.
 
+### Environment variables
+
+| Variable         | Description                                                                                                   |
+|------------------|---------------------------------------------------------------------------------------------------------------|
+| `CHROME_BIN`     | Path to the Chrome/Chromium executable. Required on systems where Chrome is not on `PATH` (e.g. many CI environments). Set automatically when using `browser-actions/setup-chrome` in GitHub Actions. |
+| `QUNITX_BROWSER` | Browser engine to use (`chromium`, `firefox`, `webkit`). Equivalent to `--browser` on the CLI. Useful in CI matrix jobs. |
+
 If you do not provide any HTML template, qunitx falls back to its built-in `test/tests.html` boilerplate internally, so `qunitx init` is optional.
 
 You can also pass a custom HTML file on the CLI:

package/dist/cli.js

@@ -39,26 +39,57 @@ var init_find_chrome = __esm({
 
 // lib/utils/pre-launch-chrome.ts
 import { spawn } from "node:child_process";
-function preLaunchChrome(chromePath, args, headless = true) {
-  if (!chromePath) return Promise.resolve(null);
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+async function preLaunchChrome(chromePath, args, headless = true) {
+  if (!chromePath) return null;
+  const userDataDir = await mkdtemp(path.join(os.tmpdir(), "qunitx-chrome-"));
+  const cleanup = () => rm(userDataDir, { recursive: true, force: true }).catch(() => {
+  });
   const headlessArgs = headless ? ["--headless=new"] : [];
+  const proc = spawn(
+    chromePath,
+    ["--remote-debugging-port=0", `--user-data-dir=${userDataDir}`, ...headlessArgs, ...args],
+    { stdio: ["ignore", "ignore", "pipe"] }
+  );
+  proc.on("close", () => {
+    cleanup();
+    resolveWith(null);
+  });
+  proc.on("error", () => resolveWith(null));
+  let resolveWith;
   return new Promise((resolve) => {
-    const proc = spawn(chromePath, ["--remote-debugging-port=0", ...headlessArgs, ...args], {
-      stdio: ["ignore", "ignore", "pipe"]
-    });
+    resolveWith = resolve;
     let buffer = "";
     proc.stderr.on("data", (chunk) => {
       buffer += chunk.toString();
       const match = buffer.match(CDP_URL_REGEX);
-      if (match) {
-        proc.unref();
-        proc.stderr.unref();
-        resolve({ proc, cdpEndpoint: match[1] });
-      }
+      if (!match) return;
+      proc.unref();
+      proc.stderr.unref();
+      resolve({
+        proc,
+        cdpEndpoint: match[1],
+        shutdown
+      });
     });
-    proc.on("error", () => resolve(null));
-    proc.on("close", () => resolve(null));
   });
+  async function shutdown() {
+    proc.ref();
+    const closed = new Promise((resolve) => {
+      if (proc.exitCode !== null) {
+        resolve();
+        return;
+      }
+      proc.once("close", resolve);
+    });
+    try {
+      if (proc.exitCode === null) proc.kill("SIGKILL");
+    } catch {
+    }
+    await closed.then(() => cleanup());
+  }
 }
 var CDP_URL_REGEX;
 var init_pre_launch_chrome = __esm({
@@ -72,21 +103,73 @@ var chromium_args_default;
 var init_chromium_args = __esm({
   "lib/utils/chromium-args.ts"() {
     chromium_args_default = [
+      // ── Sandbox / rendering ──────────────────────────────────────────────────────
       "--no-sandbox",
+      // required in most CI/container environments
       "--disable-gpu",
+      // no GPU in headless; avoids GPU process startup
+      // ── Window / UI ──────────────────────────────────────────────────────────────
       "--window-size=1440,900",
-      "--disable-extensions",
-      "--disable-sync",
+      "--hide-scrollbars",
+      // no scrollbar rendering overhead
+      // ── Automation markers ────────────────────────────────────────────────────────
+      "--enable-automation",
+      // sets navigator.webdriver=true; disables some UX-only overhead
+      "--no-default-browser-check",
+      // skip the OS-level "set as default" check on startup
       "--no-first-run",
-      "--disable-default-apps",
-      "--mute-audio",
+      // skip first-run wizard
+      // ── Network ───────────────────────────────────────────────────────────────────
       "--disable-background-networking",
+      "--disable-sync",
+      "--disable-translate",
+      // ── Extensions / apps ─────────────────────────────────────────────────────────
+      "--disable-extensions",
+      "--disable-default-apps",
+      "--disable-component-update",
+      // no background update checks
+      "--disable-field-trial-config",
+      // no A/B experiment config fetches at startup
+      // ── Crash / diagnostics ───────────────────────────────────────────────────────
+      "--disable-breakpad",
+      // no crash reporter process spawned
+      "--disable-client-side-phishing-detection",
+      // no ML model loaded on startup
+      "--metrics-recording-only",
+      "--disable-hang-monitor",
+      // ── Timers / scheduling ───────────────────────────────────────────────────────
       "--disable-background-timer-throttling",
       "--disable-renderer-backgrounding",
+      // ── Memory ───────────────────────────────────────────────────────────────────
       "--disable-dev-shm-usage",
-      "--disable-translate",
-      "--metrics-recording-only",
-      "--disable-hang-monitor"
+      // write to /tmp instead; avoids shm exhaustion with many Chromes
+      // ── Navigation ───────────────────────────────────────────────────────────────
+      "--disable-back-forward-cache",
+      // no BFCache state setup; qunitx never navigates back
+      // ── Audio ─────────────────────────────────────────────────────────────────────
+      "--mute-audio",
+      // ── Keychain / credentials ────────────────────────────────────────────────────
+      "--password-store=basic",
+      // avoids dbus/kwallet stalls on Linux
+      "--use-mock-keychain",
+      // avoids system keychain calls on macOS
+      // ── Feature flags ────────────────────────────────────────────────────────────
+      //
+      // Only features that are invisible to user test code are disabled here.
+      //
+      // PaintHolding          — Chrome delays first paint by up to 500ms to prevent flash-of-
+      //                         unstyled-content. Pure dead time in headless; disabling it makes
+      //                         every page load return faster.
+      // HttpsUpgrades         — Prevents Chrome from silently upgrading HTTP→HTTPS. Critical:
+      //                         qunitx's local test server runs on HTTP; an upgrade attempt would
+      //                         cause the connection to fail.
+      // DestroyProfileOnBrowserClose — avoids async profile teardown on exit.
+      // DialMediaRouteProvider, GlobalMediaControls, LensOverlay, MediaRouter — UI chrome with no
+      //                         test relevance.
+      // OptimizationHints     — background network requests for Chrome's optimization service.
+      // Translate             — translation UI.
+      // AvoidUnnecessaryBeforeUnloadCheckSync — reduces beforeunload handler overhead.
+      "--disable-features=AvoidUnnecessaryBeforeUnloadCheckSync,DestroyProfileOnBrowserClose,DialMediaRouteProvider,GlobalMediaControls,HttpsUpgrades,LensOverlay,MediaRouter,OptimizationHints,PaintHolding,Translate"
     ];
   }
 });
@@ -108,7 +191,13 @@ var init_perf_logger = __esm({
 });
 
 // lib/utils/early-chrome.ts
-var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, openWatchMode, earlyChromeProcRef, earlyBrowserPromise;
+async function shutdownEarlyBrowser() {
+  if (!earlyChrome) return;
+  const { shutdown } = earlyChrome;
+  earlyChrome = null;
+  await shutdown();
+}
+var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, openWatchMode, earlyChrome, earlyBrowserPromise;
 var init_early_chrome = __esm({
   "lib/utils/early-chrome.ts"() {
     init_find_chrome();
@@ -127,12 +216,12 @@ var init_early_chrome = __esm({
       { browserFromArgv: "chromium", openFromArgv: false, watchFromArgv: false }
     ));
     openWatchMode = openFromArgv && watchFromArgv;
-    earlyChromeProcRef = null;
+    earlyChrome = null;
     if (!openWatchMode) {
       process.on("exit", () => {
-        if (!earlyChromeProcRef) return;
+        if (!earlyChrome) return;
         try {
-          earlyChromeProcRef.kill("SIGKILL");
+          earlyChrome.proc.kill("SIGKILL");
         } catch {
         }
       });
@@ -143,7 +232,7 @@ var init_early_chrome = __esm({
       return preLaunchChrome(chromePath, chromium_args_default, !openWatchMode);
     }).then((info) => {
       perfLog("early-chrome.js: Chrome CDP ready", info?.cdpEndpoint ?? null);
-      if (info) earlyChromeProcRef = info.proc;
+      if (info) earlyChrome = info;
       return info;
     }) : Promise.resolve(null);
   }
@@ -151,45 +240,47 @@ var init_early_chrome = __esm({
 
 // lib/utils/color.ts
 function createColors(enabled2) {
-  const c = (open, close) => (text) => enabled2 ? `\x1B[${open}m${text}\x1B[${close}m` : String(text);
-  const red2 = c(31, 39);
-  const green2 = c(32, 39);
-  const yellow2 = c(33, 39);
-  const blue2 = c(34, 39);
+  const makeColor = (open, close) => (text) => enabled2 ? `\x1B[${open}m${text}\x1B[${close}m` : String(text);
+  const red2 = makeColor(31, 39);
+  const green2 = makeColor(32, 39);
+  const yellow2 = makeColor(33, 39);
+  const blue2 = makeColor(34, 39);
   const magenta2 = ((text) => {
     if (text !== void 0) return enabled2 ? `\x1B[35m${text}\x1B[39m` : String(text);
-    return { bold: (t) => enabled2 ? `\x1B[35m\x1B[1m${t}\x1B[22m\x1B[39m` : String(t) };
+    return {
+      bold: (boldText) => enabled2 ? `\x1B[35m\x1B[1m${boldText}\x1B[22m\x1B[39m` : String(boldText)
+    };
   });
   return { red: red2, green: green2, yellow: yellow2, blue: blue2, magenta: magenta2 };
 }
 function red(text) {
-  return _c.red(text);
+  return colors.red(text);
 }
 function green(text) {
-  return _c.green(text);
+  return colors.green(text);
 }
 function yellow(text) {
-  return _c.yellow(text);
+  return colors.yellow(text);
 }
 function blue(text) {
-  return _c.blue(text);
+  return colors.blue(text);
 }
 function magenta(text) {
-  return _c.magenta(text);
+  return colors.magenta(text);
 }
-var enabled, _c;
+var enabled, colors;
 var init_color = __esm({
   "lib/utils/color.ts"() {
     enabled = !process.env.NODE_DISABLE_COLORS && process.env.NO_COLOR == null && process.env.TERM !== "dumb" && (process.env.FORCE_COLOR != null && process.env.FORCE_COLOR !== "0" || !!process.stdout?.isTTY);
-    _c = createColors(enabled);
+    colors = createColors(enabled);
   }
 });
 
 // lib/utils/path-exists.ts
 import fs from "node:fs/promises";
-async function pathExists(path5) {
+async function pathExists(path6) {
   try {
-    await fs.access(path5);
+    await fs.access(path6);
     return true;
   } catch {
     return false;
@@ -225,8 +316,8 @@ var init_read_boilerplate = __esm({
 
 // lib/utils/find-internal-assets-from-html.ts
 function findInternalAssetsFromHTML(htmlContent) {
-  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)].map((m) => m[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)].map((m) => m[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
   return links.concat(scripts);
 }
 var ABSOLUTE_URL_REGEX, SCRIPT_SRC_REGEX, LINK_HREF_REGEX;
@@ -288,17 +379,17 @@ function dumpValue(value, indent) {
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";
     const next2 = `${indent}  `;
-    return "\n" + value.map((v) => `${next2}- ${dumpValue(v, next2)}`).join("\n");
+    return "\n" + value.map((item) => `${next2}- ${dumpValue(item, next2)}`).join("\n");
   }
   const entries = Object.entries(value);
   if (entries.length === 0) return "{}";
   const next = `${indent}  `;
-  return "\n" + entries.map(([k, v]) => `${next}${k}: ${dumpValue(v, next)}`).join("\n");
+  return "\n" + entries.map(([entryKey, entryValue]) => `${next}${entryKey}: ${dumpValue(entryValue, next)}`).join("\n");
 }
 function yamlLine(key, value) {
-  const v = dumpValue(value, "");
-  return v[0] === "\n" ? `${key}:${v}
-` : `${key}: ${v}
+  const serialized = dumpValue(value, "");
+  return serialized[0] === "\n" ? `${key}:${serialized}
+` : `${key}: ${serialized}
 `;
 }
 function dumpYaml({
@@ -404,23 +495,31 @@ var init_display_test_result = __esm({
 // lib/setup/bind-server-to-port.ts
 async function bindServerToPort(server, config) {
   let port = config.port;
+  let attempt = 0;
   while (true) {
     try {
       await server.listen(port);
       break;
     } catch (err) {
-      if (err.code === "EADDRINUSE" && !config.portExplicit) {
+      const isEADDRINUSE = err.code === "EADDRINUSE";
+      if (!isEADDRINUSE) throw err;
+      if (config.portExplicit) {
+        if (attempt >= EXPLICIT_PORT_RETRIES) throw err;
+        attempt++;
+        await new Promise((resolve) => setTimeout(resolve, EXPLICIT_PORT_RETRY_DELAY_MS));
+      } else {
         port++;
-        continue;
       }
-      throw err;
     }
   }
   config.port = server._server.address().port;
   return server;
 }
+var EXPLICIT_PORT_RETRIES, EXPLICIT_PORT_RETRY_DELAY_MS;
 var init_bind_server_to_port = __esm({
   "lib/setup/bind-server-to-port.ts"() {
+    EXPLICIT_PORT_RETRIES = 5;
+    EXPLICIT_PORT_RETRY_DELAY_MS = 20;
   }
 });
 
@@ -516,8 +615,8 @@ var init_http = __esm({
         return new Promise((resolve) => this._server.close(resolve));
       }
       /** Registers a GET route handler. */
-      get(path5, handler) {
-        this.#registerRouteHandler("GET", path5, handler);
+      get(path6, handler) {
+        this.#registerRouteHandler("GET", path6, handler);
       }
       /**
        * Starts listening on the given port (0 = OS-assigned).
@@ -548,30 +647,30 @@ var init_http = __esm({
         });
       }
       /** Registers a POST route handler. */
-      post(path5, handler) {
-        this.#registerRouteHandler("POST", path5, handler);
+      post(path6, handler) {
+        this.#registerRouteHandler("POST", path6, handler);
       }
       /** Registers a DELETE route handler. */
-      delete(path5, handler) {
-        this.#registerRouteHandler("DELETE", path5, handler);
+      delete(path6, handler) {
+        this.#registerRouteHandler("DELETE", path6, handler);
       }
       /** Registers a PUT route handler. */
-      put(path5, handler) {
-        this.#registerRouteHandler("PUT", path5, handler);
+      put(path6, handler) {
+        this.#registerRouteHandler("PUT", path6, handler);
       }
       /** Adds a middleware function to the chain. */
       use(middleware) {
         this.middleware.push(middleware);
       }
-      #registerRouteHandler(method, path5, handler) {
+      #registerRouteHandler(method, path6, handler) {
         if (!this.routes[method]) {
           this.routes[method] = {};
         }
-        this.routes[method][path5] = {
-          path: path5,
+        this.routes[method][path6] = {
+          path: path6,
           handler,
-          paramNames: this.#extractParamNames(path5),
-          isWildcard: path5 === "/*"
+          paramNames: this.#extractParamNames(path6),
+          isWildcard: path6 === "/*"
         };
       }
       #handleRequest(req, res) {
@@ -609,13 +708,13 @@ var init_http = __esm({
           return null;
         }
         return routes[url] || Object.values(routes).find((route) => {
-          const { path: path5, isWildcard } = route;
-          if (!isWildcard && !path5.includes(":")) {
+          const { path: path6, isWildcard } = route;
+          if (!isWildcard && !path6.includes(":")) {
             return false;
           }
-          if (isWildcard || this.#matchPathSegments(path5, url)) {
+          if (isWildcard || this.#matchPathSegments(path6, url)) {
             if (route.paramNames.length > 0) {
-              const regexPattern = this.#buildRegexPattern(path5, route.paramNames);
+              const regexPattern = this.#buildRegexPattern(path6, route.paramNames);
               const regex = new RegExp(`^${regexPattern}$`);
               const regexMatches = regex.exec(url);
               if (regexMatches) {
@@ -627,8 +726,8 @@ var init_http = __esm({
           return false;
         }) || routes["/*"] || null;
       }
-      #matchPathSegments(path5, url) {
-        const pathSegments = path5.split("/");
+      #matchPathSegments(path6, url) {
+        const pathSegments = path6.split("/");
         const urlSegments = url.split("/");
         if (pathSegments.length !== urlSegments.length) {
           return false;
@@ -645,14 +744,14 @@ var init_http = __esm({
         }
         return true;
       }
-      #buildRegexPattern(path5, _paramNames) {
-        let regexPattern = path5.replace(/:[^/]+/g, "([^/]+)");
+      #buildRegexPattern(path6, _paramNames) {
+        let regexPattern = path6.replace(/:[^/]+/g, "([^/]+)");
         regexPattern = regexPattern.replace(/\//g, "\\/");
         return regexPattern;
       }
-      #extractParamNames(path5) {
+      #extractParamNames(path6) {
         const paramRegex = /:(\w+)/g;
-        const paramMatches = path5.match(paramRegex);
+        const paramMatches = path6.match(paramRegex);
         return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
       }
       #extractParams(route, _url) {
@@ -669,9 +768,9 @@ var init_http = __esm({
 
 // lib/setup/web-server.ts
 import fs7 from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 function setupWebServer(config, cachedContent) {
-  const STATIC_FILES_PATH = path3.join(config.projectRoot, config.output);
+  const STATIC_FILES_PATH = path4.join(config.projectRoot, config.output);
   const server = new HTTPServer();
   const mainHTMLWithReplacedAssets = replaceAssetPaths(
     cachedContent.mainHTML.html,
@@ -682,17 +781,40 @@ function setupWebServer(config, cachedContent) {
     socket.on("message", function message(data) {
       const { event, details, abort } = JSON.parse(data);
       if (event === "wsOpen") {
+        config._phase = "loading";
         config._onWsOpen?.();
       } else if (event === "connection") {
+        config._phase = "running";
         if (!config._groupMode) console.log("TAP version 13");
+        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("  ");
+          console.log("#", blue(`\u2500\u2500 ${fileList} \u2500\u2500`));
+        }
         config._resetTestTimeout?.();
       } else if (event === "testEnd" && !abort) {
         if (details.status === "failed") {
           config.lastFailedTestFiles = config.lastRanTestFiles;
         }
+        if (config.debug && details.runtime > config.timeout * 0.8) {
+          console.log(
+            `# SLOW (${details.runtime.toFixed(0)}ms / ${config.timeout}ms timeout): ${details.fullName.join(" | ")}`
+          );
+        }
         config._resetTestTimeout?.();
         TAPDisplayTestResult(config.COUNTER, details);
       } else if (event === "done") {
+        config._phase = "done";
+        if (config.debug && config._groupMode) {
+          console.log(
+            `# group done: ${details.passed} passed, ${details.failed} failed (${details.runtime}ms)`
+          );
+        }
         if (typeof config._testRunDone === "function") {
           config._testRunDone();
           config._testRunDone = null;
@@ -784,7 +906,7 @@ function setupWebServer(config, cachedContent) {
     const filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join("");
     const statusCode = await pathExists(filePath) ? 200 : 404;
     res.writeHead(statusCode, {
-      "Content-Type": req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path3.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+      "Content-Type": req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path4.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
     });
     if (statusCode === 404) {
       res.end();
@@ -799,7 +921,7 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
   const assetPaths = findInternalAssetsFromHTML(html);
   const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
   return assetPaths.reduce((result, assetPath) => {
-    const normalizedFullAbsolutePath = path3.normalize(`${htmlDirectory}/${assetPath}`);
+    const normalizedFullAbsolutePath = path4.normalize(`${htmlDirectory}/${assetPath}`);
     return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
@@ -966,6 +1088,7 @@ var init_web_server = __esm({
     init_find_internal_assets_from_html();
     init_html_content_marker();
     init_display_test_result();
+    init_color();
     init_path_exists();
     init_http();
     fsPromise = fs7.promises;
@@ -977,18 +1100,18 @@ async function launchBrowser(config) {
   const browserName = config.browser || "chromium";
   if (browserName === "chromium") {
     const waitStart = Date.now();
-    const [playwrightCore2, earlyChrome] = await Promise.all([
+    const [playwrightCore2, earlyChrome2] = await Promise.all([
       playwrightCorePromise,
       earlyBrowserPromise
     ]);
     perfLog(
       `browser.js: playwright-core + earlyChrome resolved in ${Date.now() - waitStart}ms, earlyChrome:`,
-      earlyChrome?.cdpEndpoint ?? null
+      earlyChrome2?.cdpEndpoint ?? null
     );
-    if (earlyChrome) {
+    if (earlyChrome2) {
       const connectStart = Date.now();
       const browser = await playwrightCore2.chromium.connectOverCDP({
-        endpointURL: earlyChrome.cdpEndpoint
+        endpointURL: earlyChrome2.cdpEndpoint
       });
       perfLog(`browser.js: connectOverCDP took ${Date.now() - connectStart}ms`);
       return browser;
@@ -1122,7 +1245,7 @@ async function runUserModule(modulePath, params, scriptPosition) {
     console.log("#", red(`QUnitX ${scriptPosition} script failed:`));
     console.trace(error);
     console.error(error);
-    return process.exit(1);
+    process.stdout.write("", () => process.exit(1));
   }
 }
 var init_run_user_module = __esm({
@@ -1158,25 +1281,29 @@ async function buildTestBundle(config, cachedContent) {
     return;
   }
   const outfile = `${projectRoot}/${output}/tests.js`;
-  await Promise.all([
+  const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
+  const needsDisk = true;
+  const [allTestCode] = await Promise.all([
     buildWithOverlayfsRetry(
       {
         stdin: {
-          contents: allTestFilePaths.map((f) => `import "${f}";`).join(""),
+          contents: allTestFilePaths.map((filePath) => `import "${filePath}";`).join(""),
           resolveDir: process.cwd()
         },
         bundle: true,
         logLevel: "error",
         outfile,
         keepNames: true,
-        sourcemap: config.debug ? "inline" : config.watch ? "linked" : false,
+        legalComments: "none",
+        target: esbuildTarget(config.browser),
+        sourcemap,
         // Signal the runtime that all test modules are registered. The runtime's maybeStart()
         // waits for both this event and the WebSocket 'open' event before calling QUnit.start().
         // Dispatching from the bundle (rather than from a script onload attr) is reliable across
         // all browsers and does not require changes to user test code.
         footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
       },
-      outfile
+      needsDisk
     ),
     Promise.all(
       cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
@@ -1188,7 +1315,7 @@ async function buildTestBundle(config, cachedContent) {
       })
     )
   ]);
-  cachedContent.allTestCode = await fs8.readFile(outfile);
+  cachedContent.allTestCode = allTestCode;
 }
 async function runTestsInBrowser(config, cachedContent = {}, connections, targetTestFilesToFilter) {
   const { projectRoot, output } = config;
@@ -1207,8 +1334,11 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
     }
     if (runHasFilter) {
       const outputPath = `${projectRoot}/${output}/filtered-tests.js`;
-      await buildFilteredTests(targetTestFilesToFilter, outputPath, config);
-      cachedContent.filteredTestCode = (await fs8.readFile(outputPath)).toString();
+      cachedContent.filteredTestCode = await buildFilteredTests(
+        targetTestFilesToFilter,
+        outputPath,
+        config
+      );
     }
     const TIME_COUNTER = timeCounter();
     if (runHasFilter) {
@@ -1231,6 +1361,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
           connections.server && connections.server.close(),
           connections.browser && connections.browser.close()
         ]);
+        await shutdownEarlyBrowser();
         return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
       }
     }
@@ -1247,42 +1378,60 @@ 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);
   return buildWithOverlayfsRetry(
     {
       stdin: {
-        contents: filteredTests.map((f) => `import "${f}";`).join(""),
+        contents: filteredTests.map((filePath) => `import "${filePath}";`).join(""),
         resolveDir: process.cwd()
       },
       bundle: true,
       logLevel: "error",
       outfile: outputPath,
-      sourcemap: config.debug ? "inline" : config.watch ? "linked" : false,
+      legalComments: "none",
+      target: esbuildTarget(config.browser),
+      sourcemap,
       footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
     },
-    outputPath
+    needsDisk
   );
 }
-async function buildWithOverlayfsRetry(options, outfile) {
+async function buildWithOverlayfsRetry(options, needsDisk) {
   const RETRY_DELAY_MS = 100;
   const MAX_RETRIES = 3;
   const EMPTY_BUNDLE_THRESHOLD = 500;
-  let result = await esbuild.build(options);
+  const buildOpts = { ...options, write: false };
+  const getContents = async () => {
+    const result2 = await esbuild.build(buildOpts);
+    const jsFile = result2.outputFiles.find((outputFile) => !outputFile.path.endsWith(".map"));
+    return { result: result2, js: Buffer.from(jsFile.contents) };
+  };
+  let { result, js } = await getContents();
   for (let retry = 1; retry <= MAX_RETRIES; retry++) {
-    const bytes2 = (await fs8.stat(outfile)).size;
-    if (bytes2 >= EMPTY_BUNDLE_THRESHOLD) return result;
+    if (js.length >= EMPTY_BUNDLE_THRESHOLD) break;
     console.log(
-      `# [buildWithOverlayfsRetry] bundle is ${bytes2} bytes (< ${EMPTY_BUNDLE_THRESHOLD}) on attempt ${retry}/${MAX_RETRIES} \u2014 overlayfs flush race, retrying in ${RETRY_DELAY_MS}ms`
+      `# [buildWithOverlayfsRetry] bundle is ${js.length} bytes (< ${EMPTY_BUNDLE_THRESHOLD}) on attempt ${retry}/${MAX_RETRIES} \u2014 overlayfs flush race, retrying in ${RETRY_DELAY_MS}ms`
     );
     await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
-    result = await esbuild.build(options);
+    ({ result, js } = await getContents());
   }
-  const bytes = (await fs8.stat(outfile)).size;
-  if (bytes < EMPTY_BUNDLE_THRESHOLD) {
+  if (js.length < EMPTY_BUNDLE_THRESHOLD) {
     console.log(
-      `# [buildWithOverlayfsRetry] bundle is ${bytes} bytes after ${MAX_RETRIES} retries \u2014 proceeding`
+      `# [buildWithOverlayfsRetry] bundle is ${js.length} bytes after ${MAX_RETRIES} retries \u2014 proceeding`
     );
   }
-  return result;
+  if (needsDisk) {
+    await Promise.all(
+      result.outputFiles.map((outputFile) => fs8.writeFile(outputFile.path, outputFile.contents))
+    );
+  }
+  return js;
+}
+function esbuildTarget(browser) {
+  if (browser === "firefox") return ["firefox115"];
+  if (browser === "webkit") return ["safari16"];
+  return ["chrome120"];
 }
 async function runTestInsideHTMLFile(filePath, { page, server, browser }, config) {
   let QUNIT_RESULT;
@@ -1291,6 +1440,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);
     let resolveTestRace;
     const testRaceResult = new Promise((resolve) => {
       resolveTestRace = resolve;
@@ -1299,11 +1451,11 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     config._onWsOpen = () => {
       wsConnected = true;
       clearTimeout(timeoutHandle);
-      timeoutHandle = setTimeout(resolveTestRace, config.timeout * 3);
+      timeoutHandle = setTimeout(resolveTestRace, startupMs);
     };
     config._onTestsJsServed = () => {
       clearTimeout(timeoutHandle);
-      timeoutHandle = setTimeout(resolveTestRace, config.timeout * 4);
+      timeoutHandle = setTimeout(resolveTestRace, testsJsMs);
     };
     config._resetTestTimeout = () => {
       wsConnected = true;
@@ -1311,14 +1463,14 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
       timeoutHandle = setTimeout(resolveTestRace, config.timeout);
     };
     const targetUrl = `http://localhost:${config.port}${filePath}`;
-    const navOptions = { timeout: config.timeout + 1e4, waitUntil: "commit" };
+    const navOptions = { timeout: navMs, waitUntil: "commit" };
     if (page.url().split("?")[0] === targetUrl) {
       await page.reload(navOptions);
     } else {
       await page.goto(targetUrl, navOptions);
     }
     clearTimeout(timeoutHandle);
-    timeoutHandle = setTimeout(resolveTestRace, config.timeout * 3);
+    timeoutHandle = setTimeout(resolveTestRace, startupMs);
     await testRaceResult;
     QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
   } catch (error) {
@@ -1360,6 +1512,7 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
       connections.server && connections.server.close(),
       connections.browser && connections.browser.close()
     ]);
+    await shutdownEarlyBrowser();
     process.exit(1);
   }
 }
@@ -1367,6 +1520,7 @@ var BundleError;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
+    init_early_chrome();
     init_time_counter();
     init_run_user_module();
     init_display_final_result();
@@ -1382,70 +1536,81 @@ var init_tests_in_browser = __esm({
 
 // lib/setup/file-watcher.ts
 import fs9 from "node:fs";
-import { stat } from "node:fs/promises";
-import path4 from "node:path";
+import { stat, lstat } from "node:fs/promises";
+import path5 from "node:path";
 function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
   const extensions = config.extensions || ["js", "ts"];
   const readyPromises = [];
   const parentWatchers = [];
-  const fileWatchers = testFileLookupPaths.reduce((watchers, watchPath) => {
+  const fileWatchers = {};
+  const symlinkPollers = /* @__PURE__ */ new Map();
+  function trackSymlink(filePath) {
+    if (symlinkPollers.has(filePath)) return;
+    const handler = (curr) => {
+      if (curr.nlink === 0) {
+        fs9.unwatchFile(filePath, handler);
+        symlinkPollers.delete(filePath);
+        if (filePath in config.fsTree) {
+          handleWatchEvent(config, extensions, "unlink", filePath, onEventFunc, onFinishFunc);
+        }
+      }
+    };
+    fs9.watchFile(filePath, { interval: 500, persistent: false }, handler);
+    symlinkPollers.set(filePath, () => fs9.unwatchFile(filePath, handler));
+  }
+  function untrackSymlink(filePath) {
+    symlinkPollers.get(filePath)?.();
+    symlinkPollers.delete(filePath);
+  }
+  for (const watchPath of testFileLookupPaths) {
     let ready = false;
     const lastChangeMs = {};
-    const CHANGE_DEDUPE_MS = 30;
     const childWatcher = fs9.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready || !filename) return;
-      const fullPath = path4.join(watchPath, filename);
+      const fullPath = path5.join(watchPath, filename);
       if (eventType === "change") {
         if (!config._building) {
           const now = Date.now();
-          if (now - (lastChangeMs[fullPath] ?? 0) < CHANGE_DEDUPE_MS) return;
+          const last = lastChangeMs[fullPath] ?? 0;
+          if (now - last < CHANGE_DEDUPE_MS) {
+            if (!config._lastBuildEndMs || config._lastBuildEndMs <= last) return;
+          }
           lastChangeMs[fullPath] = now;
         }
         return handleWatchEvent(config, extensions, "change", fullPath, onEventFunc, onFinishFunc);
       }
-      try {
-        const s = await stat(fullPath);
-        handleWatchEvent(
-          config,
-          extensions,
-          s.isDirectory() ? "addDir" : "add",
-          fullPath,
-          onEventFunc,
-          onFinishFunc
-        );
-      } catch {
-        await new Promise((resolve) => setTimeout(resolve, 50));
+      const event = await classifyRenameEvent(fullPath, config.fsTree);
+      if (!event) return;
+      if (event === "add") {
         try {
-          const s = await stat(fullPath);
-          handleWatchEvent(
-            config,
-            extensions,
-            s.isDirectory() ? "addDir" : "add",
-            fullPath,
-            onEventFunc,
-            onFinishFunc
-          );
-          return;
+          const lstatResult = await lstat(fullPath);
+          if (lstatResult.isSymbolicLink()) trackSymlink(fullPath);
         } catch {
         }
-        if (!(config.fsTree && fullPath in config.fsTree)) return;
-        handleWatchEvent(config, extensions, "unlink", fullPath, onEventFunc, onFinishFunc);
+      } else if (event === "unlink") {
+        untrackSymlink(fullPath);
       }
+      handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
     });
-    const parentDir = path4.dirname(watchPath);
-    const watchedBasename = path4.basename(watchPath);
+    const parentDir = path5.dirname(watchPath);
+    const watchedBasename = path5.basename(watchPath);
+    let parentUnlinkFired = false;
     const parentWatcher = fs9.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
+      if (parentUnlinkFired) return;
+      parentUnlinkFired = true;
       try {
         await stat(watchPath);
+        parentUnlinkFired = false;
       } catch {
         handleWatchEvent(config, extensions, "unlinkDir", watchPath, onEventFunc, onFinishFunc);
         childWatcher.close();
         parentWatcher.close();
-        delete watchers[watchPath];
+        delete fileWatchers[watchPath];
       }
     });
     parentWatchers.push(parentWatcher);
+    fileWatchers[watchPath] = childWatcher;
     readyPromises.push(
       new Promise(
         (resolve) => setImmediate(() => {
@@ -1454,8 +1619,18 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         })
       )
     );
-    return Object.assign(watchers, { [watchPath]: childWatcher });
-  }, {});
+  }
+  readyPromises.push(
+    (async () => {
+      for (const filePath of Object.keys(config.fsTree)) {
+        try {
+          const lstatResult = await lstat(filePath);
+          if (lstatResult.isSymbolicLink()) trackSymlink(filePath);
+        } catch {
+        }
+      }
+    })()
+  );
   return {
     fileWatchers,
     ready: Promise.all(readyPromises).then(() => {
@@ -1463,69 +1638,85 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     killFileWatchers() {
       Object.keys(fileWatchers).forEach((key) => fileWatchers[key].close());
       parentWatchers.forEach((pw) => pw.close());
+      symlinkPollers.forEach((cancel) => cancel());
+      symlinkPollers.clear();
       return fileWatchers;
     }
   };
 }
+async function classifyRenameEvent(fullPath, fsTree) {
+  for (const delay of [0, 50]) {
+    if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
+    try {
+      const statResult = await stat(fullPath);
+      return statResult.isDirectory() ? "addDir" : "add";
+    } catch {
+    }
+  }
+  if (!fsTree) return null;
+  if (fullPath in fsTree) return "unlink";
+  const dirPrefix = fullPath + "/";
+  return Object.keys(fsTree).some((trackedPath) => trackedPath.startsWith(dirPrefix)) ? "unlinkDir" : null;
+}
 function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc) {
-  const isFileEvent = extensions.some((ext) => filePath.endsWith(`.${ext}`));
-  if (!isFileEvent && event !== "unlinkDir") return;
+  if (event !== "unlinkDir" && !extensions.some((ext) => filePath.endsWith(`.${ext}`)))
+    return Promise.resolve();
+  if (event === "change" && config._building && config._justAddedFiles?.has(filePath))
+    return Promise.resolve();
   mutateFSTree(config.fsTree, event, filePath);
   console.log(
     "#",
     magenta().bold("==================================================================")
   );
-  console.log("#", getEventColor(event), filePath.split(config.projectRoot)[1]);
+  console.log("#", colorEvent(event), filePath.split(config.projectRoot)[1]);
   console.log(
     "#",
     magenta().bold("==================================================================")
   );
-  if (!config._building) {
-    config._building = true;
-    const result = onEventFunc(event, filePath);
-    if (!(result instanceof Promise)) {
-      config._building = false;
-      return result;
-    }
-    result.then(() => {
-      onFinishFunc ? onFinishFunc(event, filePath) : null;
-    }).catch((error) => {
-      console.error("#", red("Build error:"), error.message || error);
-    }).finally(() => {
-      config._building = false;
-      if (config._pendingBuildTrigger) {
-        const trigger = config._pendingBuildTrigger;
-        config._pendingBuildTrigger = null;
-        trigger();
-      }
-    });
-  } else {
+  if (config._building) {
+    if (event === "add") config._justAddedFiles?.add(filePath);
     config._pendingBuildTrigger = () => handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc);
-  }
+    return Promise.resolve();
+  }
+  config._building = true;
+  config._justAddedFiles = event === "add" ? /* @__PURE__ */ new Set([filePath]) : /* @__PURE__ */ new Set();
+  const result = onEventFunc(event, filePath);
+  if (!(result instanceof Promise)) {
+    config._building = false;
+    return Promise.resolve();
+  }
+  return result.then(() => onFinishFunc?.(filePath, event)).catch((error) => console.error("#", red("Build error:"), error.message || error)).finally(() => {
+    config._building = false;
+    config._lastBuildEndMs = Date.now();
+    if (config._pendingBuildTrigger) {
+      const trigger = config._pendingBuildTrigger;
+      config._pendingBuildTrigger = null;
+      trigger();
+    }
+  });
 }
-function mutateFSTree(fsTree, event, path5) {
+function mutateFSTree(fsTree, event, path6) {
   if (event === "add") {
-    fsTree[path5] = null;
+    fsTree[path6] = null;
   } else if (event === "unlink") {
-    delete fsTree[path5];
+    delete fsTree[path6];
   } else if (event === "unlinkDir") {
+    const dirPrefix = path6.endsWith("/") ? path6 : path6 + "/";
     for (const treePath of Object.keys(fsTree)) {
-      if (treePath.startsWith(path5)) delete fsTree[treePath];
+      if (treePath.startsWith(dirPrefix)) delete fsTree[treePath];
     }
   }
 }
-function getEventColor(event) {
-  if (event === "change") {
-    return yellow("CHANGED:");
-  } else if (event === "add" || event === "addDir") {
-    return green("ADDED:");
-  } else if (event === "unlink" || event === "unlinkDir") {
-    return red("REMOVED:");
-  }
+function colorEvent(event) {
+  if (event === "change") return yellow("CHANGED:");
+  if (event === "add" || event === "addDir") return green("ADDED:");
+  return red("REMOVED:");
 }
+var CHANGE_DEDUPE_MS;
 var init_file_watcher = __esm({
   "lib/setup/file-watcher.ts"() {
     init_color();
+    CHANGE_DEDUPE_MS = 30;
   }
 });
 
@@ -1594,7 +1785,7 @@ function setupKeyboardEvents(config, cachedContent, connections) {
   });
 }
 function abortBrowserQUnit(_config, connections) {
-  connections.server.publish("abort", "abort");
+  connections.server.publish("abort");
 }
 var init_keyboard_events = __esm({
   "lib/setup/keyboard-events.ts"() {
@@ -1671,11 +1862,21 @@ async function run(config) {
           if (["change", "unlink", "unlinkDir"].includes(event)) {
             if (event === "change" && !(file in config.fsTree)) return;
             cachedContent.allTestCode = null;
+            if (config.debug) {
+              console.log(
+                `# Rerun triggered: ${event} \u2192 ${file.replace(`${config.projectRoot}/`, "")}`
+              );
+            }
             return await runTestsInBrowser(config, cachedContent, connections);
           }
+          if (config.debug) {
+            console.log(
+              `# Rerun triggered: ${event} \u2192 ${file.replace(`${config.projectRoot}/`, "")}`
+            );
+          }
           await runTestsInBrowser(config, cachedContent, connections, [file]);
         },
-        (_path, _event) => connections.server.publish("refresh", "refresh")
+        (_path, _event) => connections.server.publish("refresh")
       );
       await watcherReady;
     }
@@ -1688,13 +1889,17 @@ async function run(config) {
     config.lastRanTestFiles = allFiles;
     const groupConfigs = groups.map((groupFiles, i) => ({
       ...config,
-      fsTree: Object.fromEntries(groupFiles.map((f) => [f, config.fsTree[f]])),
+      fsTree: Object.fromEntries(groupFiles.map((filePath) => [filePath, config.fsTree[filePath]])),
       // Single group keeps the root output dir for backward-compatible file paths.
       output: groupCount === 1 ? config.output : `${config.output}/group-${i}`,
-      _groupMode: true
+      _groupMode: true,
+      _phase: "bundling"
     }));
     const groupCachedContents = groups.map(() => ({ ...cachedContent }));
     console.log("TAP version 13");
+    console.log(
+      `# Running ${allFiles.length} test file${allFiles.length === 1 ? "" : "s"} across ${groupCount} group${groupCount === 1 ? "" : "s"}`
+    );
     const [browser] = await Promise.all([
       launchBrowser(config),
       Promise.all(
@@ -1716,14 +1921,22 @@ async function run(config) {
     const groupResults = await Promise.allSettled(
       groupConfigs.map((groupConfig, i) => {
         const groupTimeout = new Promise((_, reject) => {
-          const t = setTimeout(
-            () => reject(new Error(`Group ${i} timed out after ${GROUP_TIMEOUT_MS}ms`)),
-            GROUP_TIMEOUT_MS
-          );
-          t.unref();
+          const timeoutId = setTimeout(() => {
+            const files = Object.keys(groupConfig.fsTree).map(
+              (filePath) => filePath.replace(`${groupConfig.projectRoot}/`, "")
+            );
+            reject(
+              new Error(
+                `Group ${i} timed out after ${GROUP_TIMEOUT_MS / 1e3}s in phase '${groupConfig._phase ?? "unknown"}'
+  Files: ${files.join(", ")}`
+              )
+            );
+          }, GROUP_TIMEOUT_MS);
+          timeoutId.unref();
         });
         return Promise.race([
           (async () => {
+            groupConfig._phase = "connecting";
             const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
             groupConfig.expressApp = connections.server;
             if (config.before) {
@@ -1739,8 +1952,8 @@ async function run(config) {
                 Promise.race([
                   connections.page.close(),
                   new Promise((resolve) => {
-                    const t = setTimeout(resolve, 1e4);
-                    t.unref();
+                    const pageCloseTimeoutId = setTimeout(resolve, 1e4);
+                    pageCloseTimeoutId.unref();
                   })
                 ]).catch(() => {
                 })
@@ -1766,11 +1979,12 @@ async function run(config) {
     }
     const exitTimer = setTimeout(() => process.exit(exitCode), 5e3);
     exitTimer.unref();
-    process.stdout.write("\n", () => {
+    process.stdout.write("\n", async () => {
       clearTimeout(exitTimer);
       clearInterval(keepAlive);
-      browser.close().catch(() => {
+      await browser.close().catch(() => {
       });
+      await shutdownEarlyBrowser();
       process.exit(exitCode);
     });
   }
@@ -1833,7 +2047,7 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
 function splitIntoGroups(files, groupCount) {
   const groups = Array.from({ length: groupCount }, () => []);
   files.forEach((file, i) => groups[i % groupCount].push(file));
-  return groups.filter((g) => g.length > 0);
+  return groups.filter((group) => group.length > 0);
 }
 function logWatcherAndKeyboardShortcutInfo(config, _server) {
   const prefix = "Watching files...";
@@ -1855,6 +2069,7 @@ function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
 var init_run = __esm({
   "lib/commands/run.ts"() {
     init_browser();
+    init_early_chrome();
     init_open_output_in_browser();
     init_color();
     init_tests_in_browser();
@@ -1881,7 +2096,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.11.0",
+  version: "0.16.0",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -1911,8 +2126,10 @@ var package_default = {
     "changelog:preview": "git-cliff",
     "changelog:update": "git-cliff --output CHANGELOG.md",
     postinstall: "PLAYWRIGHT_SKIP_DOWNLOAD=true deno install --allow-scripts=npm:playwright-core || true",
-    test: `node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require("os").availableParallelism()') test/**/*-test.ts`,
-    "test:browser": `node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require("os").availableParallelism()') test/flags/*-test.ts test/inputs/*-test.ts`,
+    test: "node test/runner.ts",
+    "test:debug": "QUNITX_DEBUG=1 node test/runner.ts",
+    dev: "node test/runner.ts",
+    "test:browser": "node test/runner.ts test/flags/*-test.ts test/inputs/*-test.ts",
     "test:release": "bash scripts/test-release.sh",
     "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
     "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"
@@ -1990,7 +2207,7 @@ ${color("$ qunitx new $testFileName")}  # Creates a qunitx test file
 
 // lib/commands/init.ts
 import fs3 from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 
 // lib/utils/find-project-root.ts
 import process2 from "node:process";
@@ -2062,8 +2279,8 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
       if (await pathExists(targetPath)) {
         return console.log(`${htmlPath} already exists`);
       } else {
-        const targetDirectory = path.dirname(targetPath);
-        const _targetOutputPath = path.relative(
+        const targetDirectory = path2.dirname(targetPath);
+        const _targetOutputPath = path2.relative(
           targetDirectory,
           `${projectRoot}/${config.output}/tests.js`
         );
@@ -2099,17 +2316,17 @@ init_read_boilerplate();
 async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
   const moduleName = process.argv[3];
-  const path5 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
-  if (await pathExists(path5)) {
-    console.log(`${path5} already exists!`);
+  const path6 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
+  if (await pathExists(path6)) {
+    console.log(`${path6} already exists!`);
     return;
   }
   const testJSContent = await readBoilerplate("test.js");
-  const targetFolderPaths = path5.split("/");
+  const targetFolderPaths = path6.split("/");
   targetFolderPaths.pop();
   await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs4.writeFile(path5, testJSContent.replace("{{moduleName}}", moduleName));
-  console.log(green(`${path5} written`));
+  await fs4.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
+  console.log(green(`${path6} written`));
 }
 
 // lib/setup/config.ts
@@ -2117,13 +2334,28 @@ import fs6 from "node:fs/promises";
 
 // lib/setup/fs-tree.ts
 import fs5, { glob as fsGlob } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 function isGlob(str) {
   return /[*?{[]/.test(str);
 }
 async function readDirRecursive(dir, filter) {
   const entries = await fs5.readdir(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((e) => e.isFile() && filter(e.name)).map((e) => path2.join(e.parentPath, e.name));
+  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 fs5.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"];
@@ -2195,20 +2427,20 @@ function setupTestFilePaths(_projectRoot, inputs2) {
   });
   return result.map((metaItem) => metaItem.input);
 }
-function pathIsFile(path5) {
-  const inputs2 = path5.split("/");
+function pathIsFile(path6) {
+  const inputs2 = path6.split("/");
   return inputs2[inputs2.length - 1].includes(".");
 }
 function pathIsIncludedInPaths(paths, targetPath) {
-  return paths.some((path5) => {
-    if (path5 === targetPath) {
+  return paths.some((path6) => {
+    if (path6 === targetPath) {
       return false;
     }
-    return matchesGlob(targetPath.input, buildGlobFormat(path5));
+    return matchesGlob(targetPath.input, buildGlobFormat(path6));
   });
 }
-function buildGlobFormat(path5) {
-  return path5.isFile ? path5.input : `${path5.input}/**`;
+function buildGlobFormat(path6) {
+  return path6.isFile ? path6.input : `${path6.input}/**`;
 }
 
 // lib/utils/parse-cli-flags.ts
@@ -2240,7 +2472,7 @@ function parseCliFlags(projectRoot) {
         return Object.assign(result, { port: Number(arg.split("=")[1]), portExplicit: true });
       } else if (arg.startsWith("--extensions")) {
         return Object.assign(result, {
-          extensions: arg.split("=")[1].split(",").map((e) => e.trim())
+          extensions: arg.split("=")[1].split(",").map((extension) => extension.trim())
         });
       } else if (arg.startsWith("--browser")) {
         const value = arg.split("=")[1];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.16.0",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -31,8 +31,10 @@
     "changelog:preview": "git-cliff",
     "changelog:update": "git-cliff --output CHANGELOG.md",
     "postinstall": "PLAYWRIGHT_SKIP_DOWNLOAD=true deno install --allow-scripts=npm:playwright-core || true",
-    "test": "node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/**/*-test.ts",
-    "test:browser": "node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/flags/*-test.ts test/inputs/*-test.ts",
+    "test": "node test/runner.ts",
+    "test:debug": "QUNITX_DEBUG=1 node test/runner.ts",
+    "dev": "node test/runner.ts",
+    "test:browser": "node test/runner.ts test/flags/*-test.ts test/inputs/*-test.ts",
     "test:release": "bash scripts/test-release.sh",
     "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
     "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"