qunitx-cli 0.23.2 → 0.23.4

package/README.md

@@ -306,10 +306,11 @@ Don't forget to add the plugin's file extension(s) to `qunitx.extensions` so dir
 
 ### Environment variables
 
-| Variable         | Description                                                                                                                                                                                           |
-| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `CHROME_BIN`     | Path to the Chrome/Chromium executable. Required on systems where Chrome is not on `PATH` (e.g. many CI environments). Set automatically when using `browser-actions/setup-chrome` in GitHub Actions. |
-| `QUNITX_BROWSER` | Browser engine to use (`chromium`, `firefox`, `webkit`). Equivalent to `--browser` on the CLI. Useful in CI matrix jobs.                                                                              |
+| Variable              | Description                                                                                                                                                                                                                                                                                                                                  |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CHROME_BIN`          | Path to the Chrome/Chromium executable. Required on systems where Chrome is not on `PATH` (e.g. many CI environments). Set automatically when using `browser-actions/setup-chrome` in GitHub Actions.                                                                                                                                        |
+| `QUNITX_BROWSER`      | Browser engine to use (`chromium`, `firefox`, `webkit`). Equivalent to `--browser` on the CLI. Useful in CI matrix jobs.                                                                                                                                                                                                                     |
+| `NODE_COMPILE_CACHE`  | Standard Node env, auto-enabled by qunitx. Stores V8 bytecode for the CLI + its dep graph on disk so the second and subsequent `qunitx` runs skip the parser pass — measured ~8% faster end-to-end (more on slow CI disks). Defaults to `${TMPDIR}/node-compile-cache`; set to a path to relocate (handy for a CI cache key) or `""` to disable. |
 
 If you do not provide any HTML template, qunitx falls back to its built-in `test/tests.html` boilerplate internally, so `qunitx init` is optional.
 

package/bin/qunitx.js

@@ -3,12 +3,22 @@
 // Prefers a pre-built SEA binary from the matching optional platform package
 // (qunitx-cli-linux-x64, qunitx-cli-darwin-arm64, etc.) when available.
 // Falls back to the bundled JS CLI (dist/cli.js) which requires Node.js + node_modules.
+import nodeModule, { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 import { access, constants, readFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 
+// Turn on V8's on-disk compile cache before importing dist/cli.js — caches
+// the bundle + its external deps (esbuild, playwright-core, ws) across cold
+// invocations. The active dir is written back to process.env so any child
+// spawn (SEA binary below, daemon auto-spawn from cli.ts) inherits and also
+// auto-enables from boot. `in` check preserves a user-set empty string.
+const cacheResult = nodeModule.enableCompileCache?.();
+if (cacheResult?.directory && !('NODE_COMPILE_CACHE' in process.env)) {
+  process.env.NODE_COMPILE_CACHE = cacheResult.directory;
+}
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 

package/dist/cli.js

@@ -374,7 +374,7 @@ var init_package = __esm({
     package_default = {
       name: "qunitx-cli",
       type: "module",
-      version: "0.23.2",
+      version: "0.23.4",
       description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
       author: "Izel Nakri",
       license: "MIT",
@@ -877,7 +877,7 @@ function awaitClose(socket) {
 async function pingDaemon() {
   const socket = await tryConnect();
   if (!socket) return null;
-  const result = new Promise((resolve) => {
+  const result2 = new Promise((resolve) => {
     attachLineParser(socket, (chunk) => {
       if (chunk.type === "pong") resolve(chunk);
     });
@@ -885,7 +885,7 @@ async function pingDaemon() {
     socket.once("error", () => resolve(null));
   });
   send(socket, { type: "ping" });
-  const pong = await result;
+  const pong = await result2;
   socket.end();
   return pong;
 }
@@ -1085,32 +1085,32 @@ var init_test_file_paths = __esm({
 import path5 from "node:path";
 function parseCliFlags(projectRoot) {
   const providedFlags = process.argv.slice(2).reduce(
-    (result, arg) => {
+    (result2, arg) => {
       if (arg.startsWith("--debug")) {
-        return Object.assign(result, { debug: parseBoolean(arg.split("=")[1]) });
+        return Object.assign(result2, { debug: parseBoolean(arg.split("=")[1]) });
       } else if (arg.startsWith("--watch")) {
-        return Object.assign(result, { watch: parseBoolean(arg.split("=")[1]) });
+        return Object.assign(result2, { watch: parseBoolean(arg.split("=")[1]) });
       } else if (arg === "-o" || arg.startsWith("-o=") || arg.startsWith("--open")) {
         const value = arg.split("=")[1];
         const open = value === void 0 || value === "true" ? true : value === "false" ? false : value;
-        return Object.assign(result, { open });
+        return Object.assign(result2, { open });
       } else if (arg.startsWith("--failfast") || arg.startsWith("--failFast")) {
-        return Object.assign(result, { failFast: parseBoolean(arg.split("=")[1]) });
+        return Object.assign(result2, { failFast: parseBoolean(arg.split("=")[1]) });
       } else if (arg.startsWith("--timeout")) {
-        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || FALLBACK_TIMEOUT_MS });
+        return Object.assign(result2, { timeout: Number(arg.split("=")[1]) || FALLBACK_TIMEOUT_MS });
       } else if (arg.startsWith("--output")) {
-        return Object.assign(result, { output: arg.split("=")[1] });
+        return Object.assign(result2, { output: arg.split("=")[1] });
       } else if (arg.endsWith(".html")) {
-        if (result.htmlPaths) {
-          result.htmlPaths.push(arg);
+        if (result2.htmlPaths) {
+          result2.htmlPaths.push(arg);
         } else {
-          result.htmlPaths = [arg];
+          result2.htmlPaths = [arg];
         }
-        return result;
+        return result2;
       } else if (arg.startsWith("--port")) {
-        return Object.assign(result, { port: Number(arg.split("=")[1]), portExplicit: true });
+        return Object.assign(result2, { port: Number(arg.split("=")[1]), portExplicit: true });
       } else if (arg.startsWith("--extensions")) {
-        return Object.assign(result, {
+        return Object.assign(result2, {
           extensions: arg.split("=")[1].split(",").map((extension) => extension.trim())
         });
       } else if (arg.startsWith("--browser")) {
@@ -1121,22 +1121,22 @@ function parseCliFlags(projectRoot) {
           );
           process.exit(1);
         }
-        return Object.assign(result, { browser: value });
+        return Object.assign(result2, { browser: value });
       } else if (arg.startsWith("--before")) {
-        return Object.assign(result, { before: parseModule(arg.split("=")[1]) });
+        return Object.assign(result2, { before: parseModule(arg.split("=")[1]) });
       } else if (arg.startsWith("--after")) {
-        return Object.assign(result, { after: parseModule(arg.split("=")[1]) });
+        return Object.assign(result2, { after: parseModule(arg.split("=")[1]) });
       } else if (arg === "--trace-perf") {
-        return result;
+        return result2;
       }
       if (arg.startsWith("-")) {
         console.warn(`# Warning: Unknown flag "${arg}" \u2014 ignored`);
