qunitx-cli 0.18.0 → 0.19.1

package/dist/cli.js

@@ -93,7 +93,7 @@ async function cleanupBrowserDir(dirPath) {
       }
     }
   }
-  const deadline = Date.now() + 1e3;
+  const deadline = Date.now() + 5e3;
   while (Date.now() < deadline) {
     const removed = await fs.rm(dirPath, { recursive: true, force: true }).then(() => true).catch(() => false);
     if (removed) break;
@@ -387,9 +387,9 @@ var init_color = __esm({
 
 // lib/utils/path-exists.ts
 import fs2 from "node:fs/promises";
-async function pathExists(path6) {
+async function pathExists(path7) {
   try {
-    await fs2.access(path6);
+    await fs2.access(path7);
     return true;
   } catch {
     return false;
@@ -547,7 +547,8 @@ function TAPDisplayTestResult(COUNTER, details) {
     process.stdout.write(`ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # skip
 `);
   } else if (details.status === "todo") {
-    process.stdout.write(`not ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # skip
+    COUNTER.todoCount = (COUNTER.todoCount ?? 0) + 1;
+    process.stdout.write(`not ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # TODO
 `);
   } else if (details.status === "failed") {
     COUNTER.failCount++;
@@ -743,8 +744,8 @@ var init_http = __esm({
         });
       }
       /** Registers a GET route handler. */
-      get(path6, handler) {
-        this.#registerRouteHandler("GET", path6, handler);
+      get(path7, handler) {
+        this.#registerRouteHandler("GET", path7, handler);
       }
       /**
        * Starts listening on the given port (0 = OS-assigned).
@@ -775,30 +776,30 @@ var init_http = __esm({
         });
       }
       /** Registers a POST route handler. */
-      post(path6, handler) {
-        this.#registerRouteHandler("POST", path6, handler);
+      post(path7, handler) {
+        this.#registerRouteHandler("POST", path7, handler);
       }
       /** Registers a DELETE route handler. */
-      delete(path6, handler) {
-        this.#registerRouteHandler("DELETE", path6, handler);
+      delete(path7, handler) {
+        this.#registerRouteHandler("DELETE", path7, handler);
       }
       /** Registers a PUT route handler. */
-      put(path6, handler) {
-        this.#registerRouteHandler("PUT", path6, handler);
+      put(path7, handler) {
+        this.#registerRouteHandler("PUT", path7, handler);
       }
       /** Adds a middleware function to the chain. */
       use(middleware) {
         this.middleware.push(middleware);
       }
-      #registerRouteHandler(method, path6, handler) {
+      #registerRouteHandler(method, path7, handler) {
         if (!this.routes[method]) {
           this.routes[method] = {};
         }
-        this.routes[method][path6] = {
-          path: path6,
+        this.routes[method][path7] = {
+          path: path7,
           handler,
-          paramNames: this.#extractParamNames(path6),
-          isWildcard: path6 === "/*"
+          paramNames: this.#extractParamNames(path7),
+          isWildcard: path7 === "/*"
         };
       }
       #handleRequest(req, res) {
@@ -836,13 +837,13 @@ var init_http = __esm({
           return null;
         }
         return routes[url] || Object.values(routes).find((route) => {
-          const { path: path6, isWildcard } = route;
-          if (!isWildcard && !path6.includes(":")) {
+          const { path: path7, isWildcard } = route;
+          if (!isWildcard && !path7.includes(":")) {
             return false;
           }
-          if (isWildcard || this.#matchPathSegments(path6, url)) {
+          if (isWildcard || this.#matchPathSegments(path7, url)) {
             if (route.paramNames.length > 0) {
-              const regexPattern = this.#buildRegexPattern(path6, route.paramNames);
+              const regexPattern = this.#buildRegexPattern(path7, route.paramNames);
               const regex = new RegExp(`^${regexPattern}$`);
               const regexMatches = regex.exec(url);
               if (regexMatches) {
@@ -854,8 +855,8 @@ var init_http = __esm({
           return false;
         }) || routes["/*"] || null;
       }
-      #matchPathSegments(path6, url) {
-        const pathSegments = path6.split("/");
+      #matchPathSegments(path7, url) {
+        const pathSegments = path7.split("/");
         const urlSegments = url.split("/");
         if (pathSegments.length !== urlSegments.length) {
           return false;
@@ -872,14 +873,14 @@ var init_http = __esm({
         }
         return true;
       }
-      #buildRegexPattern(path6, _paramNames) {
-        let regexPattern = path6.replace(/:[^/]+/g, "([^/]+)");
+      #buildRegexPattern(path7, _paramNames) {
+        let regexPattern = path7.replace(/:[^/]+/g, "([^/]+)");
         regexPattern = regexPattern.replace(/\//g, "\\/");
         return regexPattern;
       }
-      #extractParamNames(path6) {
+      #extractParamNames(path7) {
         const paramRegex = /:(\w+)/g;
-        const paramMatches = path6.match(paramRegex);
+        const paramMatches = path7.match(paramRegex);
         return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
       }
       #extractParams(route, _url) {
@@ -907,7 +908,7 @@ function setupWebServer(config, cachedContent) {
   );
   server.wss.on("connection", function connection(socket) {
     socket.on("message", function message(data) {
-      const { event, details, abort } = JSON.parse(data);
+      const { event, details, qunitResult, abort } = JSON.parse(data);
       if (event === "wsOpen") {
         config._phase = "loading";
         config._onWsOpen?.();
@@ -940,6 +941,7 @@ function setupWebServer(config, cachedContent) {
         TAPDisplayTestResult(config.COUNTER, details);
       } else if (event === "done") {
         config._phase = "done";
+        config._lastQUnitResult = qunitResult ?? null;
         if (config.debug && config._groupMode) {
           process.stdout.write(
             `# group done: ${details.passed} passed, ${details.failed} failed (${details.runtime}ms)
@@ -967,7 +969,11 @@ function setupWebServer(config, cachedContent) {
       return;
     }
     config._onTestsJsServed?.();
-    res.writeHead(200, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
+    res.writeHead(200, {
+      "Content-Type": "application/javascript",
+      "Cache-Control": "no-store",
+      "Content-Length": bytes
+    });
     res.end(cachedContent.allTestCode);
   });
   server.get("/filtered-tests.js", (_req, res) => {
@@ -984,14 +990,34 @@ function setupWebServer(config, cachedContent) {
       return;
     }
     config._onTestsJsServed?.();
-    res.writeHead(200, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
+    res.writeHead(200, {
+      "Content-Type": "application/javascript",
+      "Cache-Control": "no-store",
+      "Content-Length": bytes
+    });
     res.end(cachedContent.filteredTestCode);
   });
   server.get("/", async (_req, res) => {
-    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    if (cachedContent._buildError) {
+      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return await fsPromise.writeFile(
+        `${config.projectRoot}/${config.output}/index.html`,
+        htmlContent2
+      );
+    }
+    if (cachedContent._noTestsWarning) {
+      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return;
+    }
     const htmlContent = escapeAndInjectTestsToHTML(
       mainHTMLWithReplacedAssets,
-      TEST_RUNTIME_TO_INJECT,
+      testRuntimeToInject(config.port, config),
       "./tests.js"
     );
     res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
@@ -1003,10 +1029,26 @@ function setupWebServer(config, cachedContent) {
     );
   });
   server.get("/qunitx.html", async (_req, res) => {
-    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    if (cachedContent._buildError) {
+      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return await fsPromise.writeFile(
+        `${config.projectRoot}/${config.output}/qunitx.html`,
+        htmlContent2
+      );
+    }
+    if (cachedContent._noTestsWarning) {
+      const htmlContent2 = buildNoTestsHTML(cachedContent._noTestsWarning);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return;
+    }
     const htmlContent = escapeAndInjectTestsToHTML(
       mainHTMLWithReplacedAssets,
-      TEST_RUNTIME_TO_INJECT,
+      testRuntimeToInject(config.port, config),
       "./filtered-tests.js"
     );
     res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
@@ -1020,10 +1062,9 @@ function setupWebServer(config, cachedContent) {
   server.get("/*", async (req, res) => {
     const possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
     if (possibleDynamicHTML) {
-      const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
       const htmlContent = escapeAndInjectTestsToHTML(
         possibleDynamicHTML,
-        TEST_RUNTIME_TO_INJECT,
+        testRuntimeToInject(config.port, config),
         "/tests.js"
       );
       res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
@@ -1163,7 +1204,15 @@ function testRuntimeToInject(port, config) {
 
       if (!window.QUnit) {
         console.log('QUnit not found after WebSocket connected');
-        window.testTimeout = ${config.timeout};
+        if (window.IS_PLAYWRIGHT) {
+          // 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 } }));
+        } else {
+          window.testTimeout = ${config.timeout};
+        }
         return;
       }
 
@@ -1172,11 +1221,6 @@ function testRuntimeToInject(port, config) {
           window.socket.send(JSON.stringify({ event: 'connection' }));
         }
       });
-      window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'moduleStart', details: details }, getCircularReplacer()));
-        }
-      });
       window.QUnit.on('testStart', (details) => {
         window.QUNIT_RESULT.totalTests++;
         window.QUNIT_RESULT.currentTest = details.fullName.join(' | ');
@@ -1196,7 +1240,7 @@ function testRuntimeToInject(port, config) {
       });
       window.QUnit.done((details) => {
         if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+          window.socket.send(JSON.stringify({ event: 'done', details: details, qunitResult: window.QUNIT_RESULT, abort: window.abortQUnit }, getCircularReplacer()));
           // Do NOT set testTimeout here. The WS 'done' event (testsDone promise) is the
           // canonical completion signal for Playwright runs. waitForFunction is reserved
           // for true timeouts (test hangs) where testTimeout increments naturally via setInterval.
@@ -1215,6 +1259,211 @@ 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;
+    }
+    #qunit-header {
+      padding: 0.5em 0 0.5em 1em;
+      color: #C2CCD1;
+      background-color: #0D3349;
+      font-size: 1.5em;
+      line-height: 1em;
+      font-weight: 400;
+      border-radius: 5px 5px 0 0;
+    }
+    #qunit-banner { height: 5px; background-color: #F0AD4E; }
+    #qunit-userAgent {
+      padding: 0.5em 1em;
+      color: #fff;
+      background-color: #EC971F;
+      text-shadow: rgba(0,0,0,.3) 2px 2px 1px;
+      font-size: small;
+    }
+    #qunit-tests { list-style: none; font-size: smaller; }
+    #qunit-tests li.warn {
+      display: list-item;
+      padding: 0.4em 1em;
+      border-bottom: 1px solid #fff;
+      color: #000;
+      background-color: #FCF8E3;
+      border-left: 5px solid #F0AD4E;
+    }
+    #qunit-tests li.warn:last-child { border-radius: 0 0 5px 5px; }
+    .qunit-assert-list { margin-top: 0.5em; padding: 0.5em; background-color: #fff; border-radius: 5px; list-style: none; }
+    .qunit-assert-list > li {
+      padding: 5px;
+      background-color: #FFF8DC;
+      border-left: 10px solid #F0AD4E;
+      color: #8A6D3B;
+    }
+    .qunit-assert-list pre {
+      font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
+      font-size: 12px;
+      line-height: 1.6;
+      white-space: pre-wrap;
+      word-break: break-word;
+      color: #8A6D3B;
+      margin: 0;
+    }
+    #qunit-testresult {
+      padding: 0.5em 1em;
+      color: #366097;
+      background-color: #E2F0F7;
+      border-bottom: 1px solid #fff;
+      font-size: small;
+    }
+    .dots span { display: inline-block; animation: pulse 1.4s ease-in-out infinite; }
+    .dots span:nth-child(2) { animation-delay: .2s; }
+    .dots span:nth-child(3) { animation-delay: .4s; }
+    @keyframes pulse { 0%,100% { opacity: .2; } 50% { opacity: 1; } }
+  </style>
+</head>
+<body>
+  <div id="qunit">
+    <h1 id="qunit-header">qunitx</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-userAgent">Warning: No Tests Registered</div>
+    <ol id="qunit-tests">
+      <li class="warn">
+        <strong>0 QUnit tests were registered in the bundled file(s)</strong>
+        <ol class="qunit-assert-list">
+          <li><pre>${escaped}</pre></li>
+        </ol>
+      </li>
+    </ol>
+    <div id="qunit-testresult">
+      Watching for changes&nbsp;<span class="dots"><span>&#9679;</span><span>&#9679;</span><span>&#9679;</span></span>
+    </div>
+  </div>
+  <script>
+    if (location.port) {
+      (function () {
+        var retries = 0;
+        function connect() {
+          var ws = new WebSocket('ws://' + location.hostname + ':' + location.port);
+          ws.addEventListener('message', function (e) { if (e.data === 'refresh') location.reload(true); });
+          ws.addEventListener('close', function () { if (retries++ < 120) setTimeout(connect, 1000); });
+          ws.addEventListener('error', function () { ws.close(); });
+        }
+        connect();
+      })();
+    }
+  </script>
+</body>
+</html>`;
+}
+function buildErrorHTML(buildError) {
+  const escaped = buildError.formatted.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <title>Build Error \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;
+      color: #C2CCD1;
+      background-color: #0D3349;
+      font-size: 1.5em;
+      line-height: 1em;
+      font-weight: 400;
+      border-radius: 5px 5px 0 0;
+    }
+    #qunit-banner { height: 5px; background-color: #EE5757; }
+    #qunit-userAgent {
+      padding: 0.5em 1em;
+      color: #fff;
+      background-color: #2B81AF;
+      text-shadow: rgba(0,0,0,.5) 2px 2px 1px;
+      font-size: small;
+    }
+    #qunit-tests { list-style: none; font-size: smaller; }
+    #qunit-tests li.fail {
+      display: list-item;
+      padding: 0.4em 1em;
+      border-bottom: 1px solid #fff;
+      color: #000;
+      background-color: #EE5757;
+    }
+    #qunit-tests li.fail:last-child { border-radius: 0 0 5px 5px; }
+    .qunit-assert-list { margin-top: 0.5em; padding: 0.5em; background-color: #fff; border-radius: 5px; list-style: none; }
+    .qunit-assert-list > li {
+      padding: 5px;
+      background-color: #fff;
+      border-left: 10px solid #EE5757;
+      color: #710909;
+    }
+    .qunit-assert-list pre {
+      font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
+      font-size: 12px;
+      line-height: 1.6;
+      white-space: pre-wrap;
+      word-break: break-word;
+      color: #710909;
+      margin: 0;
+    }
+    #qunit-testresult {
+      padding: 0.5em 1em;
+      color: #366097;
+      background-color: #E2F0F7;
+      border-bottom: 1px solid #fff;
+      font-size: small;
+    }
+    .dots span { display: inline-block; animation: pulse 1.4s ease-in-out infinite; }
+    .dots span:nth-child(2) { animation-delay: .2s; }
+    .dots span:nth-child(3) { animation-delay: .4s; }
+    @keyframes pulse { 0%,100% { opacity: .2; } 50% { opacity: 1; } }
+  </style>
+</head>
+<body>
+  <div id="qunit">
+    <h1 id="qunit-header">qunitx</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-userAgent">Build Error: ${buildError.type}</div>
+    <ol id="qunit-tests">
+      <li class="fail">
+        <strong>esbuild failed to bundle test files</strong>
+        <ol class="qunit-assert-list">
+          <li><pre>${escaped}</pre></li>
+        </ol>
+      </li>
+    </ol>
+    <div id="qunit-testresult">
+      Watching for changes&nbsp;<span class="dots"><span>&#9679;</span><span>&#9679;</span><span>&#9679;</span></span>
+    </div>
+  </div>
+  <script>
+    if (location.port) {
+      (function () {
+        var retries = 0;
+        function connect() {
+          var ws = new WebSocket('ws://' + location.hostname + ':' + location.port);
+          ws.addEventListener('message', function (e) { if (e.data === 'refresh') location.reload(true); });
+          ws.addEventListener('close', function () { if (retries++ < 120) setTimeout(connect, 1000); });
+          ws.addEventListener('error', function () { ws.close(); });
+        }
+        connect();
+      })();
+    }
+  </script>
+</body>
+</html>`;
+}
 var fsPromise;
 var init_web_server = __esm({
   "lib/setup/web-server.ts"() {
@@ -1282,21 +1531,32 @@ async function setupBrowser(config, cachedContent, existingBrowser = null) {
   perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
   const browser = resolvedExistingBrowser || await launchBrowser(config);
   const pageStart = Date.now();
-  const [page] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
+  const isHeadedWatchMode = config.open === true && config.watch;
+  const getPage = isHeadedWatchMode ? () => browser.contexts()[0]?.pages()[0] ?? browser.newPage() : () => browser.newPage();
+  const [page] = await Promise.all([getPage(), bindServerToPort(server, config)]);
   perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
   await page.addInitScript(() => {
     window.IS_PLAYWRIGHT = true;
   });
-  page.on("console", async (msg) => {
+  config._pendingConsoleHandlers = /* @__PURE__ */ new Set();
+  page.on("console", (msg) => {
     const type = msg.type();
     const alwaysShow = type === "warning" || type === "error";
     if (!alwaysShow && !config.debug) return;
-    try {
-      const values = await Promise.all(msg.args().map((arg) => arg.jsonValue()));
-      console.log(...values);
-    } catch {
-      console.log(msg.text());
-    }
+    const handler = (async () => {
+      try {
+        const values = await Promise.all(
+          msg.args().map(
+            (arg) => arg.jsonValue().catch(() => arg.evaluate((v) => JSON.stringify(v)).then(JSON.parse))
+          )
+        );
+        console.log(...values);
+      } catch {
+        console.log(msg.text());
+      }
+    })();
+    config._pendingConsoleHandlers.add(handler);
+    handler.finally(() => config._pendingConsoleHandlers?.delete(handler));
   });
   page.on("pageerror", (error) => {
     console.error(error.toString());
@@ -1388,7 +1648,7 @@ var init_run_user_module = __esm({
 });
 
 // lib/tap/display-final-result.ts
-function TAPDisplayFinalResult({ testCount, passCount, skipCount, failCount }, timeTaken) {
+function TAPDisplayFinalResult({ testCount, passCount, skipCount, todoCount, failCount }, timeTaken) {
   process.stdout.write("\n");
   process.stdout.write(`1..${testCount}
 `);
@@ -1397,6 +1657,8 @@ function TAPDisplayFinalResult({ testCount, passCount, skipCount, failCount }, t
   process.stdout.write(`# pass ${passCount}
 `);
   process.stdout.write(`# skip ${skipCount}
+`);
+  process.stdout.write(`# todo ${todoCount}
 `);
   process.stdout.write(`# fail ${failCount}
 `);
@@ -1411,7 +1673,36 @@ var init_display_final_result = __esm({
 
 // lib/commands/run/tests-in-browser.ts
 import fs9 from "node:fs/promises";
+import path5 from "node:path";
 import esbuild from "esbuild";
+function deriveBuildErrorType(error) {
+  const msgs = error?.errors ?? [];
+  const text = msgs[0]?.text ?? (error instanceof Error ? error.message : String(error));
+  if (/could not resolve|cannot find module|no such file/i.test(text))
+    return "Module Resolution Error";
+  if (/unexpected token|expected .* but found|unterminated/i.test(text)) return "Syntax Error";
+  if (/is not (defined|a function)|cannot read prop/i.test(text)) return "Reference Error";
+  return "Build Error";
+}
+function formatBuildErrors(error) {
+  const msgs = error?.errors ?? [];
+  if (msgs.length > 0) {
+    return msgs.map((msg, i) => {
+      const loc = msg.location;
+      const lineNum = loc ? String(loc.line) : "";
+      const pad = loc ? " ".repeat(lineNum.length) : "";
+      const locationLines = loc ? [
+        `    ${loc.file}:${loc.line}:${loc.column}`,
+        `  ${lineNum} \u2502 ${loc.lineText}`,
+        `  ${pad} \u2502 ${" ".repeat(loc.column)}${"~".repeat(Math.max(1, loc.length))}`
+      ] : [];
+      const noteLines = msg.notes.filter((n) => n.text).map((n) => `    Note: ${n.text}`);
+      return [`[${i + 1}] ${msg.text}`].concat(locationLines, noteLines).join("\n");
+    }).join("\n\n");
+  }
+  const raw = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return raw.replace(/\x1b\[[0-9;]*[mGKH]/g, "").replace(/\r\n/g, "\n");
+}
 async function buildTestBundle(config, cachedContent) {
   const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
@@ -1428,8 +1719,12 @@ async function buildTestBundle(config, cachedContent) {
       contents: allTestFilePaths.map((filePath) => `import "${filePath}";`).join(""),
       resolveDir: process.cwd()
     },
+    // Allow test files outside the project root (e.g. /tmp/my-test.ts) to import
+    // packages from any node_modules on the ancestor chain of cwd — the same lookup
+    // order Node itself uses when resolving require() from process.cwd().
+    nodePaths: ANCESTOR_NODE_MODULES,
     bundle: true,
-    logLevel: "error",
+    logLevel: "silent",
     outfile,
     keepNames: true,
     legalComments: "none",
@@ -1441,26 +1736,47 @@ async function buildTestBundle(config, cachedContent) {
     // all browsers and does not require changes to user test code.
     footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
   };
-  const [allTestCode] = await Promise.all([
-    config.watch ? buildIncrementally(buildOptions, allTestFilePaths.join("\0"), cachedContent, needsDisk) : buildWithOverlayfsRetry(buildOptions, needsDisk),
-    Promise.all(
-      cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
-        const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
-        if (htmlPath !== "/") {
-          await fs9.rm(targetPath, { force: true, recursive: true });
-          await fs9.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
-        }
-      })
-    )
-  ]);
-  cachedContent.allTestCode = allTestCode;
+  cachedContent._buildError = null;
+  cachedContent._noTestsWarning = null;
+  try {
+    const [allTestCode] = await Promise.all([
+      config.watch ? buildIncrementally(buildOptions, allTestFilePaths.join("\0"), cachedContent, needsDisk) : buildWithOverlayfsRetry(buildOptions, needsDisk),
+      Promise.all(
+        cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
+          const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
+          if (htmlPath !== "/") {
+            await fs9.rm(targetPath, { force: true, recursive: true });
+            await fs9.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+          }
+        })
+      )
+    ]);
+    cachedContent.allTestCode = allTestCode;
+  } catch (error) {
+    cachedContent._buildError = {
+      type: deriveBuildErrorType(error),
+      formatted: formatBuildErrors(error)
+    };
+    await fs9.writeFile(
+      `${projectRoot}/${output}/index.html`,
+      buildErrorHTML(cachedContent._buildError)
+    );
+    throw error;
+  }
 }
 async function runTestsInBrowser(config, cachedContent = {}, connections, targetTestFilesToFilter) {
   const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
   const runHasFilter = !!targetTestFilesToFilter;
   if (!config._groupMode) {
-    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
+    config.COUNTER = {
+      testCount: 0,
+      failCount: 0,
+      skipCount: 0,
+      todoCount: 0,
+      passCount: 0,
+      errorCount: 0
+    };
   }
   config.lastRanTestFiles = targetTestFilesToFilter || allTestFilePaths;
   try {
@@ -1492,11 +1808,26 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
     }
     const TIME_TAKEN = TIME_COUNTER.stop();
     if (!config._groupMode) {
+      if (config.COUNTER.testCount === 0 && !cachedContent._buildError) {
+        const displayFiles = allTestFilePaths.map(
+          (f) => f.startsWith(`${projectRoot}/`) ? f.slice(projectRoot.length + 1) : f
+        );
+        cachedContent._noTestsWarning = displayFiles;
+        const fileWord = allTestFilePaths.length === 1 ? "file" : "files";
+        console.log(
+          `# Warning: 0 tests registered \u2014 no QUnit test cases found in ${allTestFilePaths.length} ${fileWord}`
+        );
+        fs9.writeFile(`${projectRoot}/${output}/index.html`, buildNoTestsHTML(displayFiles)).catch(
+          () => {
+          }
+        );
+      }
       TAPDisplayFinalResult(config.COUNTER, TIME_TAKEN);
       if (config.after) {
         await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
       }
       if (!config.watch) {
+        await flushConsoleHandlers(config._pendingConsoleHandlers);
         await Promise.all([
           connections.server && connections.server.close(),
           connections.browser && connections.browser.close()
@@ -1507,8 +1838,18 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
     }
   } catch (error) {
     config.lastFailedTestFiles = config.lastRanTestFiles;
-    console.log(error);
     const exception = new BundleError(error);
+    if (!cachedContent._buildError && error.errors?.length) {
+      cachedContent._buildError = {
+        type: deriveBuildErrorType(error),
+        formatted: formatBuildErrors(error)
+      };
+      fs9.writeFile(
+        `${projectRoot}/${output}/qunitx.html`,
+        buildErrorHTML(cachedContent._buildError)
+      ).catch(() => {
+      });
+    }
     if (config.watch) {
       console.log(`# ${exception}`);
     } else {
@@ -1526,8 +1867,9 @@ function buildFilteredTests(filteredTests, outputPath, config) {
         contents: filteredTests.map((filePath) => `import "${filePath}";`).join(""),
         resolveDir: process.cwd()
       },
+      nodePaths: ANCESTOR_NODE_MODULES,
       bundle: true,
-      logLevel: "error",
+      logLevel: "silent",
       outfile: outputPath,
       legalComments: "none",
       target: esbuildTarget(config.browser),
@@ -1542,15 +1884,13 @@ async function runWithOverlayfsRetry(getContents, needsDisk) {
   const MAX_RETRIES = 3;
   const EMPTY_BUNDLE_THRESHOLD = 500;
   let { result, js } = await getContents();
+  const initialSize = js.length;
   for (let retry = 1; retry <= MAX_RETRIES; retry++) {
     if (js.length >= EMPTY_BUNDLE_THRESHOLD) break;
-    console.log(
-      `# [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, js } = await getContents());
   }
-  if (js.length < EMPTY_BUNDLE_THRESHOLD) {
+  if (js.length < EMPTY_BUNDLE_THRESHOLD && js.length !== initialSize) {
     console.log(
       `# [buildWithOverlayfsRetry] bundle is ${js.length} bytes after ${MAX_RETRIES} retries \u2014 proceeding`
     );
@@ -1629,7 +1969,7 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     clearTimeout(timeoutHandle);
     timeoutHandle = setTimeout(resolveTestRace, startupMs);
     await testRaceResult;
-    QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
+    QUNIT_RESULT = config._lastQUnitResult ?? await page.evaluate(() => window.QUNIT_RESULT);
   } catch (error) {
     targetError = error;
     console.log(error);
@@ -1640,14 +1980,22 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     config._onTestsJsServed = null;
     config._resetTestTimeout = null;
     config._testRunDone = null;
+    config._lastQUnitResult = null;
   }
-  if (!QUNIT_RESULT || QUNIT_RESULT.totalTests === 0) {
+  if (!QUNIT_RESULT) {
     if (targetError) console.log(targetError);
     const wsReason = !wsConnected ? "WebSocket connection never received \u2014 Chrome may be CPU-starved or the page failed to load" : "WebSocket connected but no tests ran \u2014 QUnit may have failed to start";
     console.log(`# TIMEOUT: ${wsReason}`);
     console.log("BROWSER: runtime error thrown during executing tests");
     console.error("BROWSER: runtime error thrown during executing tests");
-    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
+    await failOnNonWatchMode(
+      config.watch,
+      { server, browser },
+      config._groupMode,
+      config._pendingConsoleHandlers
+    );
+  } else if (QUNIT_RESULT.totalTests === 0) {
+    return;
   } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
     if (targetError) console.log(targetError);
     console.log(
@@ -1655,16 +2003,22 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     );
     console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
-    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
+    await failOnNonWatchMode(
+      config.watch,
+      { server, browser },
+      config._groupMode,
+      config._pendingConsoleHandlers
+    );
   } else if (QUNIT_RESULT.failedTests > config.COUNTER.failCount) {
     config.COUNTER.failCount = QUNIT_RESULT.failedTests;
   }
 }
-async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false) {
+async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false, pendingHandlers) {
   if (!watchMode) {
     if (groupMode) {
       throw new Error("Browser test run failed");
     }
+    await flushConsoleHandlers(pendingHandlers);
     await Promise.all([
       connections.server && connections.server.close(),
       connections.browser && connections.browser.close()
@@ -1673,7 +2027,12 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
     process.exit(1);
   }
 }
-var BundleError;
+async function flushConsoleHandlers(handlers, deadline = Date.now() + 2e3) {
+  if (!handlers || handlers.size === 0 || Date.now() >= deadline) return;
+  await Promise.allSettled([...handlers]);
+  return flushConsoleHandlers(handlers, deadline);
+}
+var BundleError, ancestorNodeModules, ANCESTOR_NODE_MODULES;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -1681,6 +2040,7 @@ var init_tests_in_browser = __esm({
     init_time_counter();
     init_run_user_module();
     init_display_final_result();
+    init_web_server();
     BundleError = class extends Error {
       constructor(message) {
         super(message);
@@ -1688,13 +2048,17 @@ var init_tests_in_browser = __esm({
         this.message = `esbuild Bundle Error: ${message}`.split("\n").join("\n# ");
       }
     };
+    ancestorNodeModules = (dir) => dir.split(path5.sep).map(
+      (_, i, parts) => path5.join(parts.slice(0, parts.length - i).join(path5.sep) || path5.sep, "node_modules")
+    );
+    ANCESTOR_NODE_MODULES = ancestorNodeModules(process.cwd());
   }
 });
 
 // lib/setup/file-watcher.ts
 import fs10 from "node:fs";
 import { stat, lstat } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
   const extensions = config.extensions || ["js", "ts"];
   const readyPromises = [];
@@ -1724,7 +2088,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     const lastChangeMs = {};
     const childWatcher = fs10.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready || !filename) return;
-      const fullPath = path5.join(watchPath, filename);
+      const fullPath = filename === path6.basename(watchPath) ? watchPath : path6.join(watchPath, filename);
       if (eventType === "change") {
         if (!config._building) {
           const now = Date.now();
@@ -1749,8 +2113,8 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
       }
       handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
     });
-    const parentDir = path5.dirname(watchPath);
-    const watchedBasename = path5.basename(watchPath);
+    const parentDir = path6.dirname(watchPath);
+    const watchedBasename = path6.basename(watchPath);
     let parentUnlinkFired = false;
     const parentWatcher = fs10.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
@@ -1825,7 +2189,8 @@ function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFi
     "#",
     magenta().bold("==================================================================")
   );
-  console.log("#", colorEvent(event), filePath.split(config.projectRoot)[1]);
+  const displayPath = filePath.startsWith(config.projectRoot) ? filePath.slice(config.projectRoot.length) : filePath;
+  console.log("#", colorEvent(event), displayPath);
   console.log(
     "#",
     magenta().bold("==================================================================")
@@ -1852,13 +2217,13 @@ function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFi
     }
   });
 }
-function mutateFSTree(fsTree, event, path6) {
+function mutateFSTree(fsTree, event, path7) {
   if (event === "add") {
-    fsTree[path6] = null;
+    fsTree[path7] = null;
   } else if (event === "unlink") {
-    delete fsTree[path6];
+    delete fsTree[path7];
   } else if (event === "unlinkDir") {
-    const dirPrefix = path6.endsWith("/") ? path6 : path6 + "/";
+    const dirPrefix = path7.endsWith("/") ? path7 : path7 + "/";
     for (const treePath of Object.keys(fsTree)) {
       if (treePath.startsWith(dirPrefix)) delete fsTree[treePath];
     }
@@ -1873,7 +2238,7 @@ var CHANGE_DEDUPE_MS;
 var init_file_watcher = __esm({
   "lib/setup/file-watcher.ts"() {
     init_color();
-    CHANGE_DEDUPE_MS = 30;
+    CHANGE_DEDUPE_MS = 10;
   }
 });
 
@@ -1990,14 +2355,18 @@ import { availableParallelism } from "node:os";
 async function run(config) {
   const cachedContent = await buildCachedContent(config, config.htmlPaths);
   if (config.watch) {
-    cachedContent._preBuildPromise = buildTestBundle(config, cachedContent);
+    const preBuildPromise = buildTestBundle(config, cachedContent);
+    preBuildPromise.catch(() => {
+    });
+    cachedContent._preBuildPromise = preBuildPromise;
     const [connections] = await Promise.all([
       setupBrowser(config, cachedContent),
       writeOutputStaticFiles(config, cachedContent)
     ]);
     config.expressApp = connections.server;
     setupKeyboardEvents(config, cachedContent, connections);
-    if (config.open) {
+    const isHeadedWatchMode = config.open === true && config.watch;
+    if (config.open && !isHeadedWatchMode) {
       void openOutputInBrowser(config);
     }
     if (config.before) {
@@ -2012,6 +2381,10 @@ async function run(config) {
       ]);
       throw error;
     }
+    if (isHeadedWatchMode && (cachedContent._buildError || cachedContent._noTestsWarning)) {
+      await connections.page.goto(`http://localhost:${config.port}/`, { waitUntil: "commit", timeout: 5e3 }).catch(() => {
+      });
+    }
     if (config.watch) {
       const { ready: watcherReady } = setupFileWatchers(
         config.testFileLookupPaths,
@@ -2035,7 +2408,13 @@ async function run(config) {
           }
           await runTestsInBrowser(config, cachedContent, connections, [file]);
         },
-        (_path, _event) => connections.server.publish("refresh")
+        async (_path, _event) => {
+          connections.server.publish("refresh");
+          if (isHeadedWatchMode && (cachedContent._buildError || cachedContent._noTestsWarning)) {
+            await connections.page.goto(`http://localhost:${config.port}/`, { waitUntil: "commit", timeout: 5e3 }).catch(() => {
+            });
+          }
+        }
       );
       await watcherReady;
     }
@@ -2043,8 +2422,15 @@ async function run(config) {
   } else {
     const allFiles = Object.keys(config.fsTree);
     const groupCount = Math.min(allFiles.length, availableParallelism());
-    const groups = splitIntoGroups(allFiles, groupCount);
-    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
+    const groups = await splitIntoGroups(allFiles, groupCount);
+    config.COUNTER = {
+      testCount: 0,
+      failCount: 0,
+      skipCount: 0,
+      todoCount: 0,
+      passCount: 0,
+      errorCount: 0
+    };
     config.lastRanTestFiles = allFiles;
     const groupConfigs = groups.map((groupFiles, i) => ({
       ...config,
@@ -2105,6 +2491,7 @@ async function run(config) {
             try {
               await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
             } finally {
+              await flushConsoleHandlers(groupConfig._pendingConsoleHandlers);
               await Promise.all([
                 connections.server && connections.server.close(),
                 connections.page && // Unref'd: the keepAlive interval above holds the event loop open, so this
@@ -2133,6 +2520,12 @@ async function run(config) {
       config.COUNTER.failCount > 0 ? 1 : 0
     );
     process.exitCode = exitCode;
+    if (config.COUNTER.testCount === 0 && exitCode === 0) {
+      const fileWord = allFiles.length === 1 ? "file" : "files";
+      console.log(
+        `# Warning: 0 tests registered \u2014 no QUnit test cases found in ${allFiles.length} ${fileWord}`
+      );
+    }
     TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
     if (config.after) {
       await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
@@ -2204,10 +2597,24 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
   }
   return cachedContent;
 }
-function splitIntoGroups(files, groupCount) {
-  const groups = Array.from({ length: groupCount }, () => []);
-  files.forEach((file, i) => groups[i % groupCount].push(file));
-  return groups.filter((group) => group.length > 0);
+async function splitIntoGroups(files, groupCount) {
+  const withSizes = await Promise.all(
+    files.map(
+      (f) => fs12.stat(f).then(({ size }) => ({ f, size })).catch(() => ({ f, size: 0 }))
+    )
+  );
+  return withSizes.sort((a, b) => b.size - a.size).reduce(
+    (groups, { f, size }) => {
+      const { idx } = groups.reduce(
+        (min, { total }, i) => total < min.total ? { idx: i, total } : min,
+        { idx: 0, total: groups[0].total }
+      );
+      groups[idx].files.push(f);
+      groups[idx].total += size;
+      return groups;
+    },
+    Array.from({ length: groupCount }, () => ({ files: [], total: 0 }))
+  ).flatMap((g) => g.files.length > 0 ? [g.files] : []);
 }
 function logWatcherAndKeyboardShortcutInfo(config, _server) {
   const prefix = "Watching files...";
@@ -2256,7 +2663,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.18.0",
+  version: "0.19.1",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2488,17 +2895,17 @@ function pathToModuleName(filePath) {
 async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
   const moduleName = pathToModuleName(process.argv[3]);
-  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!`);
+  const path7 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
+  if (await pathExists(path7)) {
+    console.log(`${path7} already exists!`);
     return;
   }
   const testJSContent = await readTemplate("test.js");
-  const targetFolderPaths = path6.split("/");
+  const targetFolderPaths = path7.split("/");
   targetFolderPaths.pop();
   await fs5.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs5.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
-  console.log(green(`${path6} written`));
+  await fs5.writeFile(path7, testJSContent.replace("{{moduleName}}", moduleName));
+  console.log(green(`${path7} written`));
 }
 
 // lib/setup/config.ts
@@ -2599,20 +3006,20 @@ function setupTestFilePaths(_projectRoot, inputs2) {
   });
   return result.map((metaItem) => metaItem.input);
 }
-function pathIsFile(path6) {
-  const inputs2 = path6.split("/");
+function pathIsFile(path7) {
+  const inputs2 = path7.split("/");
   return inputs2[inputs2.length - 1].includes(".");
 }
 function pathIsIncludedInPaths(paths, targetPath) {
-  return paths.some((path6) => {
-    if (path6 === targetPath) {
+  return paths.some((path7) => {
+    if (path7 === targetPath) {
       return false;
     }
-    return matchesGlob(targetPath.input, buildGlobFormat(path6));
+    return matchesGlob(targetPath.input, buildGlobFormat(path7));
   });
 }
-function buildGlobFormat(path6) {
-  return path6.isFile ? path6.input : `${path6.input}/**`;
+function buildGlobFormat(path7) {
+  return path7.isFile ? path7.input : `${path7.input}/**`;
 }
 
 // lib/utils/parse-cli-flags.ts
@@ -2666,7 +3073,9 @@ function parseCliFlags(projectRoot) {
         console.warn(`# Warning: Unknown flag "${arg}" \u2014 ignored`);
         return result;
       }
-      result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
+      result.inputs.add(
+        arg.startsWith(projectRoot) || arg.startsWith("/") ? arg : `${process.cwd()}/${arg}`
+      );
       return result;
     },
     { inputs: /* @__PURE__ */ new Set([]) }
@@ -2704,7 +3113,14 @@ async function setupConfig() {
     testFileLookupPaths: setupTestFilePaths(projectRoot, inputs2),
     lastFailedTestFiles: null,
     lastRanTestFiles: null,
-    COUNTER: { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 },
+    COUNTER: {
+      testCount: 0,
+      failCount: 0,
+      skipCount: 0,
+      todoCount: 0,
+      passCount: 0,
+      errorCount: 0
+    },
     _testRunDone: null,
     _resetTestTimeout: null,
     _onWsOpen: null,

package/package.json

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