qunitx-cli 0.23.6 → 0.24.0

package/dist/cli.js

@@ -374,7 +374,7 @@ var init_package = __esm({
     package_default = {
       name: "qunitx-cli",
       type: "module",
-      version: "0.23.6",
+      version: "0.24.0",
       description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
       author: "Izel Nakri",
       license: "MIT",
@@ -519,6 +519,8 @@ ${color("--browser")} : browser engine to run tests in: chromium, firefox, webki
 ${color("--before")} : run a script before the tests(i.e start a new web server before tests)
 ${color("--after")} : run a script after the tests(i.e save test results to a file)
 ${color("--no-daemon")} : don't use the daemon for this run \u2014 skips a running daemon and prevents ${color("QUNITX_DAEMON")} auto-spawn
+${color("--changed")} : run only test files affected by changes since ${color("HEAD")} (requires git; falls back to running all on first use)
+${color("--since")} : run only test files affected by changes since the given git ref (e.g. ${color("--since=main")}); ${color("--changed")} = ${color("--since=HEAD")}
 ${color("--trace-perf")} : write timestamped startup-perf trace lines to stderr (Chrome pre-launch, module load, browser bind)
 
 ${highlight("Example:")} $ ${color("qunitx test/foo.ts app/e2e --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js")}
@@ -547,9 +549,9 @@ var init_help = __esm({
 
 // lib/utils/path-exists.ts
 import fs2 from "node:fs/promises";
-async function pathExists(path14) {
+async function pathExists(path17) {
   try {
-    await fs2.access(path14);
+    await fs2.access(path17);
     return true;
   } catch {
     return false;
@@ -641,17 +643,17 @@ import fs4 from "node:fs/promises";
 async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
   const moduleName = pathToModuleName(process.argv[3]);
-  const path14 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
-  if (await pathExists(path14)) {
-    console.log(`${path14} already exists!`);
+  const path17 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
+  if (await pathExists(path17)) {
+    console.log(`${path17} already exists!`);
     return;
   }
   const testJSContent = await readTemplate("test.js");
-  const targetFolderPaths = path14.split("/");
+  const targetFolderPaths = path17.split("/");
   targetFolderPaths.pop();
   await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs4.writeFile(path14, testJSContent.replace("{{moduleName}}", moduleName));
-  console.log(green(`${path14} written`));
+  await fs4.writeFile(path17, testJSContent.replace("{{moduleName}}", moduleName));
+  console.log(green(`${path17} written`));
 }
 function pathToModuleName(filePath) {
   const withoutExt = filePath.replace(/\.(js|ts)$/, "");
@@ -892,9 +894,9 @@ async function pingDaemon() {
   socket.end();
   return pong;
 }
-async function shutdownDaemon() {
-  const pid = await readDaemonPid();
-  const socket = await tryConnect();
+async function shutdownDaemon(cwd = process.cwd()) {
+  const pid = await readDaemonPid(cwd);
+  const socket = await tryConnect(cwd);
   if (!socket) return false;
   attachLineParser(socket, () => {
   });
@@ -903,9 +905,9 @@ async function shutdownDaemon() {
   if (pid !== null) await waitForPidExit(pid, SHUTDOWN_PID_WAIT_MS);
   return true;
 }
-async function readDaemonPid() {
+async function readDaemonPid(cwd = process.cwd()) {
   try {
-    const info = JSON.parse(await fs6.readFile(daemonInfoPath(), "utf8"));
+    const info = JSON.parse(await fs6.readFile(daemonInfoPath(cwd), "utf8"));
     return typeof info.pid === "number" ? info.pid : null;
   } catch {
     return null;
@@ -1068,11 +1070,11 @@ function setupTestFilePaths(inputs2) {
   }, []);
   return dedupedFolders.concat(dedupedGlobFiles, dedupedPlainFiles).map((meta) => meta.input);
 }
-function pathIsFile(path14) {
-  return path14.includes(".", path14.lastIndexOf("/") + 1);
+function pathIsFile(path17) {
+  return path17.includes(".", path17.lastIndexOf("/") + 1);
 }
 function isIncludedIn(paths, target) {
-  return paths.some((path14) => path14 !== target && matchesGlob(target.input, path14.globFormat));
+  return paths.some((path17) => path17 !== target && matchesGlob(target.input, path17.globFormat));
 }
 function isGlob2(str) {
   return GLOB_CHARS.test(str);
@@ -1084,8 +1086,162 @@ var init_test_file_paths = __esm({
   }
 });
 
-// lib/utils/parse-cli-flags.ts
+// lib/utils/get-changed-files.ts
 import path5 from "node:path";
+function getChangedFiles(metafile, esbuildCwd, changedAbsPaths, testFiles) {
+  const deps = new Map(
+    Object.entries(metafile.inputs).map(([relPath, info]) => [
+      path5.resolve(esbuildCwd, relPath),
+      (info.imports ?? []).map((i) => path5.resolve(esbuildCwd, i.path))
+    ])
+  );
+  const memo = /* @__PURE__ */ new Map();
+  return new Set(
+    testFiles.filter((test) => reachesChange(test, deps, changedAbsPaths, memo, /* @__PURE__ */ new Set()))
+  );
+}
+function reachesChange(node, deps, changedAbsPaths, memo, stack) {
+  const cached = memo.get(node);
+  if (cached !== void 0) return cached;
+  if (stack.has(node)) return false;
+  stack.add(node);
+  const result2 = changedAbsPaths.has(node) || (deps.get(node) ?? []).some((dep) => reachesChange(dep, deps, changedAbsPaths, memo, stack));
+  stack.delete(node);
+  memo.set(node, result2);
+  return result2;
+}
+var init_get_changed_files = __esm({
+  "lib/utils/get-changed-files.ts"() {
+  }
+});
+
+// lib/utils/get-changed-file-paths-in-git-since.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path6 from "node:path";
+async function getChangedFilePathsInGitSince(projectRoot, ref) {
+  const [diffOut, statusOut] = await Promise.all([
+    execFileAsync("git", ["diff", "--name-only", "--no-renames", ref, "--", projectRoot], {
+      cwd: projectRoot,
+      maxBuffer: 16 * 1024 * 1024
+    }).then((r) => r.stdout),
+    execFileAsync("git", ["status", "--porcelain", "--untracked-files=all"], {
+      cwd: projectRoot,
+      maxBuffer: 16 * 1024 * 1024
+    }).then((r) => r.stdout)
+  ]);
+  const fromStatus = (line) => {
+    const rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    return arrow === -1 ? rest : rest.slice(arrow + 4);
+  };
+  const relPaths = /* @__PURE__ */ new Set([
+    ...diffOut.split("\n").filter(Boolean),
+    ...statusOut.split("\n").filter((l) => l.length >= 4).map(fromStatus)
+  ]);
+  const isBlastRadius = (rel) => {
+    const base = path6.basename(rel);
+    return BLAST_RADIUS_FILES.has(base) || BLAST_RADIUS_PATTERNS.some((re) => re.test(base));
+  };
+  if (Array.from(relPaths).some(isBlastRadius)) return null;
+  return new Set(Array.from(relPaths, (rel) => path6.resolve(projectRoot, rel)));
+}
+var execFileAsync, BLAST_RADIUS_FILES, BLAST_RADIUS_PATTERNS;
+var init_get_changed_file_paths_in_git_since = __esm({
+  "lib/utils/get-changed-file-paths-in-git-since.ts"() {
+    execFileAsync = promisify(execFile);
+    BLAST_RADIUS_FILES = /* @__PURE__ */ new Set(["package.json", "package-lock.json", "deno.json", "deno.lock"]);
+    BLAST_RADIUS_PATTERNS = [/^tsconfig.*\.json$/];
+  }
+});
+
+// lib/utils/metafile-cache.ts
+import fs8 from "node:fs/promises";
+import path7 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+function metafileCachePath(projectRoot) {
+  const tag = createHash2("sha1").update(projectRoot).digest("hex").slice(0, 12);
+  return path7.join(projectRoot, "node_modules", ".cache", "qunitx", tag, CACHE_FILE);
+}
+async function writeMetafileCache(projectRoot, esbuildCwd, metafile) {
+  const file = metafileCachePath(projectRoot);
+  try {
+    await fs8.mkdir(path7.dirname(file), { recursive: true });
+    await fs8.writeFile(
+      file,
+      JSON.stringify({ esbuildCwd, metafile })
+    );
+  } catch {
+  }
+}
+async function readMetafileCache(projectRoot) {
+  try {
+    const raw = await fs8.readFile(metafileCachePath(projectRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.esbuildCwd !== "string" || !parsed.metafile?.inputs) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+var CACHE_FILE;
+var init_metafile_cache = __esm({
+  "lib/utils/metafile-cache.ts"() {
+    CACHE_FILE = "metafile.json";
+  }
+});
+
+// lib/setup/get-changed-fs-tree.ts
+async function getChangedFsTree(fsTree, projectRoot, changedSince) {
+  const testFiles = Object.keys(fsTree);
+  if (testFiles.length === 0) return fsTree;
+  const cache = await readMetafileCache(projectRoot);
+  if (!cache) {
+    process.stdout.write(
+      `# --changed: no metafile cache yet \u2014 running all ${testFiles.length} test files (cache populates on this run)
+`
+    );
+    return fsTree;
+  }
+  const changed = await getChangedFilePathsInGitSince(projectRoot, changedSince).catch(
+    (err) => err
+  );
+  if (changed instanceof Error) {
+    process.stdout.write(
+      `# --changed: git lookup failed (${changed.message.split("\n")[0]}) \u2014 running all ${testFiles.length} test files
+`
+    );
+    return fsTree;
+  } else if (changed === null) {
+    process.stdout.write(
+      `# --changed: blast-radius file changed (package.json / tsconfig.json / lockfile) \u2014 running all ${testFiles.length} test files
+`
+    );
+    return fsTree;
+  } else if (changed.size === 0) {
+    process.stdout.write(
+      `# --changed: 0 files changed since ${changedSince} \u2014 running 0 test files
+`
+    );
+    return {};
+  }
+  const affected = getChangedFiles(cache.metafile, cache.esbuildCwd, changed, testFiles);
+  process.stdout.write(
+    `# --changed: ${affected.size} of ${testFiles.length} test files affected by changes since ${changedSince}
+`
+  );
+  return Object.fromEntries(testFiles.filter((f) => affected.has(f)).map((f) => [f, null]));
+}
+var init_get_changed_fs_tree = __esm({
+  "lib/setup/get-changed-fs-tree.ts"() {
+    init_get_changed_files();
+    init_get_changed_file_paths_in_git_since();
+    init_metafile_cache();
+  }
+});
+
+// lib/utils/parse-cli-flags.ts
+import path8 from "node:path";
 function parseCliFlags(projectRoot) {
   const providedFlags = process.argv.slice(2).reduce(
     (result2, arg) => {
@@ -1129,6 +1285,15 @@ function parseCliFlags(projectRoot) {
         return Object.assign(result2, { before: parseModule(arg.split("=")[1]) });
       } else if (arg.startsWith("--after")) {
         return Object.assign(result2, { after: parseModule(arg.split("=")[1]) });
+      } else if (arg === "--changed") {
+        return Object.assign(result2, { changedSince: "HEAD" });
+      } else if (arg.startsWith("--since")) {
+        const ref = arg.split("=")[1];
+        if (!ref) {
+          console.error(`Invalid --since value: empty. Expected --since=<git-ref>.`);
+          process.exit(1);
+        }
+        return Object.assign(result2, { changedSince: ref });
       } else if (arg === "--trace-perf") {
         return result2;
       }
@@ -1137,7 +1302,7 @@ function parseCliFlags(projectRoot) {
         return result2;
       }
       result2.inputs.add(
-        arg.startsWith(projectRoot) || arg.startsWith("/") ? arg : path5.join(process.cwd(), arg)
+        arg.startsWith(projectRoot) || path8.isAbsolute(arg) ? arg : path8.join(process.cwd(), arg)
       );
       return result2;
     },
@@ -1185,7 +1350,7 @@ __export(config_exports, {
   default: () => setupConfig,
   setupConfig: () => setupConfig
 });
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 async function setupConfig() {
@@ -1223,10 +1388,13 @@ async function setupConfig() {
     buildFSTree(config.testFileLookupPaths, config),
     pluginsPromise
   ]);
+  if (config.changedSince && !config.watch) {
+    config.fsTree = await getChangedFsTree(config.fsTree, config.projectRoot, config.changedSince);
+  }
   return config;
 }
 async function readConfigFromPackageJSON(projectRoot) {
-  const packageJSON = await fs8.readFile(`${projectRoot}/package.json`);
+  const packageJSON = await fs9.readFile(`${projectRoot}/package.json`);
   return JSON.parse(packageJSON.toString());
 }
 function normalizeHTMLPaths(projectRoot, htmlPaths) {
@@ -1258,6 +1426,7 @@ var init_config = __esm({
     init_find_project_root();
     init_fs_tree();
     init_test_file_paths();
+    init_get_changed_fs_tree();
     init_parse_cli_flags();
   }
 });
@@ -1529,13 +1698,13 @@ function extractSourceLine(content, lineIndex) {
   const line = content.split("\n", lineIndex + 1)[lineIndex];
   return line?.trim() || null;
 }
-function normalizePosix(path14) {
-  const parts = path14.split("/").reduce((acc, part) => {
+function normalizePosix(path17) {
+  const parts = path17.split("/").reduce((acc, part) => {
     if (part === "..") acc.pop();
     else if (part && part !== ".") acc.push(part);
     return acc;
   }, []);
-  return (path14.startsWith("/") ? "/" : "") + parts.join("/");
+  return (path17.startsWith("/") ? "/" : "") + parts.join("/");
 }
 function toAbsolutePath(rawSource, outDir, sourceRoot) {
   if (rawSource.startsWith("file://")) return rawSource.slice(7);
@@ -1543,8 +1712,8 @@ function toAbsolutePath(rawSource, outDir, sourceRoot) {
   const base = sourceRoot ? normalizePosix(`${outDir}/${sourceRoot}`) : outDir;
   return normalizePosix(`${base}/${rawSource}`);
 }
-function isNodeModulesPath(path14) {
-  return path14.includes("/node_modules/") || path14.includes("\\node_modules\\");
+function isNodeModulesPath(path17) {
+  return path17.includes("/node_modules/") || path17.includes("\\node_modules\\");
 }
 function makeDisplayPath(absolutePath, projectRoot) {
   const prefix = projectRoot + "/";
@@ -1820,8 +1989,8 @@ var init_web = __esm({
         });
       }
       /** Registers a GET route handler. */
-      get(path14, handler) {
-        this.#registerRouteHandler("GET", path14, handler);
+      get(path17, handler) {
+        this.#registerRouteHandler("GET", path17, handler);
       }
       /**
        * Starts listening on the given port (0 = OS-assigned).
@@ -1852,32 +2021,32 @@ var init_web = __esm({
         });
       }
       /** Registers a POST route handler. */
-      post(path14, handler) {
-        this.#registerRouteHandler("POST", path14, handler);
+      post(path17, handler) {
+        this.#registerRouteHandler("POST", path17, handler);
       }
       /** Registers a DELETE route handler. */
-      delete(path14, handler) {
-        this.#registerRouteHandler("DELETE", path14, handler);
+      delete(path17, handler) {
+        this.#registerRouteHandler("DELETE", path17, handler);
       }
       /** Registers a PUT route handler. */
-      put(path14, handler) {
-        this.#registerRouteHandler("PUT", path14, handler);
+      put(path17, handler) {
+        this.#registerRouteHandler("PUT", path17, handler);
       }
       /** Adds a middleware function to the chain. */
       use(middleware) {
         this.middleware.push(middleware);
       }
-      #registerRouteHandler(method, path14, handler) {
+      #registerRouteHandler(method, path17, handler) {
         if (!this.routes[method]) {
           this.routes[method] = {};
         }
-        const paramNames = this.#extractParamNames(path14);
-        this.routes[method][path14] = {
-          path: path14,
+        const paramNames = this.#extractParamNames(path17);
+        this.routes[method][path17] = {
+          path: path17,
           handler,
           paramNames,
-          isWildcard: path14 === "/*",
-          compiledRegex: paramNames.length > 0 ? new RegExp(`^${this.#buildRegexPattern(path14, paramNames)}$`) : null
+          isWildcard: path17 === "/*",
+          compiledRegex: paramNames.length > 0 ? new RegExp(`^${this.#buildRegexPattern(path17, paramNames)}$`) : null
         };
       }
       #handleRequest(req, res) {
@@ -1915,11 +2084,11 @@ var init_web = __esm({
           return null;
         }
         return routes[url] || Object.values(routes).find((route) => {
-          const { path: path14, isWildcard } = route;
-          if (!isWildcard && !path14.includes(":")) {
+          const { path: path17, isWildcard } = route;
+          if (!isWildcard && !path17.includes(":")) {
             return false;
           }
-          if (isWildcard || this.#matchPathSegments(path14, url)) {
+          if (isWildcard || this.#matchPathSegments(path17, url)) {
             if (route.compiledRegex) {
               const regexMatches = route.compiledRegex.exec(url);
               if (regexMatches) {
@@ -1931,8 +2100,8 @@ var init_web = __esm({
           return false;
         }) || null;
       }
-      #matchPathSegments(path14, url) {
-        const pathSegments = path14.split("/");
+      #matchPathSegments(path17, url) {
+        const pathSegments = path17.split("/");
         const urlSegments = url.split("/");
         if (pathSegments.length !== urlSegments.length) {
           return false;
@@ -1949,14 +2118,14 @@ var init_web = __esm({
         }
         return true;
       }
-      #buildRegexPattern(path14, _paramNames) {
-        let regexPattern = path14.replace(/:[^/]+/g, "([^/]+)");
+      #buildRegexPattern(path17, _paramNames) {
+        let regexPattern = path17.replace(/:[^/]+/g, "([^/]+)");
         regexPattern = regexPattern.replace(/\//g, "\\/");
         return regexPattern;
       }
-      #extractParamNames(path14) {
+      #extractParamNames(path17) {
         const paramRegex = /:(\w+)/g;
-        const paramMatches = path14.match(paramRegex);
+        const paramMatches = path17.match(paramRegex);
         return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
       }
       #extractParams(route, _url) {
@@ -1972,10 +2141,10 @@ var init_web = __esm({
 });
 
 // lib/setup/web-server.ts
-import fs9 from "node:fs";
-import path6 from "node:path";
+import fs10 from "node:fs";
+import path9 from "node:path";
 function setupWebServer(config, cachedContent) {
-  const STATIC_FILES_PATH = path6.resolve(config.projectRoot, config.output);
+  const STATIC_FILES_PATH = path9.resolve(config.projectRoot, config.output);
   const server = new HTTPServer();
   const mainHTMLWithReplacedAssets = replaceAssetPaths(
     cachedContent.mainHTML.html,
@@ -2113,7 +2282,7 @@ function setupWebServer(config, cachedContent) {
         config._testRunDone = null;
       }
       return saveHTML(
-        path6.join(path6.resolve(config.projectRoot, config.output), "index.html"),
+        path9.join(path9.resolve(config.projectRoot, config.output), "index.html"),
         htmlContent
       );
     }
@@ -2124,7 +2293,7 @@ function setupWebServer(config, cachedContent) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainIndexHTML);
     saveHTML(
-      path6.join(path6.resolve(config.projectRoot, config.output), "index.html"),
+      path9.join(path9.resolve(config.projectRoot, config.output), "index.html"),
       mainIndexHTML
     );
   });
@@ -2134,7 +2303,7 @@ function setupWebServer(config, cachedContent) {
       res.writeHead(200, HTML_HEADERS);
       res.end(htmlContent);
       return saveHTML(
-        path6.join(path6.resolve(config.projectRoot, config.output), "qunitx.html"),
+        path9.join(path9.resolve(config.projectRoot, config.output), "qunitx.html"),
         htmlContent
       );
     }
@@ -2145,7 +2314,7 @@ function setupWebServer(config, cachedContent) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainQunitxHTML);
     saveHTML(
-      path6.join(path6.resolve(config.projectRoot, config.output), "qunitx.html"),
+      path9.join(path9.resolve(config.projectRoot, config.output), "qunitx.html"),
       mainQunitxHTML
     );
   });
@@ -2159,14 +2328,14 @@ function setupWebServer(config, cachedContent) {
       );
       res.writeHead(200, HTML_HEADERS);
       res.end(htmlContent);
-      saveHTML(path6.join(path6.resolve(config.projectRoot, config.output), req.path), htmlContent);
+      saveHTML(path9.join(path9.resolve(config.projectRoot, config.output), req.path), htmlContent);
       return;
     }
     const url = req.url;
     const requestStartedAt = Date.now();
     const filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join("");
-    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path6.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
-    const stream = fs9.createReadStream(filePath);
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path9.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs10.createReadStream(filePath);
     stream.on("open", () => {
       res.writeHead(200, { "Content-Type": contentType });
       stream.pipe(res);
@@ -2419,7 +2588,7 @@ function registerGroupRoutes(server, groupConfig, groupCachedContent, groupId) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainGroupHTML);
     saveHTML(
-      path6.join(path6.resolve(groupConfig.projectRoot, groupConfig.output), "index.html"),
+      path9.join(path9.resolve(groupConfig.projectRoot, groupConfig.output), "index.html"),
       mainGroupHTML
     );
   });
@@ -2505,11 +2674,11 @@ function registerSharedStaticHandler(server, groupConfigs) {
       res.end("Not found");
       return;
     }
-    const STATIC_FILES_PATH = path6.resolve(groupConfig.projectRoot, groupConfig.output);
+    const STATIC_FILES_PATH = path9.resolve(groupConfig.projectRoot, groupConfig.output);
     const subPath = match[2] || "/";
     const filePath = (subPath.endsWith("/") ? [STATIC_FILES_PATH, subPath, "index.html"] : [STATIC_FILES_PATH, subPath]).join("");
-    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path6.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
-    const stream = fs9.createReadStream(filePath);
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path9.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs10.createReadStream(filePath);
     stream.on("open", () => {
       res.writeHead(200, { "Content-Type": contentType });
       stream.pipe(res);
@@ -2524,7 +2693,7 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
   const assetPaths = findInternalAssetsFromHTML(html);
   const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
   return assetPaths.reduce((result2, assetPath) => {
-    const normalizedFullAbsolutePath = path6.normalize(`${htmlDirectory}/${assetPath}`);
+    const normalizedFullAbsolutePath = path9.normalize(`${htmlDirectory}/${assetPath}`);
     return result2.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
@@ -2686,7 +2855,7 @@ var init_web_server = __esm({
     init_display_test_result();
     init_color();
     init_web();
-    fsPromise = fs9.promises;
+    fsPromise = fs10.promises;
     HTML_HEADERS = { "Content-Type": "text/html", "Cache-Control": "no-store" };
     WATCH_WS_RECONNECT_INTERVAL_MS = 1e3;
     WATCH_WS_RECONNECT_MAX_RETRIES = 120;
@@ -2905,8 +3074,8 @@ var init_display_final_result = __esm({
 });
 
 // lib/commands/run/tests-in-browser.ts
-import fs10 from "node:fs/promises";
-import path7 from "node:path";
+import fs11 from "node:fs/promises";
+import path10 from "node:path";
 import esbuild from "esbuild";
 function deriveBuildErrorType(error) {
   const msgs = error?.errors ?? [];
@@ -2946,9 +3115,9 @@ async function buildTestBundle(config, cachedContent) {
     console.log("# [buildTestBundle] fsTree is empty \u2014 skipping build (no test files found)");
     return;
   }
-  const outDir = path7.resolve(projectRoot, output);
-  const outfile = path7.join(outDir, "tests.js");
-  await fs10.mkdir(outDir, { recursive: true });
+  const outDir = path10.resolve(projectRoot, output);
+  const outfile = path10.join(outDir, "tests.js");
+  await fs11.mkdir(outDir, { recursive: true });
   const sourcemap = "inline";
   const needsDisk = true;
   const buildOptions = {
@@ -2972,6 +3141,10 @@ async function buildTestBundle(config, cachedContent) {
     // tsconfig's `jsxImportSource` or a `@jsxImportSource <pkg>` pragma cover Vue/Preact/Solid.
     jsx: "automatic",
     plugins: config.plugins,
+    // Required for --changed/--since dep-graph filter on subsequent runs (cache
+    // populates here, reads in setupConfig). Inputs map carries the full reverse-dep
+    // graph; output cost is negligible.
+    metafile: true,
     // 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
@@ -2983,32 +3156,33 @@ async function buildTestBundle(config, cachedContent) {
   const cacheHolder = config._daemonEsbuildCache ?? cachedContent;
   const fileKey = bundleCacheKey(buildOptions, allTestFilePaths);
   try {
-    const [allTestCode] = await Promise.all([
+    const [{ js: allTestCode, metafile }] = await Promise.all([
       config.watch || config._daemonMode ? buildIncrementally(buildOptions, fileKey, cacheHolder, needsDisk) : buildWithOverlayfsRetry(buildOptions, needsDisk),
       Promise.all(
         cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
-          const targetPath = path7.join(outDir, htmlPath);
+          const targetPath = path10.join(outDir, htmlPath);
           if (htmlPath !== "/") {
-            await fs10.rm(targetPath, { force: true, recursive: true });
-            await fs10.mkdir(path7.dirname(targetPath), { recursive: true });
+            await fs11.rm(targetPath, { force: true, recursive: true });
+            await fs11.mkdir(path10.dirname(targetPath), { recursive: true });
           }
         })
       )
     ]);
     cachedContent.allTestCode = allTestCode;
     config._sourceMapDecoder = extractInlineSourceMap(allTestCode, outDir);
+    if (metafile) void writeMetafileCache(projectRoot, process.cwd(), metafile);
   } catch (error) {
     cachedContent._buildError = {
       type: deriveBuildErrorType(error),
       formatted: formatBuildErrors(error)
     };
-    await fs10.writeFile(path7.join(outDir, "index.html"), buildErrorHTML(cachedContent._buildError));
+    await fs11.writeFile(path10.join(outDir, "index.html"), buildErrorHTML(cachedContent._buildError));
     throw error;
   }
 }
 async function runTestsInBrowser(config, cachedContent = {}, connections, targetTestFilesToFilter) {
   const { projectRoot, output } = config;
-  const outDir = path7.resolve(projectRoot, output);
+  const outDir = path10.resolve(projectRoot, output);
   const allTestFilePaths = Object.keys(config.fsTree);
   const runHasFilter = !!targetTestFilesToFilter;
   if (!config._groupMode) {
@@ -3036,7 +3210,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
       return connections;
     }
     if (runHasFilter) {
-      const outputPath = path7.join(outDir, "filtered-tests.js");
+      const outputPath = path10.join(outDir, "filtered-tests.js");
       cachedContent.filteredTestCode = await buildFilteredTests(
         targetTestFilesToFilter,
         outputPath,
@@ -3076,7 +3250,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         console.log(
           `# Warning: 0 tests registered \u2014 no QUnit test cases found in ${allTestFilePaths.length} ${fileWord}`
         );
-        fs10.writeFile(path7.join(outDir, "index.html"), buildNoTestsHTML(displayFiles)).catch(
+        fs11.writeFile(path10.join(outDir, "index.html"), buildNoTestsHTML(displayFiles)).catch(
           () => {
           }
         );
@@ -3108,8 +3282,8 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         type: deriveBuildErrorType(error),
         formatted: formatBuildErrors(error)
       };
-      fs10.writeFile(
-        path7.join(outDir, "qunitx.html"),
+      fs11.writeFile(
+        path10.join(outDir, "qunitx.html"),
         buildErrorHTML(cachedContent._buildError)
       ).catch(
         (err) => config.debug && process.stderr.write(`# [qunitx] writeFile qunitx.html: ${err.message}
@@ -3159,7 +3333,7 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
     );
   await Promise.all(
     activeGroups.map(
-      (group) => fs10.mkdir(path7.resolve(group.config.projectRoot, group.config.output), { recursive: true })
+      (group) => fs11.mkdir(path10.resolve(group.config.projectRoot, group.config.output), { recursive: true })
     )
   );
   const sourcemap = "inline";
@@ -3179,7 +3353,7 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
       });
     }
   };
-  const esbuildOutdir = path7.join(projectRoot, "tmp");
+  const esbuildOutdir = path10.join(projectRoot, "tmp");
   const buildOptions = {
     entryPoints: activeGroups.map((_, slotIndex) => ({
       in: `group-entry-${slotIndex}`,
@@ -3201,6 +3375,9 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
     sourcemap,
     write: false,
     jsx: "automatic",
+    // Required for --changed/--since dep-graph filter on subsequent runs. Same
+    // contract as the single-group path in `buildTestBundle`.
+    metafile: true,
     footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
   };
   const hasSmallOutput = (result2) => (result2.outputFiles ?? []).some(
@@ -3221,8 +3398,8 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
         const slotIndex = parseInt(match[1]);
         const isMap = Boolean(match[2]);
         const { config, cachedContent } = activeGroups[slotIndex];
-        const destPath = path7.join(
-          path7.resolve(config.projectRoot, config.output),
+        const destPath = path10.join(
+          path10.resolve(config.projectRoot, config.output),
           "tests.js" + (isMap ? ".map" : "")
         );
         if (!isMap) {
@@ -3232,17 +3409,20 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
             esbuildOutdir
           );
         }
-        return fs10.writeFile(destPath, outputFile.contents);
+        return fs11.writeFile(destPath, outputFile.contents);
       })
     );
+    if (result2.metafile) {
+      void writeMetafileCache(projectRoot, process.cwd(), result2.metafile);
+    }
   } catch (error) {
     const buildError = { type: deriveBuildErrorType(error), formatted: formatBuildErrors(error) };
     const errorHtml = buildErrorHTML(buildError);
     await Promise.all(
       activeGroups.map((group) => {
         group.cachedContent._buildError = buildError;
-        return fs10.writeFile(
-          path7.join(path7.resolve(group.config.projectRoot, group.config.output), "index.html"),
+        return fs11.writeFile(
+          path10.join(path10.resolve(group.config.projectRoot, group.config.output), "index.html"),
           errorHtml
         ).catch(
           (err) => debug && process.stderr.write(`# [qunitx] writeFile index.html: ${err.message}
@@ -3274,7 +3454,7 @@ function buildFilteredTests(filteredTests, outputPath, config) {
       footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
     },
     needsDisk
-  );
+  ).then((r) => r.js);
 }
 async function runWithOverlayfsRetry(getContents, needsDisk) {
   let { result: result2, js } = await getContents();
@@ -3291,10 +3471,10 @@ async function runWithOverlayfsRetry(getContents, needsDisk) {
   }
   if (needsDisk) {
     await Promise.all(
-      result2.outputFiles.map((outputFile) => fs10.writeFile(outputFile.path, outputFile.contents))
+      result2.outputFiles.map((outputFile) => fs11.writeFile(outputFile.path, outputFile.contents))
     );
   }
-  return js;
+  return { js, metafile: result2.metafile };
 }
 function buildWithOverlayfsRetry(options, needsDisk) {
   const buildOpts = { ...options, write: false };
@@ -3428,9 +3608,9 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
   process.exit(1);
 }
 function toEsbuildImportPath(filePath) {
-  const rel = path7.relative(process.cwd(), filePath);
+  const rel = path10.relative(process.cwd(), filePath);
   const normalized = rel.replace(/\\/g, "/");
-  if (path7.isAbsolute(rel)) return filePath.replace(/\\/g, "/");
+  if (path10.isAbsolute(rel)) return filePath.replace(/\\/g, "/");
   return normalized.startsWith(".") ? normalized : "./" + normalized;
 }
 var ancestorNodeModules, ANCESTOR_NODE_MODULES, RETRY_DELAY_MS, MAX_RETRIES, EMPTY_BUNDLE_THRESHOLD, NAV_GRACE_MS, MAX_NAV_SLOWDOWN_FACTOR, MIN_NAV_MS, STARTUP_TIMEOUT_FACTOR, TESTS_JS_TIMEOUT_FACTOR, CONSOLE_FLUSH_TIMEOUT_MS, TEST_STALL_BUFFER_MS, GROUP_OUTPUT_REGEX, BundleError, DaemonRunError;
@@ -3444,8 +3624,9 @@ var init_tests_in_browser = __esm({
     init_display_final_result();
     init_web_server();
     init_source_map_decoder();
-    ancestorNodeModules = (dir) => dir.split(path7.sep).map(
-      (_, i, parts) => path7.join(parts.slice(0, parts.length - i).join(path7.sep) || path7.sep, "node_modules")
+    init_metafile_cache();
+    ancestorNodeModules = (dir) => dir.split(path10.sep).map(
+      (_, i, parts) => path10.join(parts.slice(0, parts.length - i).join(path10.sep) || path10.sep, "node_modules")
     );
     ANCESTOR_NODE_MODULES = ancestorNodeModules(process.cwd());
     RETRY_DELAY_MS = 100;
@@ -3481,11 +3662,11 @@ var init_tests_in_browser = __esm({
 
 // lib/utils/open-output-in-browser.ts
 import { spawn as spawn2 } from "node:child_process";
-import path8 from "node:path";
+import path11 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 async function openOutputInBrowser(config) {
   try {
-    const outputFile = config.watch ? `http://localhost:${config.port}` : pathToFileURL3(path8.join(path8.resolve(config.projectRoot, config.output), "index.html")).href;
+    const outputFile = config.watch ? `http://localhost:${config.port}` : pathToFileURL3(path11.join(path11.resolve(config.projectRoot, config.output), "index.html")).href;
     if (typeof config.open === "string") {
       spawnDetached(config.open, [outputFile]);
       return;
@@ -3518,9 +3699,9 @@ var init_open_output_in_browser = __esm({
 });
 
 // lib/setup/file-watcher.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import { readdir, stat, lstat } from "node:fs/promises";
-import path9 from "node:path";
+import path12 from "node:path";
 function recordJustAdded(config, filePath) {
   let map = justAddedAt.get(config);
   if (!map) justAddedAt.set(config, map = /* @__PURE__ */ new Map());
@@ -3539,19 +3720,27 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     if (symlinkPollers.has(filePath)) return;
     const handler = (curr, prev) => {
       if (curr.nlink === 0) {
-        fs11.unwatchFile(filePath, handler);
+        fs12.unwatchFile(filePath, handler);
         symlinkPollers.delete(filePath);
         if (filePath in config.fsTree) {
           handleWatchEvent(config, extensions, "unlink", filePath, onEventFunc, onFinishFunc);
         }
       } else if ((process.platform === "win32" || process.platform === "darwin") && curr.mtimeMs !== prev.mtimeMs) {
         if (filePath in config.fsTree) {
-          handleWatchEvent(config, extensions, "change", filePath, onEventFunc, onFinishFunc);
+          const existing = pendingChangeTimers.get(filePath);
+          if (existing) clearTimeout(existing);
+          pendingChangeTimers.set(
+            filePath,
+            setTimeout(() => {
+              pendingChangeTimers.delete(filePath);
+              handleWatchEvent(config, extensions, "change", filePath, onEventFunc, onFinishFunc);
+            }, CHANGE_COALESCE_MS)
+          );
         }
       }
     };
-    fs11.watchFile(filePath, { interval: SYMLINK_POLL_INTERVAL_MS, persistent: false }, handler);
-    symlinkPollers.set(filePath, () => fs11.unwatchFile(filePath, handler));
+    fs12.watchFile(filePath, { interval: SYMLINK_POLL_INTERVAL_MS, persistent: false }, handler);
+    symlinkPollers.set(filePath, () => fs12.unwatchFile(filePath, handler));
   }
   function untrackSymlink(filePath) {
     symlinkPollers.get(filePath)?.();
@@ -3562,7 +3751,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     let rescanInProgress = false;
     const lastEventMs = {};
     const seenMtimeMs = {};
-    const childWatcher = fs11.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+    const childWatcher = fs12.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready) return;
       if (!filename) {
         if (process.platform === "darwin" && !rescanInProgress) {
@@ -3580,7 +3769,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         }
         return;
       }
-      const fullPath = filename === path9.basename(watchPath) ? watchPath : path9.join(watchPath, filename);
+      const fullPath = filename === path12.basename(watchPath) ? watchPath : path12.join(watchPath, filename);
       if (eventType === "change") {
         const now = Date.now();
         const last = lastEventMs[fullPath] ?? 0;
@@ -3618,8 +3807,8 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
       }
       handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
     });
-    const parentDir = path9.dirname(watchPath);
-    const watchedBasename = path9.basename(watchPath);
+    const parentDir = path12.dirname(watchPath);
+    const watchedBasename = path12.basename(watchPath);
     let parentUnlinkFired = false;
     let rescanTimer = null;
     const tryFireParentUnlink = async () => {
@@ -3638,7 +3827,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         return true;
       }
     };
-    const parentWatcher = fs11.watch(parentDir, async (eventType, filename) => {
+    const parentWatcher = fs12.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
       await tryFireParentUnlink();
     });
@@ -3752,11 +3941,11 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
     const trackedToRecheck = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        presentDirs.add(path9.join(entry.parentPath, entry.name));
+        presentDirs.add(path12.join(entry.parentPath, entry.name));
         continue;
       }
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-      const entryPath = path9.join(entry.parentPath, entry.name);
+      const entryPath = path12.join(entry.parentPath, entry.name);
       presentDirs.add(entry.parentPath);
       if (!extensions.some((ext) => entryPath.endsWith(`.${ext}`))) continue;
       presentPaths.add(entryPath);
@@ -3779,13 +3968,13 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
         }
       })
     );
-    const watchPrefix = watchPath + path9.sep;
+    const watchPrefix = watchPath + path12.sep;
     const firedDirPrefixes = [];
     for (const trackedPath of Object.keys(config.fsTree)) {
       if (!trackedPath.startsWith(watchPrefix) || presentPaths.has(trackedPath)) continue;
-      if (firedDirPrefixes.some((p) => trackedPath.startsWith(p + path9.sep))) continue;
-      const parts = trackedPath.slice(watchPrefix.length).split(path9.sep);
-      const goneDirPath = parts.slice(0, -1).map((_, i) => watchPrefix + parts.slice(0, i + 1).join(path9.sep)).find((p) => !presentDirs.has(p)) ?? null;
+      if (firedDirPrefixes.some((p) => trackedPath.startsWith(p + path12.sep))) continue;
+      const parts = trackedPath.slice(watchPrefix.length).split(path12.sep);
+      const goneDirPath = parts.slice(0, -1).map((_, i) => watchPrefix + parts.slice(0, i + 1).join(path12.sep)).find((p) => !presentDirs.has(p)) ?? null;
       if (goneDirPath !== null) {
         firedDirPrefixes.push(goneDirPath);
         handleWatchEvent(config, extensions, "unlinkDir", goneDirPath, onEventFunc, onFinishFunc);
@@ -3838,7 +4027,7 @@ var init_file_watcher = __esm({
     SYMLINK_POLL_INTERVAL_MS = 500;
     OVERLAYFS_RENAME_RETRY_MS = 50;
     RESCAN_INTERVAL_MS = 1e3;
-    CHANGE_COALESCE_MS = 50;
+    CHANGE_COALESCE_MS = 75;
     ADD_SUPPRESS_WINDOW_MS = 1e3;
     justAddedAt = /* @__PURE__ */ new WeakMap();
   }
@@ -3920,28 +4109,28 @@ var init_keyboard_events = __esm({
 });
 
 // lib/setup/write-output-static-files.ts
-import fs12 from "node:fs/promises";
-import path10 from "node:path";
+import fs13 from "node:fs/promises";
+import path13 from "node:path";
 async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
-    const htmlRelativePath = path10.relative(projectRoot, staticHTMLKey);
-    const outDir = path10.resolve(projectRoot, output);
-    await ensureFolderExists(path10.join(outDir, htmlRelativePath));
-    await fs12.writeFile(
-      path10.join(outDir, htmlRelativePath),
+    const htmlRelativePath = path13.relative(projectRoot, staticHTMLKey);
+    const outDir = path13.resolve(projectRoot, output);
+    await ensureFolderExists(path13.join(outDir, htmlRelativePath));
+    await fs13.writeFile(
+      path13.join(outDir, htmlRelativePath),
       cachedContent.staticHTMLs[staticHTMLKey]
     );
   });
   const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
-    const assetRelativePath = path10.relative(projectRoot, assetAbsolutePath);
-    const outDir = path10.resolve(projectRoot, output);
-    await ensureFolderExists(path10.join(outDir, assetRelativePath));
-    await fs12.copyFile(assetAbsolutePath, path10.join(outDir, assetRelativePath));
+    const assetRelativePath = path13.relative(projectRoot, assetAbsolutePath).replace(/^(?:\.\.[\\/])+/, "");
+    const outDir = path13.resolve(projectRoot, output);
+    await ensureFolderExists(path13.join(outDir, assetRelativePath));
+    await fs13.copyFile(assetAbsolutePath, path13.join(outDir, assetRelativePath));
   });
   await Promise.all(staticHTMLPromises.concat(assetPromises));
 }
 async function ensureFolderExists(assetPath) {
-  await fs12.mkdir(path10.dirname(assetPath), { recursive: true });
+  await fs13.mkdir(path13.dirname(assetPath), { recursive: true });
 }
 var init_write_output_static_files = __esm({
   "lib/setup/write-output-static-files.ts"() {
@@ -3949,9 +4138,9 @@ var init_write_output_static_files = __esm({
 });
 
 // lib/utils/daemon-hint.ts
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import os3 from "node:os";
-import path11 from "node:path";
+import path14 from "node:path";
 function shouldShowDaemonHint(ctx) {
   const env = ctx.env ?? process.env;
   if (ctx.watch) return false;
@@ -3969,14 +4158,14 @@ async function maybePrintDaemonHint(ctx, opts = {}) {
   if (!shouldShowDaemonHint(ctx)) return;
   const sentinel = opts.sentinelPath ?? DEFAULT_SENTINEL;
   try {
-    await fs13.access(sentinel);
+    await fs14.access(sentinel);
     return;
   } catch {
   }
   (opts.write ?? ((t) => process.stderr.write(t)))(HINT_TEXT);
   try {
-    await fs13.mkdir(path11.dirname(sentinel), { recursive: true });
-    await fs13.writeFile(sentinel, (/* @__PURE__ */ new Date()).toISOString());
+    await fs14.mkdir(path14.dirname(sentinel), { recursive: true });
+    await fs14.writeFile(sentinel, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -3985,7 +4174,7 @@ var init_daemon_hint = __esm({
   "lib/utils/daemon-hint.ts"() {
     FAST_RUN_THRESHOLD_MS = 500;
     HINT_TEXT = "\n\x1B[34m\u2139\x1B[39m Tip: export QUNITX_DAEMON=1 for ~2\xD7 faster repeated runs (qunitx daemon --help)\n";
-    DEFAULT_SENTINEL = path11.join(os3.homedir(), ".cache", "qunitx", "hint-shown");
+    DEFAULT_SENTINEL = path14.join(os3.homedir(), ".cache", "qunitx", "hint-shown");
   }
 });
 
@@ -3998,7 +4187,7 @@ __export(run_exports, {
   readTimingCache: () => readTimingCache,
   run: () => run
 });
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import { join as join3, normalize } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { availableParallelism } from "node:os";
@@ -4085,6 +4274,21 @@ async function run(config) {
     logWatcherAndKeyboardShortcutInfo(config, connections.server);
   } else {
     const allFiles = Object.keys(config.fsTree);
+    if (allFiles.length === 0) {
+      process.stdout.write("TAP version 13\n");
+      process.stdout.write(
+        `# Running 0 test files${config._daemonMode ? " (daemon)" : ""}
+1..0
+`
+      );
+      if (config._daemonMode) throw new DaemonRunError(0);
+      if (!config.watch) {
+        const browser2 = config._daemonBrowser ? null : await browserPromise;
+        await closeWithGrace([browser2?.close(), shutdownPrelaunch()]);
+        return process.exit(0);
+      }
+      return;
+    }
     const groupCount = Math.min(allFiles.length, availableParallelism());
     const { groups, weights } = await splitIntoGroups(allFiles, groupCount, timings ?? {});
     config.COUNTER = {
@@ -4242,7 +4446,7 @@ async function run(config) {
 }
 async function buildCachedContent(config, htmlPaths) {
   const htmlBuffers = await Promise.all(
-    config.htmlPaths.map((htmlPath) => fs14.readFile(htmlPath).catch(() => null))
+    config.htmlPaths.map((htmlPath) => fs15.readFile(htmlPath).catch(() => null))
   );
   const cachedContent = htmlPaths.reduce(
     (result2, _htmlPath, index) => {
@@ -4297,7 +4501,7 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
 }
 async function readTimingCache(projectRoot) {
   try {
-    const parsed = JSON.parse(await fs14.readFile(`${projectRoot}/tmp/test-timings.json`, "utf8"));
+    const parsed = JSON.parse(await fs15.readFile(`${projectRoot}/tmp/test-timings.json`, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -4316,7 +4520,7 @@ function computeFileTimes(groups, weights, wallTimes) {
   return result2;
 }
 async function persistTimings(fileTimes, projectRoot) {
-  await fs14.writeFile(
+  await fs15.writeFile(
     `${projectRoot}/tmp/test-timings.json`,
     JSON.stringify(Object.fromEntries(fileTimes), null, 2)
   );
@@ -4331,7 +4535,7 @@ ${lines.join("\n")}
 async function splitIntoGroups(files, groupCount, timings) {
   const sizes = await Promise.all(
     files.map(
-      (f) => timings[f] > 0 ? Promise.resolve(0) : fs14.stat(f).then((s) => s.size).catch(() => 0)
+      (f) => timings[f] > 0 ? Promise.resolve(0) : fs15.stat(f).then((s) => s.size).catch(() => 0)
     )
   );
   const knownRates = files.map((f, i) => ({ ms: timings[f], size: sizes[i] })).filter(({ ms, size }) => ms > 0 && size > 0);
@@ -4393,7 +4597,7 @@ var init_run = __esm({
     init_close_with_grace();
     init_daemon_hint();
     WATCH_NAV_TIMEOUT_MS = 5e3;
-    STDOUT_FLUSH_GRACE_MS = 5e3;
+    STDOUT_FLUSH_GRACE_MS = 3e4;
     KEEP_ALIVE_INTERVAL_MS = 1e4;
     EXIT_CODE_SIGTERM = 128 + 15;
   }
@@ -4405,19 +4609,19 @@ __export(server_exports, {
   runDaemonServer: () => runDaemonServer
 });
 import net2 from "node:net";
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import { writeFile, unlink, stat as stat2, chmod } from "node:fs/promises";
-import path12 from "node:path";
+import path15 from "node:path";
 async function runDaemonServer() {
   const cwd = process.cwd();
   const socketPath = daemonSocketPath(cwd);
   const infoPath = daemonInfoPath(cwd);
-  if (fs15.existsSync(infoPath) && await isLiveSocket(socketPath)) process.exit(0);
+  if (fs16.existsSync(infoPath) && await isLiveSocket(socketPath)) process.exit(0);
   await unlink(socketPath).catch(() => {
   });
   const logPath = process.env.QUNITX_DAEMON_LOG;
   if (logPath) {
-    const log = fs15.createWriteStream(logPath, { flags: "a" });
+    const log = fs16.createWriteStream(logPath, { flags: "a" });
     log.on("error", () => {
     });
     const forward = log.write.bind(log);
@@ -4543,7 +4747,7 @@ async function dispatch(req, socket, state) {
     socket.end();
   } else if (req.type === "shutdown") {
     try {
-      fs15.unlinkSync(state.infoPath);
+      fs16.unlinkSync(state.infoPath);
     } catch {
     }
     writeChunk(socket, { type: "done", exitCode: 0 });
@@ -4685,7 +4889,7 @@ async function isLiveSocket(socketPath) {
 }
 async function readPkgMtime(cwd) {
   try {
-    return (await stat2(path12.join(cwd, "package.json"))).mtimeMs;
+    return (await stat2(path15.join(cwd, "package.json"))).mtimeMs;
   } catch {
     return 0;
   }
@@ -4713,8 +4917,8 @@ __export(daemon_exports, {
   runDaemonCommand: () => runDaemonCommand
 });
 import { spawn as spawn3 } from "node:child_process";
-import fs16, { existsSync as existsSync3 } from "node:fs";
-import path13 from "node:path";
+import fs17, { existsSync as existsSync3 } from "node:fs";
+import path16 from "node:path";
 async function buildDaemonSpawn() {
   const sea = await import("node:sea").catch(() => null);
   if (sea?.isSea()) return { bin: process.execPath, args: ["daemon", "_serve"] };
@@ -4739,15 +4943,15 @@ async function runServeMode() {
 function waitForFile(filePath, timeoutMs) {
   if (existsSync3(filePath)) return Promise.resolve(true);
   return new Promise((resolve) => {
-    const dir = path13.dirname(filePath);
-    const fileName = path13.basename(filePath);
+    const dir = path16.dirname(filePath);
+    const fileName = path16.basename(filePath);
     const settle = (ok) => {
       clearTimeout(timer);
       watcher.close();
       resolve(ok);
     };
     const timer = setTimeout(() => settle(false), timeoutMs);
-    const watcher = fs16.watch(dir, (_event, name) => {
+    const watcher = fs17.watch(dir, (_event, name) => {
       if (name === fileName && existsSync3(filePath)) settle(true);
     });
     watcher.on("error", () => settle(false));

package/package.json

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