-        return result;
+        return result2;
       }
-      result.inputs.add(
+      result2.inputs.add(
         arg.startsWith(projectRoot) || arg.startsWith("/") ? arg : path5.join(process.cwd(), arg)
       );
-      return result;
+      return result2;
     },
     { inputs: /* @__PURE__ */ new Set([]) }
   );
@@ -1152,10 +1152,10 @@ function parseCliFlags(projectRoot) {
   }
   return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
 }
-function parseBoolean(result, defaultValue = true) {
-  if (result === "true") {
+function parseBoolean(result2, defaultValue = true) {
+  if (result2 === "true") {
     return true;
-  } else if (result === "false") {
+  } else if (result2 === "false") {
     return false;
   }
   return defaultValue;
@@ -1375,7 +1375,7 @@ var init_indent_string = __esm({
 
 // lib/utils/source-map-decoder.ts
 function decodeMappings(mappings) {
-  const result = [];
+  const result2 = [];
   const cursor = { position: 0 };
   const mappingsLength = mappings.length;
   let segments = [];
@@ -1395,14 +1395,14 @@ function decodeMappings(mappings) {
     } else if (charCode === COMMA) {
       cursor.position++;
     } else {
-      result.push(segments);
+      result2.push(segments);
       segments = [];
       generatedCol = 0;
       cursor.position++;
     }
   }
-  result.push(segments);
-  return result;
+  result2.push(segments);
+  return result2;
 }
 function parseSourceMap(json, outDir) {
   const map = JSON.parse(json);
@@ -2517,9 +2517,9 @@ function registerSharedStaticHandler(server, groupConfigs) {
 function replaceAssetPaths(html, htmlPath, projectRoot) {
   const assetPaths = findInternalAssetsFromHTML(html);
   const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
-  return assetPaths.reduce((result, assetPath) => {
+  return assetPaths.reduce((result2, assetPath) => {
     const normalizedFullAbsolutePath = path6.normalize(`${htmlDirectory}/${assetPath}`);
-    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
+    return result2.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
 function testRuntimeToInject(config, groupId) {
@@ -3197,19 +3197,19 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
     jsx: "automatic",
     footer: { js: 'window.dispatchEvent(new CustomEvent("qunitx:tests-ready"));' }
   };
-  const hasSmallOutput = (result) => (result.outputFiles ?? []).some(
+  const hasSmallOutput = (result2) => (result2.outputFiles ?? []).some(
     (outputFile) => GROUP_OUTPUT_REGEX.test(outputFile.path) && !outputFile.path.endsWith(".map") && outputFile.contents.length < EMPTY_BUNDLE_THRESHOLD
   );
   const buildWithRetry = async (retriesLeft) => {
-    const result = await esbuild.build(buildOptions);
-    if (!hasSmallOutput(result) || retriesLeft === 0) return result;
+    const result2 = await esbuild.build(buildOptions);
+    if (!hasSmallOutput(result2) || retriesLeft === 0) return result2;
     await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
     return buildWithRetry(retriesLeft - 1);
   };
   try {
-    const result = await buildWithRetry(MAX_RETRIES);
+    const result2 = await buildWithRetry(MAX_RETRIES);
     await Promise.all(
-      (result.outputFiles ?? []).map((outputFile) => {
+      (result2.outputFiles ?? []).map((outputFile) => {
         const match = GROUP_OUTPUT_REGEX.exec(outputFile.path);
         if (!match) return Promise.resolve();
         const slotIndex = parseInt(match[1]);
@@ -3271,12 +3271,12 @@ function buildFilteredTests(filteredTests, outputPath, config) {
   );
 }
 async function runWithOverlayfsRetry(getContents, needsDisk) {
-  let { result, js } = await getContents();
+  let { result: result2, js } = await getContents();
   const initialSize = js.length;
   for (let retry = 1; retry <= MAX_RETRIES; retry++) {
     if (js.length >= EMPTY_BUNDLE_THRESHOLD) break;
     await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
-    ({ result, js } = await getContents());
+    ({ result: result2, js } = await getContents());
   }
   if (js.length < EMPTY_BUNDLE_THRESHOLD && js.length !== initialSize) {
     console.log(
@@ -3285,7 +3285,7 @@ async function runWithOverlayfsRetry(getContents, needsDisk) {
   }
   if (needsDisk) {
     await Promise.all(
-      result.outputFiles.map((outputFile) => fs10.writeFile(outputFile.path, outputFile.contents))
+      result2.outputFiles.map((outputFile) => fs10.writeFile(outputFile.path, outputFile.contents))
     );
   }
   return js;
@@ -3293,9 +3293,9 @@ async function runWithOverlayfsRetry(getContents, needsDisk) {
 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) };
+    const result2 = await esbuild.build(buildOpts);
+    const jsFile = result2.outputFiles.find((f) => !f.path.endsWith(".map"));
+    return { result: result2, js: Buffer.from(jsFile.contents) };
   }, needsDisk);
 }
 async function buildIncrementally(options, fileKey, cache, needsDisk) {
@@ -3308,9 +3308,9 @@ async function buildIncrementally(options, fileKey, cache, needsDisk) {
   }
   const ctx = cache._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) };
+    const result2 = await ctx.rebuild();
+    const jsFile = result2.outputFiles.find((f) => !f.path.endsWith(".map"));
+    return { result: result2, js: Buffer.from(jsFile.contents) };
   }, needsDisk);
 }
 function esbuildTarget(browser) {
@@ -3697,12 +3697,12 @@ function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFi
   }
   config._building = true;
   config._justAddedFiles = event === "add" ? /* @__PURE__ */ new Set([filePath]) : /* @__PURE__ */ new Set();
-  const result = onEventFunc(event, filePath);
-  if (!(result instanceof Promise)) {
+  const result2 = onEventFunc(event, filePath);
+  if (!(result2 instanceof Promise)) {
     config._building = false;
     return Promise.resolve();
   }
-  return result.then(() => onFinishFunc?.(filePath, event)).catch((error) => console.error("#", red("Build error:"), error.message || error)).finally(() => {
+  return result2.then(() => onFinishFunc?.(filePath, event)).catch((error) => console.error("#", red("Build error:"), error.message || error)).finally(() => {
     config._building = false;
     config._lastBuildEndMs = Date.now();
     if (config._pendingBuildTrigger) {
@@ -4211,14 +4211,14 @@ async function buildCachedContent(config, htmlPaths) {
     config.htmlPaths.map((htmlPath) => fs14.readFile(htmlPath).catch(() => null))
   );
   const cachedContent = htmlPaths.reduce(
-    (result, _htmlPath, index) => {
+    (result2, _htmlPath, index) => {
       const buffer = htmlBuffers[index];
-      if (buffer === null) return result;
+      if (buffer === null) return result2;
       const filePath = config.htmlPaths[index];
       const html = buffer.toString();
       if (isCustomTemplate(html)) {
-        result.dynamicContentHTMLs[filePath] = html;
-        result.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ""));
+        result2.dynamicContentHTMLs[filePath] = html;
+        result2.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ""));
       } else {
         console.log(
           "#",
@@ -4226,12 +4226,12 @@ async function buildCachedContent(config, htmlPaths) {
             `WARNING: Static html file with no {{qunitxScript}} or handlebars-style tokens detected. Therefore ignoring ${filePath}`
           )
         );
-        result.staticHTMLs[filePath] = html;
+        result2.staticHTMLs[filePath] = html;
       }
       findInternalAssetsFromHTML(html).forEach((key) => {
-        result.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath));
+        result2.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath));
       });
-      return result;
+      return result2;
     },
     {
       allTestCode: null,
@@ -4270,16 +4270,16 @@ async function readTimingCache(projectRoot) {
   }
 }
 function computeFileTimes(groups, weights, wallTimes) {
-  const result = /* @__PURE__ */ new Map();
+  const result2 = /* @__PURE__ */ new Map();
   groups.forEach((group, i) => {
     const wallMs = wallTimes.get(i);
     if (wallMs === void 0) return;
     const total = group.reduce((sum, f) => sum + (weights.get(f) ?? 0), 0);
     group.forEach(
-      (f) => result.set(f, total > 0 ? wallMs * ((weights.get(f) ?? 0) / total) : wallMs / group.length)
+      (f) => result2.set(f, total > 0 ? wallMs * ((weights.get(f) ?? 0) / total) : wallMs / group.length)
     );
   });
-  return result;
+  return result2;
 }
 async function persistTimings(fileTimes, projectRoot) {
   await fs14.writeFile(
@@ -4681,7 +4681,11 @@ __export(daemon_exports, {
 import { spawn as spawn3 } from "node:child_process";
 import fs16, { existsSync as existsSync3 } from "node:fs";
 import path13 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+async function buildDaemonSpawn() {
+  const sea = await import("node:sea").catch(() => null);
+  if (sea?.isSea()) return { bin: process.execPath, args: ["daemon", "_serve"] };
+  return { bin: process.execPath, args: [process.argv[1], "daemon", "_serve"] };
+}
 function runDaemonCommand() {
   const sub = process.argv[3];
   if (sub === "_serve") return runServeMode();
@@ -4719,7 +4723,8 @@ function waitForFile(filePath, timeoutMs) {
 async function spawnAndWaitForDaemon() {
   const parsed = parseDaemonIdleTimeout(process.env.QUNITX_DAEMON_IDLE_TIMEOUT);
   if (parsed.warning) process.stderr.write(parsed.warning + "\n");
-  spawn3(process.execPath, [CLI_ENTRY, "daemon", "_serve"], {
+  const { bin, args } = await buildDaemonSpawn();
+  spawn3(bin, args, {
     detached: true,
     stdio: "ignore",
     env: { ...process.env, QUNITX_DAEMON_CWD: process.cwd() }
@@ -4739,9 +4744,9 @@ async function startDaemon() {
 `);
     return 0;
   }
-  const result = await spawnAndWaitForDaemon();
-  if (result) {
-    process.stdout.write(`Daemon started (pid ${result.pid})
+  const result2 = await spawnAndWaitForDaemon();
+  if (result2) {
+    process.stdout.write(`Daemon started (pid ${result2.pid})
 `);
     return 0;
   }
@@ -4772,7 +4777,7 @@ async function statusDaemon() {
   );
   return 0;
 }
-var SPAWN_TIMEOUT_MS, highlight2, color2, USAGE, __filename, CLI_ENTRY;
+var SPAWN_TIMEOUT_MS, highlight2, color2, USAGE;
 var init_daemon = __esm({
   "lib/commands/daemon/index.ts"() {
     init_color();
@@ -4798,11 +4803,16 @@ ${color2("QUNITX_DAEMON_LOG=<path>")}     : redirect the daemon's stdout + stder
 
 ${highlight2("Tip:")} set ${color2("QUNITX_DAEMON=1")} to auto-spawn the daemon on the first qunitx run; ${color2("$ qunitx --help")} for top-level options.
 `;
-    __filename = fileURLToPath2(import.meta.url);
-    CLI_ENTRY = path13.resolve(path13.dirname(__filename), "..", "..", "..", "cli.ts");
   }
 });
 
+// lib/utils/enable-compile-cache.ts
+import module from "node:module";
+var result = module.enableCompileCache?.();
+if (result?.directory && !("NODE_COMPILE_CACHE" in process.env)) {
+  process.env.NODE_COMPILE_CACHE = result.directory;
+}
+
 // cli.ts
 init_chrome_prelaunch();
 init_package();

package/package.json

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