qunitx-cli 0.17.8 → 0.19.0

package/dist/cli.js

@@ -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;
@@ -488,12 +488,18 @@ function dumpValue(value, indent) {
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";
     const next2 = `${indent}  `;
-    return "\n" + value.map((item) => `${next2}- ${dumpValue(item, next2)}`).join("\n");
+    return "\n" + value.map((item) => {
+      const v = dumpValue(item, next2);
+      return v[0] === "\n" ? `${next2}-${v}` : `${next2}- ${v}`;
+    }).join("\n");
   }
   const entries = Object.entries(value);
   if (entries.length === 0) return "{}";
   const next = `${indent}  `;
-  return "\n" + entries.map(([entryKey, entryValue]) => `${next}${entryKey}: ${dumpValue(entryValue, next)}`).join("\n");
+  return "\n" + entries.map(([entryKey, entryValue]) => {
+    const v = dumpValue(entryValue, next);
+    return v[0] === "\n" ? `${next}${entryKey}:${v}` : `${next}${entryKey}: ${v}`;
+  }).join("\n");
 }
 function yamlLine(key, value) {
   const serialized = dumpValue(value, "");
@@ -510,12 +516,12 @@ function dumpYaml({
   at
 }) {
   return `name: ${dumpString(name, "")}
-` + yamlLine("actual", actual) + yamlLine("expected", expected) + yamlLine("message", message) + yamlLine("stack", stack) + yamlLine("at", at);
+` + yamlLine("actual", actual) + yamlLine("expected", expected) + (message !== null ? yamlLine("message", message) : "") + (stack !== null ? yamlLine("stack", stack) : "") + (at !== null ? yamlLine("at", at) : "");
 }
 var NEEDS_QUOTING;
 var init_dump_yaml = __esm({
   "lib/tap/dump-yaml.ts"() {
-    NEEDS_QUOTING = /^$|^(null|true|false|~|yes|no|on|off|y|n)$|^[{[!|>'"#%@`]|^[-?:](\s|$)|^---|^[-+]?(\d|\.\d)|^\d{4}-\d{2}-\d{2}|: |#/i;
+    NEEDS_QUOTING = /^$|^\s|^(null|true|false|~|yes|no|on|off|y|n)$|^[{[!|>'"#%@`]|^[-?:](\s|$)|^---|^[-+]?(\d|\.\d)|^\d{4}-\d{2}-\d{2}|: |#/i;
   }
 });
 
@@ -538,46 +544,56 @@ function TAPDisplayTestResult(COUNTER, details) {
   COUNTER.testCount++;
   if (details.status === "skipped") {
     COUNTER.skipCount++;
-    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(" | "), "# skip");
+    process.stdout.write(`ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # skip
+`);
   } else if (details.status === "todo") {
-    console.log(`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++;
-    console.log(
-      `not ok ${COUNTER.testCount}`,
-      details.fullName.join(" | "),
-      `# (${details.runtime.toFixed(0)} ms)`
+    process.stdout.write(
+      `not ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # (${details.runtime.toFixed(0)} ms)
+`
     );
     details.assertions.forEach((assertion, index) => {
       if (!assertion.passed && assertion.todo === false) {
         COUNTER.errorCount = (COUNTER.errorCount ?? 0) + 1;
-        const stack = assertion.stack?.match(/\(.+\)/g);
-        console.log("  ---");
-        console.log(
+        process.stdout.write("  ---\n");
+        process.stdout.write(
           indentString(
             dumpYaml({
               name: `Assertion #${index + 1}`,
-              actual: assertion.actual ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
-              expected: assertion.expected ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
+              actual: assertion.actual !== null && typeof assertion.actual === "object" ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
+              expected: assertion.expected !== null && typeof assertion.expected === "object" ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
               message: assertion.message || null,
-              stack: assertion.stack || null,
-              at: stack ? stack[0].replace("(file://", "").replace(")", "") : null
+              // Trim leading/trailing whitespace: Chrome stacks start with "    at ..."
+              // (4 spaces per frame) which would otherwise render as "stack:     at ..." in YAML.
+              stack: assertion.stack?.trim() || null,
+              at: extractStackAt(assertion.stack)
             }),
             4
           )
         );
-        console.log("  ...");
+        process.stdout.write("  ...\n");
       }
     });
   } else if (details.status === "passed") {
     COUNTER.passCount++;
-    console.log(
-      `ok ${COUNTER.testCount}`,
-      details.fullName.join(" | "),
-      `# (${details.runtime.toFixed(0)} ms)`
+    process.stdout.write(
+      `ok ${COUNTER.testCount} ${details.fullName.join(" | ")} # (${details.runtime.toFixed(0)} ms)
+`
     );
   }
 }
+function extractStackAt(stack) {
+  if (!stack) return null;
+  const chromeMatch = stack.match(/\(([^)\n]+:[0-9]+:[0-9]+)\)/);
+  if (chromeMatch) return chromeMatch[1].replace("file://", "");
+  const geckoMatch = stack.match(/@([^\s\n@]+:[0-9]+:[0-9]+)/);
+  if (geckoMatch) return geckoMatch[1];
+  return null;
+}
 function getCircularReplacer() {
   const ancestors = [];
   return function(_key, value) {
@@ -728,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).
@@ -760,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) {
@@ -821,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) {
@@ -839,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;
@@ -857,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) {
@@ -898,7 +914,7 @@ function setupWebServer(config, cachedContent) {
         config._onWsOpen?.();
       } else if (event === "connection") {
         config._phase = "running";
-        if (!config._groupMode) console.log("TAP version 13");
+        if (!config._groupMode) process.stdout.write("TAP version 13\n");
         if (config.debug && config._groupMode) {
           const allFiles = Object.keys(config.fsTree);
           const relFiles = allFiles.map(
@@ -907,7 +923,8 @@ function setupWebServer(config, cachedContent) {
           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`));
+          process.stdout.write(`# ${blue(`\u2500\u2500 ${fileList} \u2500\u2500`)}
+`);
         }
         config._resetTestTimeout?.();
       } else if (event === "testEnd" && !abort) {
@@ -915,8 +932,9 @@ function setupWebServer(config, cachedContent) {
           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(" | ")}`
+          process.stdout.write(
+            `# SLOW (${details.runtime.toFixed(0)}ms / ${config.timeout}ms timeout): ${details.fullName.join(" | ")}
+`
           );
         }
         config._resetTestTimeout?.();
@@ -924,8 +942,9 @@ function setupWebServer(config, cachedContent) {
       } 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)`
+          process.stdout.write(
+            `# group done: ${details.passed} passed, ${details.failed} failed (${details.runtime}ms)
+`
           );
         }
         if (typeof config._testRunDone === "function") {
@@ -937,8 +956,9 @@ function setupWebServer(config, cachedContent) {
   });
   server.get("/tests.js", (_req, res) => {
     const bytes = cachedContent.allTestCode?.length ?? null;
-    console.log(
-      `# [HTTPServer] GET /tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (allTestCode is null)"}`
+    process.stdout.write(
+      `# [HTTPServer] GET /tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (allTestCode is null)"}
+`
     );
     if (bytes === null) {
       res.writeHead(503, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
@@ -953,8 +973,9 @@ function setupWebServer(config, cachedContent) {
   });
   server.get("/filtered-tests.js", (_req, res) => {
     const bytes = cachedContent.filteredTestCode?.length ?? null;
-    console.log(
-      `# [HTTPServer] GET /filtered-tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (filteredTestCode is null)"}`
+    process.stdout.write(
+      `# [HTTPServer] GET /filtered-tests.js \u2192 ${bytes !== null ? `${bytes} bytes` : "NOT READY (filteredTestCode is null)"}
+`
     );
     if (bytes === null) {
       res.writeHead(503, { "Content-Type": "application/javascript", "Cache-Control": "no-store" });
@@ -968,6 +989,23 @@ function setupWebServer(config, cachedContent) {
     res.end(cachedContent.filteredTestCode);
   });
   server.get("/", async (_req, res) => {
+    if (cachedContent._buildError) {
+      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return await fsPromise.writeFile(
+        `${config.projectRoot}/${config.output}/index.html`,
+        htmlContent2
+      );
+    }
+    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 TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
     const htmlContent = escapeAndInjectTestsToHTML(
       mainHTMLWithReplacedAssets,
@@ -983,6 +1021,23 @@ function setupWebServer(config, cachedContent) {
     );
   });
   server.get("/qunitx.html", async (_req, res) => {
+    if (cachedContent._buildError) {
+      const htmlContent2 = buildErrorHTML(cachedContent._buildError);
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-store" });
+      res.write(htmlContent2);
+      res.end();
+      return await fsPromise.writeFile(
+        `${config.projectRoot}/${config.output}/qunitx.html`,
+        htmlContent2
+      );
+    }
+    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 TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
     const htmlContent = escapeAndInjectTestsToHTML(
       mainHTMLWithReplacedAssets,
@@ -1026,7 +1081,10 @@ function setupWebServer(config, cachedContent) {
     } else {
       fs8.createReadStream(filePath).pipe(res);
     }
-    console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms`);
+    process.stdout.write(
+      `# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms
+`
+    );
   });
   return server;
 }
@@ -1140,7 +1198,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;
       }
 
@@ -1192,6 +1258,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"() {
@@ -1259,7 +1530,9 @@ 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;
@@ -1365,15 +1638,23 @@ var init_run_user_module = __esm({
 });
 
 // lib/tap/display-final-result.ts
-function TAPDisplayFinalResult({ testCount, passCount, skipCount, failCount }, timeTaken) {
-  console.log("");
-  console.log(`1..${testCount}`);
-  console.log(`# tests ${testCount}`);
-  console.log(`# pass ${passCount}`);
-  console.log(`# skip ${skipCount}`);
-  console.log(`# fail ${failCount}`);
-  console.log(`# duration ${timeTaken}`);
-  console.log("");
+function TAPDisplayFinalResult({ testCount, passCount, skipCount, todoCount, failCount }, timeTaken) {
+  process.stdout.write("\n");
+  process.stdout.write(`1..${testCount}
+`);
+  process.stdout.write(`# tests ${testCount}
+`);
+  process.stdout.write(`# pass ${passCount}
+`);
+  process.stdout.write(`# skip ${skipCount}
+`);
+  process.stdout.write(`# todo ${todoCount}
+`);
+  process.stdout.write(`# fail ${failCount}
+`);
+  process.stdout.write(`# duration ${timeTaken}
+`);
+  process.stdout.write("\n");
 }
 var init_display_final_result = __esm({
   "lib/tap/display-final-result.ts"() {
@@ -1382,7 +1663,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);
@@ -1399,8 +1709,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: ancestorNodeModules(process.cwd()),
     bundle: true,
-    logLevel: "error",
+    logLevel: "silent",
     outfile,
     keepNames: true,
     legalComments: "none",
@@ -1412,26 +1726,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 {
@@ -1463,6 +1798,20 @@ 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");
@@ -1478,8 +1827,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 {
@@ -1497,8 +1856,9 @@ function buildFilteredTests(filteredTests, outputPath, config) {
         contents: filteredTests.map((filePath) => `import "${filePath}";`).join(""),
         resolveDir: process.cwd()
       },
+      nodePaths: ancestorNodeModules(process.cwd()),
       bundle: true,
-      logLevel: "error",
+      logLevel: "silent",
       outfile: outputPath,
       legalComments: "none",
       target: esbuildTarget(config.browser),
@@ -1513,15 +1873,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`
     );
@@ -1612,13 +1970,15 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     config._resetTestTimeout = null;
     config._testRunDone = 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);
+  } else if (QUNIT_RESULT.totalTests === 0) {
+    return;
   } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
     if (targetError) console.log(targetError);
     console.log(
@@ -1644,7 +2004,7 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
     process.exit(1);
   }
 }
-var BundleError;
+var BundleError, ancestorNodeModules;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -1652,6 +2012,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);
@@ -1659,13 +2020,16 @@ 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")
+    );
   }
 });
 
 // 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 = [];
@@ -1695,7 +2059,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();
@@ -1720,8 +2084,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;
@@ -1796,7 +2160,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("==================================================================")
@@ -1823,13 +2188,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];
     }
@@ -1961,14 +2326,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) {
@@ -1983,6 +2352,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,
@@ -2006,7 +2379,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;
     }
@@ -2015,7 +2394,14 @@ async function run(config) {
     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 };
+    config.COUNTER = {
+      testCount: 0,
+      failCount: 0,
+      skipCount: 0,
+      todoCount: 0,
+      passCount: 0,
+      errorCount: 0
+    };
     config.lastRanTestFiles = allFiles;
     const groupConfigs = groups.map((groupFiles, i) => ({
       ...config,
@@ -2026,9 +2412,10 @@ async function run(config) {
       _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"}`
+    process.stdout.write("TAP version 13\n");
+    process.stdout.write(
+      `# Running ${allFiles.length} test file${allFiles.length === 1 ? "" : "s"} across ${groupCount} group${groupCount === 1 ? "" : "s"}
+`
     );
     const [browser] = await Promise.all([
       launchBrowser(config),
@@ -2103,6 +2490,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");
@@ -2226,7 +2619,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.17.8",
+  version: "0.19.0",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2458,17 +2851,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
@@ -2569,20 +2962,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
@@ -2636,7 +3029,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([]) }
@@ -2674,7 +3069,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.17.8",
+  "version": "0.19.0",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",