qunitx-cli 0.17.6 → 0.17.8

package/dist/cli.js

@@ -53,6 +53,76 @@ var init_kill_process_group = __esm({
   }
 });
 
+// lib/utils/cleanup-browser-dir.ts
+import fs from "node:fs/promises";
+async function cleanupBrowserDir(dirPath) {
+  if (process.platform !== "linux") {
+    await fs.rm(dirPath, { recursive: true, force: true }).catch(() => {
+    });
+    return;
+  }
+  const dirName = dirPath.split("/").pop();
+  const killedPids = /* @__PURE__ */ new Set();
+  const procEntries = await fs.readdir("/proc").catch(() => []);
+  await Promise.all(
+    procEntries.map(async (entry) => {
+      if (!/^\d+$/.test(entry)) return;
+      const pid = parseInt(entry);
+      try {
+        const [cwd, cmdline] = await Promise.all([
+          fs.readlink(`/proc/${entry}/cwd`).catch(() => ""),
+          fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "")
+        ]);
+        if (!cwd.startsWith(dirPath) && !cmdline.includes(dirName)) return;
+        try {
+          process.kill(pid, "SIGKILL");
+          killedPids.add(pid);
+        } catch {
+        }
+      } catch {
+      }
+    })
+  );
+  while (killedPids.size > 0) {
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    for (const pid of killedPids) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        killedPids.delete(pid);
+      }
+    }
+  }
+  const deadline = Date.now() + 1e3;
+  while (Date.now() < deadline) {
+    const removed = await fs.rm(dirPath, { recursive: true, force: true }).then(() => true).catch(() => false);
+    if (removed) break;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  if (await fs.access(dirPath).then(() => true).catch(() => false)) {
+    const diagEntries = await fs.readdir("/proc").catch(() => []);
+    await Promise.all(
+      diagEntries.map(async (entry) => {
+        if (!/^\d+$/.test(entry)) return;
+        try {
+          const cwd = await fs.readlink(`/proc/${entry}/cwd`).catch(() => "");
+          if (!cwd.startsWith(dirPath)) return;
+          const cmdline = await fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "");
+          process.stderr.write(
+            `# [qunitx] cleanup failed: pid ${entry} still holds ${dirPath} as cwd (cmdline: ${cmdline.replace(/\0/g, " ").slice(0, 120)})
+`
+          );
+        } catch {
+        }
+      })
+    );
+  }
+}
+var init_cleanup_browser_dir = __esm({
+  "lib/utils/cleanup-browser-dir.ts"() {
+  }
+});
+
 // lib/utils/pre-launch-chrome.ts
 import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
@@ -123,11 +193,10 @@ async function preLaunchChrome(chromePath, args, headless = true) {
         } catch {
           break;
         }
-        await new Promise((r) => setTimeout(r, 20));
+        await new Promise((resolve) => setTimeout(resolve, 20));
       }
       clearTimeout(warnTimer);
-      await rm(userDataDir, { recursive: true, force: true }).catch(() => {
-      });
+      await cleanupBrowserDir(userDataDir);
     });
   }
 }
@@ -135,6 +204,7 @@ var CDP_URL_REGEX;
 var init_pre_launch_chrome = __esm({
   "lib/utils/pre-launch-chrome.ts"() {
     init_kill_process_group();
+    init_cleanup_browser_dir();
     CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
   }
 });
@@ -231,16 +301,16 @@ var init_perf_logger = __esm({
   }
 });
 
-// lib/utils/early-chrome.ts
-async function shutdownEarlyBrowser() {
+// lib/utils/chrome-prelaunch.ts
+async function shutdownPrelaunch() {
   if (!earlyChrome) return;
   const { shutdown } = earlyChrome;
   earlyChrome = null;
   await shutdown();
 }
-var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, openWatchMode, earlyChrome, earlyBrowserPromise;
-var init_early_chrome = __esm({
-  "lib/utils/early-chrome.ts"() {
+var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, openWatchMode, earlyChrome, prelaunchPromise;
+var init_chrome_prelaunch = __esm({
+  "lib/utils/chrome-prelaunch.ts"() {
     init_find_chrome();
     init_pre_launch_chrome();
     init_kill_process_group();
@@ -265,12 +335,12 @@ var init_early_chrome = __esm({
         killProcessGroup(earlyChrome.proc.pid);
       });
     }
-    perfLog("early-chrome.js: module evaluated");
-    earlyBrowserPromise = isRunCommand && browserFromArgv === "chromium" ? findChrome().then((chromePath) => {
-      perfLog("early-chrome.js: findChrome resolved", chromePath);
+    perfLog("chrome-prelaunch.ts: module evaluated");
+    prelaunchPromise = isRunCommand && browserFromArgv === "chromium" ? findChrome().then((chromePath) => {
+      perfLog("chrome-prelaunch.ts: findChrome resolved", chromePath);
       return preLaunchChrome(chromePath, CHROMIUM_ARGS, !openWatchMode);
     }).then((info) => {
-      perfLog("early-chrome.js: Chrome CDP ready", info?.cdpEndpoint ?? null);
+      perfLog("chrome-prelaunch.ts: Chrome CDP ready", info?.cdpEndpoint ?? null);
       if (info) earlyChrome = info;
       return info;
     }) : Promise.resolve(null);
@@ -316,10 +386,10 @@ var init_color = __esm({
 });
 
 // lib/utils/path-exists.ts
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 async function pathExists(path6) {
   try {
-    await fs.access(path6);
+    await fs2.access(path6);
     return true;
   } catch {
     return false;
@@ -330,17 +400,17 @@ var init_path_exists = __esm({
   }
 });
 
-// lib/utils/read-boilerplate.ts
-import fs2 from "node:fs/promises";
+// lib/utils/read-template.ts
+import fs3 from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
-async function readBoilerplate(relativePath) {
+async function readTemplate(relativePath) {
   const sea = await import("node:sea").catch(() => null);
   if (sea?.isSea()) return sea.getAsset(relativePath, "utf8");
   const __dirname = dirname(fileURLToPath(import.meta.url));
   for (const base of ["../templates", "../../templates"]) {
     try {
-      return (await fs2.readFile(join2(__dirname, base, relativePath))).toString();
+      return (await fs3.readFile(join2(__dirname, base, relativePath))).toString();
     } catch {
     }
   }
@@ -348,8 +418,8 @@ async function readBoilerplate(relativePath) {
     `qunitx-cli: template "${relativePath}" not found \u2014 try reinstalling the package.`
   );
 }
-var init_read_boilerplate = __esm({
-  "lib/utils/read-boilerplate.ts"() {
+var init_read_template = __esm({
+  "lib/utils/read-template.ts"() {
   }
 });
 
@@ -368,19 +438,19 @@ var init_find_internal_assets_from_html = __esm({
   }
 });
 
-// lib/utils/html-content-marker.ts
-function findHTMLContentMarker(html) {
-  return html.includes(HTML_CONTENT_MARKER) ? HTML_CONTENT_MARKER : void 0;
+// lib/utils/html.ts
+function findScriptPlaceholder(html) {
+  return html.includes(SCRIPT_PLACEHOLDER) ? SCRIPT_PLACEHOLDER : void 0;
 }
-function htmlHasDynamicContentMarker(html) {
-  return !!findHTMLContentMarker(html) || HANDLEBARS_TOKEN_REGEX.test(html);
+function isCustomTemplate(html) {
+  return !!findScriptPlaceholder(html) || HANDLEBARS_TOKEN_REGEX.test(html);
 }
-function replaceHTMLContentMarker(html, content) {
-  const marker = findHTMLContentMarker(html);
-  if (marker) {
-    return html.replace(marker, content);
+function injectScript(html, content) {
+  const placeholder = findScriptPlaceholder(html);
+  if (placeholder) {
+    return html.replace(placeholder, content);
   }
-  if (htmlHasDynamicContentMarker(html)) {
+  if (isCustomTemplate(html)) {
     if (html.includes("</body>")) {
       return html.replace("</body>", `${content}</body>`);
     }
@@ -391,10 +461,10 @@ function replaceHTMLContentMarker(html, content) {
   }
   return html;
 }
-var HTML_CONTENT_MARKER, HANDLEBARS_TOKEN_REGEX;
-var init_html_content_marker = __esm({
-  "lib/utils/html-content-marker.ts"() {
-    HTML_CONTENT_MARKER = "{{qunitxScript}}";
+var SCRIPT_PLACEHOLDER, HANDLEBARS_TOKEN_REGEX;
+var init_html = __esm({
+  "lib/utils/html.ts"() {
+    SCRIPT_PLACEHOLDER = "{{qunitxScript}}";
     HANDLEBARS_TOKEN_REGEX = /{{\s*[^}]+\s*}}/;
   }
 });
@@ -557,8 +627,8 @@ async function bindServerToPort(server, config) {
 var EXPLICIT_PORT_RETRIES, EXPLICIT_PORT_RETRY_DELAY_MS;
 var init_bind_server_to_port = __esm({
   "lib/setup/bind-server-to-port.ts"() {
-    EXPLICIT_PORT_RETRIES = 5;
-    EXPLICIT_PORT_RETRY_DELAY_MS = 20;
+    EXPLICIT_PORT_RETRIES = 20;
+    EXPLICIT_PORT_RETRY_DELAY_MS = 50;
   }
 });
 
@@ -810,7 +880,7 @@ var init_http = __esm({
 });
 
 // lib/setup/web-server.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path4 from "node:path";
 function setupWebServer(config, cachedContent) {
   const STATIC_FILES_PATH = path4.join(config.projectRoot, config.output);
@@ -954,7 +1024,7 @@ function setupWebServer(config, cachedContent) {
     if (statusCode === 404) {
       res.end();
     } else {
-      fs7.createReadStream(filePath).pipe(res);
+      fs8.createReadStream(filePath).pipe(res);
     }
     console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms`);
   });
@@ -1119,22 +1189,19 @@ function testRuntimeToInject(port, config) {
   </script>`;
 }
 function escapeAndInjectTestsToHTML(html, testRuntimeCode, testBundleUrl) {
-  return replaceHTMLContentMarker(
-    html,
-    `${testRuntimeCode}
-<script src="${testBundleUrl}" async></script>`
-  );
+  return injectScript(html, `${testRuntimeCode}
+<script src="${testBundleUrl}" async></script>`);
 }
 var fsPromise;
 var init_web_server = __esm({
   "lib/setup/web-server.ts"() {
     init_find_internal_assets_from_html();
-    init_html_content_marker();
+    init_html();
     init_display_test_result();
     init_color();
     init_path_exists();
     init_http();
-    fsPromise = fs7.promises;
+    fsPromise = fs8.promises;
   }
 });
 
@@ -1143,18 +1210,18 @@ async function launchBrowser(config) {
   const browserName = config.browser || "chromium";
   if (browserName === "chromium") {
     const waitStart = Date.now();
-    const [playwrightCore2, earlyChrome2] = await Promise.all([
+    const [playwrightCore2, prelaunch] = await Promise.all([
       playwrightCorePromise,
-      earlyBrowserPromise
+      prelaunchPromise
     ]);
     perfLog(
-      `browser.js: playwright-core + earlyChrome resolved in ${Date.now() - waitStart}ms, earlyChrome:`,
-      earlyChrome2?.cdpEndpoint ?? null
+      `browser.js: playwright-core + prelaunch resolved in ${Date.now() - waitStart}ms, prelaunch:`,
+      prelaunch?.cdpEndpoint ?? null
     );
-    if (earlyChrome2) {
+    if (prelaunch) {
       const connectStart = Date.now();
       const browser = await playwrightCore2.chromium.connectOverCDP({
-        endpointURL: earlyChrome2.cdpEndpoint
+        endpointURL: prelaunch.cdpEndpoint
       });
       perfLog(`browser.js: connectOverCDP took ${Date.now() - connectStart}ms`);
       return browser;
@@ -1209,8 +1276,8 @@ async function setupBrowser(config, cachedContent, existingBrowser = null) {
     }
   });
   page.on("pageerror", (error) => {
-    console.log(error.toString());
     console.error(error.toString());
+    config.COUNTER.failCount++;
   });
   return { server, browser, page };
 }
@@ -1221,7 +1288,7 @@ var init_browser = __esm({
     init_bind_server_to_port();
     init_find_chrome();
     init_chromium_args();
-    init_early_chrome();
+    init_chrome_prelaunch();
     init_perf_logger();
     playwrightCorePromise = import("playwright-core");
     perfLog("browser.js: playwright-core import started");
@@ -1314,7 +1381,7 @@ var init_display_final_result = __esm({
 });
 
 // lib/commands/run/tests-in-browser.ts
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import esbuild from "esbuild";
 async function buildTestBundle(config, cachedContent) {
   const { projectRoot, output } = config;
@@ -1324,37 +1391,35 @@ async function buildTestBundle(config, cachedContent) {
     return;
   }
   const outfile = `${projectRoot}/${output}/tests.js`;
-  await fs8.mkdir(`${projectRoot}/${output}`, { recursive: true });
+  await fs9.mkdir(`${projectRoot}/${output}`, { recursive: true });
   const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
   const needsDisk = true;
+  const buildOptions = {
+    stdin: {
+      contents: allTestFilePaths.map((filePath) => `import "${filePath}";`).join(""),
+      resolveDir: process.cwd()
+    },
+    bundle: true,
+    logLevel: "error",
+    outfile,
+    keepNames: true,
+    legalComments: "none",
+    target: esbuildTarget(config.browser),
+    sourcemap,
+    // Signal the runtime that all test modules are registered. The runtime's maybeStart()
+    // waits for both this event and the WebSocket 'open' event before calling QUnit.start().
+    // Dispatching from the bundle (rather than from a script onload attr) is reliable across
+    // all browsers and does not require changes to user test code.
+    footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
+  };
   const [allTestCode] = await Promise.all([
-    buildWithOverlayfsRetry(
-      {
-        stdin: {
-          contents: allTestFilePaths.map((filePath) => `import "${filePath}";`).join(""),
-          resolveDir: process.cwd()
-        },
-        bundle: true,
-        logLevel: "error",
-        outfile,
-        keepNames: true,
-        legalComments: "none",
-        target: esbuildTarget(config.browser),
-        sourcemap,
-        // Signal the runtime that all test modules are registered. The runtime's maybeStart()
-        // waits for both this event and the WebSocket 'open' event before calling QUnit.start().
-        // Dispatching from the bundle (rather than from a script onload attr) is reliable across
-        // all browsers and does not require changes to user test code.
-        footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
-      },
-      needsDisk
-    ),
+    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 fs8.rm(targetPath, { force: true, recursive: true });
-          await fs8.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+          await fs9.rm(targetPath, { force: true, recursive: true });
+          await fs9.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
         }
       })
     )
@@ -1370,8 +1435,10 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
   }
   config.lastRanTestFiles = targetTestFilesToFilter || allTestFilePaths;
   try {
+    const preBuildPromise = cachedContent._preBuildPromise;
+    cachedContent._preBuildPromise = null;
     if (!cachedContent.allTestCode) {
-      await buildTestBundle(config, cachedContent);
+      await (preBuildPromise ?? buildTestBundle(config, cachedContent));
     }
     if (!cachedContent.allTestCode) {
       return connections;
@@ -1405,7 +1472,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
           connections.server && connections.server.close(),
           connections.browser && connections.browser.close()
         ]);
-        await shutdownEarlyBrowser();
+        await shutdownPrelaunch();
         return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
       }
     }
@@ -1441,16 +1508,10 @@ function buildFilteredTests(filteredTests, outputPath, config) {
     needsDisk
   );
 }
-async function buildWithOverlayfsRetry(options, needsDisk) {
+async function runWithOverlayfsRetry(getContents, needsDisk) {
   const RETRY_DELAY_MS = 100;
   const MAX_RETRIES = 3;
   const EMPTY_BUNDLE_THRESHOLD = 500;
-  const buildOpts = { ...options, write: false };
-  const getContents = async () => {
-    const result2 = await esbuild.build(buildOpts);
-    const jsFile = result2.outputFiles.find((outputFile) => !outputFile.path.endsWith(".map"));
-    return { result: result2, js: Buffer.from(jsFile.contents) };
-  };
   let { result, js } = await getContents();
   for (let retry = 1; retry <= MAX_RETRIES; retry++) {
     if (js.length >= EMPTY_BUNDLE_THRESHOLD) break;
@@ -1467,11 +1528,34 @@ async function buildWithOverlayfsRetry(options, needsDisk) {
   }
   if (needsDisk) {
     await Promise.all(
-      result.outputFiles.map((outputFile) => fs8.writeFile(outputFile.path, outputFile.contents))
+      result.outputFiles.map((outputFile) => fs9.writeFile(outputFile.path, outputFile.contents))
     );
   }
   return js;
 }
+function buildWithOverlayfsRetry(options, needsDisk) {
+  const buildOpts = { ...options, write: false };
+  return runWithOverlayfsRetry(async () => {
+    const result = await esbuild.build(buildOpts);
+    const jsFile = result.outputFiles.find((f) => !f.path.endsWith(".map"));
+    return { result, js: Buffer.from(jsFile.contents) };
+  }, needsDisk);
+}
+async function buildIncrementally(options, fileKey, cachedContent, needsDisk) {
+  const buildOpts = { ...options, write: false };
+  if (!cachedContent._esbuildContext || cachedContent._esbuildContextKey !== fileKey) {
+    cachedContent._esbuildContext?.dispose().catch(() => {
+    });
+    cachedContent._esbuildContext = await esbuild.context(buildOpts);
+    cachedContent._esbuildContextKey = fileKey;
+  }
+  const ctx = cachedContent._esbuildContext;
+  return runWithOverlayfsRetry(async () => {
+    const result = await ctx.rebuild();
+    const jsFile = result.outputFiles.find((f) => !f.path.endsWith(".map"));
+    return { result, js: Buffer.from(jsFile.contents) };
+  }, needsDisk);
+}
 function esbuildTarget(browser) {
   if (browser === "firefox") return ["firefox115"];
   if (browser === "webkit") return ["safari16"];
@@ -1556,7 +1640,7 @@ async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode
       connections.server && connections.server.close(),
       connections.browser && connections.browser.close()
     ]);
-    await shutdownEarlyBrowser();
+    await shutdownPrelaunch();
     process.exit(1);
   }
 }
@@ -1564,7 +1648,7 @@ var BundleError;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
-    init_early_chrome();
+    init_chrome_prelaunch();
     init_time_counter();
     init_run_user_module();
     init_display_final_result();
@@ -1579,7 +1663,7 @@ var init_tests_in_browser = __esm({
 });
 
 // lib/setup/file-watcher.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import { stat, lstat } from "node:fs/promises";
 import path5 from "node:path";
 function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
@@ -1592,15 +1676,15 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     if (symlinkPollers.has(filePath)) return;
     const handler = (curr) => {
       if (curr.nlink === 0) {
-        fs9.unwatchFile(filePath, handler);
+        fs10.unwatchFile(filePath, handler);
         symlinkPollers.delete(filePath);
         if (filePath in config.fsTree) {
           handleWatchEvent(config, extensions, "unlink", filePath, onEventFunc, onFinishFunc);
         }
       }
     };
-    fs9.watchFile(filePath, { interval: 500, persistent: false }, handler);
-    symlinkPollers.set(filePath, () => fs9.unwatchFile(filePath, handler));
+    fs10.watchFile(filePath, { interval: 500, persistent: false }, handler);
+    symlinkPollers.set(filePath, () => fs10.unwatchFile(filePath, handler));
   }
   function untrackSymlink(filePath) {
     symlinkPollers.get(filePath)?.();
@@ -1609,7 +1693,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
   for (const watchPath of testFileLookupPaths) {
     let ready = false;
     const lastChangeMs = {};
-    const childWatcher = fs9.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+    const childWatcher = fs10.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready || !filename) return;
       const fullPath = path5.join(watchPath, filename);
       if (eventType === "change") {
@@ -1639,7 +1723,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     const parentDir = path5.dirname(watchPath);
     const watchedBasename = path5.basename(watchPath);
     let parentUnlinkFired = false;
-    const parentWatcher = fs9.watch(parentDir, async (eventType, filename) => {
+    const parentWatcher = fs10.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
       if (parentUnlinkFired) return;
       parentUnlinkFired = true;
@@ -1840,12 +1924,12 @@ var init_keyboard_events = __esm({
 });
 
 // lib/setup/write-output-static-files.ts
-import fs10 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
     const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, "");
     await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
-    await fs10.writeFile(
+    await fs11.writeFile(
       `${projectRoot}/${output}/${htmlRelativePath}`,
       cachedContent.staticHTMLs[staticHTMLKey]
     );
@@ -1853,12 +1937,12 @@ async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
     const assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, "");
     await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
-    await fs10.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
+    await fs11.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
   });
   await Promise.all(staticHTMLPromises.concat(assetPromises));
 }
 async function ensureFolderExists(assetPath) {
-  await fs10.mkdir(assetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+  await fs11.mkdir(assetPath.split("/").slice(0, -1).join("/"), { recursive: true });
 }
 var init_write_output_static_files = __esm({
   "lib/setup/write-output-static-files.ts"() {
@@ -1871,12 +1955,13 @@ __export(run_exports, {
   default: () => run,
   run: () => run
 });
-import fs11 from "node:fs/promises";
+import fs12 from "node:fs/promises";
 import { normalize } from "node:path";
 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 [connections] = await Promise.all([
       setupBrowser(config, cachedContent),
       writeOutputStaticFiles(config, cachedContent)
@@ -2029,14 +2114,14 @@ async function run(config) {
       clearInterval(keepAlive);
       await browser.close().catch(() => {
       });
-      await shutdownEarlyBrowser();
+      await shutdownPrelaunch();
       process.exit(exitCode);
     });
   }
 }
 async function buildCachedContent(config, htmlPaths) {
   const htmlBuffers = await Promise.all(
-    config.htmlPaths.map((htmlPath) => fs11.readFile(htmlPath).catch(() => null))
+    config.htmlPaths.map((htmlPath) => fs12.readFile(htmlPath).catch(() => null))
   );
   const cachedContent = htmlPaths.reduce(
     (result, _htmlPath, index) => {
@@ -2044,7 +2129,7 @@ async function buildCachedContent(config, htmlPaths) {
       if (buffer === null) return result;
       const filePath = config.htmlPaths[index];
       const html = buffer.toString();
-      if (htmlHasDynamicContentMarker(html)) {
+      if (isCustomTemplate(html)) {
         result.dynamicContentHTMLs[filePath] = html;
         result.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ""));
       } else {
@@ -2083,7 +2168,7 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
       html: cachedContent.dynamicContentHTMLs[mainHTMLPath]
     };
   } else {
-    const html = await readBoilerplate("setup/tests.hbs");
+    const html = await readTemplate("setup/tests.hbs");
     cachedContent.mainHTML = { filePath: `${projectRoot}/test/tests.html`, html };
     cachedContent.assets.add(`${projectRoot}/node_modules/qunitx/vendor/qunit.css`);
   }
@@ -2114,7 +2199,7 @@ function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
 var init_run = __esm({
   "lib/commands/run.ts"() {
     init_browser();
-    init_early_chrome();
+    init_chrome_prelaunch();
     init_open_output_in_browser();
     init_color();
     init_tests_in_browser();
@@ -2125,13 +2210,13 @@ var init_run = __esm({
     init_write_output_static_files();
     init_time_counter();
     init_display_final_result();
-    init_read_boilerplate();
-    init_html_content_marker();
+    init_read_template();
+    init_html();
   }
 });
 
 // cli.ts
-init_early_chrome();
+init_chrome_prelaunch();
 import process4 from "node:process";
 
 // lib/commands/help.ts
@@ -2141,7 +2226,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.17.6",
+  version: "0.17.8",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2200,7 +2285,7 @@ var package_default = {
     express: "^5.2.1",
     "js-yaml": "^4.1.1",
     prettier: "^3.8.2",
-    qunitx: "^1.2.1",
+    qunitx: "^1.2.7",
     typescript: "^6.0.2"
   },
   volta: {
@@ -2251,7 +2336,7 @@ ${color("$ qunitx new $testFileName")}  # Creates a qunitx test file
 }
 
 // lib/commands/init.ts
-import fs3 from "node:fs/promises";
+import fs4 from "node:fs/promises";
 import path2 from "node:path";
 
 // lib/utils/find-project-root.ts
@@ -2300,10 +2385,10 @@ var defaultProjectConfigValues = {
 };
 
 // lib/commands/init.ts
-init_read_boilerplate();
+init_read_template();
 async function initializeProject() {
   const projectRoot = await findProjectRoot();
-  const oldPackageJSON = JSON.parse(await fs3.readFile(`${projectRoot}/package.json`));
+  const oldPackageJSON = JSON.parse(await fs4.readFile(`${projectRoot}/package.json`));
   const existingQunitx = oldPackageJSON.qunitx || {};
   const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
   const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
@@ -2316,7 +2401,7 @@ async function initializeProject() {
   ]);
 }
 async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
-  const testHTMLTemplateBuffer = await readBoilerplate("setup/tests.hbs");
+  const testHTMLTemplateBuffer = await readTemplate("setup/tests.hbs");
   return await Promise.all(
     config.htmlPaths.map(async (htmlPath) => {
       const targetPath = `${projectRoot}/${htmlPath}`;
@@ -2332,8 +2417,8 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
           "{{applicationName}}",
           oldPackageJSON.name
         );
-        await fs3.mkdir(targetDirectory, { recursive: true });
-        await fs3.writeFile(targetPath, testHTMLTemplate);
+        await fs4.mkdir(targetDirectory, { recursive: true });
+        await fs4.writeFile(targetPath, testHTMLTemplate);
         console.log(`${targetPath} written`);
       }
     })
@@ -2341,22 +2426,22 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
 }
 async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
   const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
-  await fs3.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
+  await fs4.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
 }
 async function writeTSConfigIfNeeded(projectRoot) {
   const targetPath = `${projectRoot}/tsconfig.json`;
   if (!await pathExists(targetPath)) {
-    const tsConfigTemplate = await readBoilerplate("setup/tsconfig.json");
-    await fs3.writeFile(targetPath, tsConfigTemplate);
+    const tsConfigTemplate = await readTemplate("setup/tsconfig.json");
+    await fs4.writeFile(targetPath, tsConfigTemplate);
     console.log(`${targetPath} written`);
   }
 }
 
 // lib/commands/generate.ts
 init_color();
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 init_path_exists();
-init_read_boilerplate();
+init_read_template();
 
 // lib/utils/convert-to-pascal-case.ts
 function convertToPascalCase(str) {
@@ -2378,25 +2463,25 @@ async function generateTestFiles() {
     console.log(`${path6} already exists!`);
     return;
   }
-  const testJSContent = await readBoilerplate("test.js");
+  const testJSContent = await readTemplate("test.js");
   const targetFolderPaths = path6.split("/");
   targetFolderPaths.pop();
-  await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs4.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
+  await fs5.mkdir(targetFolderPaths.join("/"), { recursive: true });
+  await fs5.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
   console.log(green(`${path6} written`));
 }
 
 // lib/setup/config.ts
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 
 // lib/setup/fs-tree.ts
-import fs5, { glob as fsGlob } from "node:fs/promises";
+import fs6, { glob as fsGlob } from "node:fs/promises";
 import path3 from "node:path";
 function isGlob(str) {
   return /[*?{[]/.test(str);
 }
 async function readDirRecursive(dir, filter) {
-  const entries = await fs5.readdir(dir, { recursive: true, withFileTypes: true });
+  const entries = await fs6.readdir(dir, { recursive: true, withFileTypes: true });
   const candidates = entries.filter(
     (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
   );
@@ -2405,7 +2490,7 @@ async function readDirRecursive(dir, filter) {
       const fullPath = path3.join(dirent.parentPath, dirent.name);
       if (dirent.isFile()) return fullPath;
       try {
-        const statResult = await fs5.stat(fullPath);
+        const statResult = await fs6.stat(fullPath);
         return statResult.isFile() ? fullPath : null;
       } catch {
         return null;
@@ -2427,7 +2512,7 @@ async function buildFSTree(fileAbsolutePaths, config = {}) {
             }
           }
         } else {
-          const entry = await fs5.stat(fileAbsolutePath);
+          const entry = await fs6.stat(fileAbsolutePath);
           if (entry.isFile()) {
             fsTree[fileAbsolutePath] = null;
           } else if (entry.isDirectory()) {
@@ -2600,7 +2685,7 @@ async function setupConfig() {
   return config;
 }
 async function readConfigFromPackageJSON(projectRoot) {
-  const packageJSON = await fs6.readFile(`${projectRoot}/package.json`);
+  const packageJSON = await fs7.readFile(`${projectRoot}/package.json`);
   return JSON.parse(packageJSON.toString());
 }
 function normalizeHTMLPaths(projectRoot, htmlPaths) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.17.6",
+  "version": "0.17.8",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -60,7 +60,7 @@
     "express": "^5.2.1",
     "js-yaml": "^4.1.1",
     "prettier": "^3.8.2",
-    "qunitx": "^1.2.1",
+    "qunitx": "^1.2.7",
     "typescript": "^6.0.2"
   },
   "volta": {