qunitx-cli 0.7.0 → 0.9.0

package/lib/commands/help.js

@@ -24,6 +24,7 @@ ${color('--output')} : folder to distribute built qunitx html and js that a webs
 ${color('--failFast')} : run the target file or folders with immediate abort if a single test fails
 ${color('--port')} : HTTP server port (auto-selects a free port if the given port is taken)[default: 1234]
 ${color('--extensions')} : comma-separated file extensions to track for discovery and watch-mode rebuilds[default: js,ts]
+${color('--browser')} : browser engine to run tests in: chromium, firefox, webkit[default: chromium]
 ${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)
 

package/lib/commands/run/tests-in-browser.js

@@ -48,7 +48,7 @@ export async function buildTestBundle(config, cachedContent) {
 }
 
 /**
- * Runs the esbuild-bundled tests inside a Puppeteer-controlled browser page and streams TAP output.
+ * Runs the esbuild-bundled tests inside a Playwright-controlled browser page and streams TAP output.
  * @returns {Promise<object>}
  */
 export default async function runTestsInBrowser(
@@ -147,15 +147,12 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
       config._testRunDone = resolve;
     });
 
-    await page.evaluateOnNewDocument(() => {
-      window.IS_PUPPETEER = true;
-    });
     await page.goto(`http://localhost:${config.port}${filePath}`, {
       timeout: config.timeout + 10000,
     });
     await Promise.race([
       testsDone,
-      page.waitForFunction(`window.testTimeout >= ${config.timeout}`, {
+      page.waitForFunction(`window.testTimeout >= ${config.timeout}`, null, {
         timeout: config.timeout + 10000,
       }),
     ]);

package/lib/commands/run.js

@@ -1,10 +1,9 @@
+import setupBrowser, { launchBrowser } from '../setup/browser.js';
 import fs from 'node:fs/promises';
 import { normalize } from 'node:path';
 import { availableParallelism } from 'node:os';
-import Puppeteer from 'puppeteer';
 import { blue, yellow } from '../utils/color.js';
 import runTestsInBrowser, { buildTestBundle } from './run/tests-in-browser.js';
-import setupBrowser from '../setup/browser.js';
 import fileWatcher from '../setup/file-watcher.js';
 import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
 import runUserModule from '../utils/run-user-module.js';
@@ -12,7 +11,6 @@ import setupKeyboardEvents from '../setup/keyboard-events.js';
 import writeOutputStaticFiles from '../setup/write-output-static-files.js';
 import timeCounter from '../utils/time-counter.js';
 import TAPDisplayFinalResult from '../tap/display-final-result.js';
-import findChrome from '../utils/find-chrome.js';
 import readBoilerplate from '../utils/read-boilerplate.js';
 
 /**
@@ -65,7 +63,7 @@ export default async function run(config) {
     // CONCURRENT MODE: split test files across N groups = availableParallelism().
     // All group bundles are built while Chrome is starting up, so esbuild time
     // is hidden behind the ~1.2s Chrome launch. Each group then gets its own
-    // HTTP server and Puppeteer page inside one shared browser instance.
+    // HTTP server and Playwright page inside one shared browser instance.
     const allFiles = Object.keys(config.fsTree);
     const groupCount = Math.min(allFiles.length, availableParallelism());
     const groups = splitIntoGroups(allFiles, groupCount);
@@ -83,32 +81,9 @@ export default async function run(config) {
     }));
     const groupCachedContents = groups.map(() => ({ ...cachedContent }));
 
-    // Build all group bundles and write static files while Chrome is starting up.
+    // Build all group bundles and write static files while the browser is starting up.
     const [browser] = await Promise.all([
-      findChrome().then((chromePath) =>
-        Puppeteer.launch({
-          args: [
-            '--no-sandbox',
-            '--disable-gpu',
-            '--remote-debugging-port=0',
-            '--window-size=1440,900',
-            '--disable-extensions',
-            '--disable-sync',
-            '--no-first-run',
-            '--disable-default-apps',
-            '--mute-audio',
-            '--disable-background-networking',
-            '--disable-background-timer-throttling',
-            '--disable-renderer-backgrounding',
-            '--disable-dev-shm-usage',
-            '--disable-translate',
-            '--metrics-recording-only',
-            '--disable-hang-monitor',
-          ],
-          executablePath: chromePath,
-          headless: true,
-        }),
-      ),
+      launchBrowser(config),
       Promise.all(
         groupConfigs.map((groupConfig, i) =>
           Promise.all([

package/lib/setup/browser.js

@@ -1,10 +1,62 @@
-import Puppeteer from 'puppeteer';
 import setupWebServer from './web-server.js';
 import bindServerToPort from './bind-server-to-port.js';
 import findChrome from '../utils/find-chrome.js';
+import CHROMIUM_ARGS from '../utils/chromium-args.js';
+import { earlyBrowserPromise } from '../utils/early-chrome.js';
+import { perfLog } from '../utils/perf-logger.js';
+
+// Playwright-core starts loading the moment run.js imports this module.
+// browser.js is intentionally the first import in run.js so playwright-core
+// starts loading before heavier deps (esbuild, chokidar) queue up I/O reads
+// and saturate libuv's thread pool, which would delay the dynamic import resolution.
+// early-chrome.js (statically imported by cli.js) already started Chrome pre-launch,
+// so both race in parallel — Chrome is typically ready when playwright-core finishes.
+const playwrightCorePromise = import('playwright-core');
+perfLog('browser.js: playwright-core import started');
+
+/**
+ * Launches a browser for the given config.browser type.
+ * For chromium: connects via CDP to the pre-launched Chrome (fast path) or falls
+ * back to chromium.launch() if pre-launch failed.
+ * For firefox/webkit: uses playwright's standard launch (requires `npx playwright install [browser]`).
+ * @returns {Promise<object>}
+ */
+export async function launchBrowser(config) {
+  const browserName = config.browser || 'chromium';
+
+  if (browserName === 'chromium') {
+    const waitStart = Date.now();
+    const [playwrightCore, earlyChrome] = await Promise.all([
+      playwrightCorePromise,
+      earlyBrowserPromise,
+    ]);
+    perfLog(
+      `browser.js: playwright-core + earlyChrome resolved in ${Date.now() - waitStart}ms, earlyChrome:`,
+      earlyChrome?.cdpEndpoint ?? null,
+    );
+
+    if (earlyChrome) {
+      const connectStart = Date.now();
+      const browser = await playwrightCore.chromium.connectOverCDP({
+        endpointURL: earlyChrome.cdpEndpoint,
+      });
+      perfLog(`browser.js: connectOverCDP took ${Date.now() - connectStart}ms`);
+      return browser;
+    }
+
+    // Pre-launch failed (Chrome not found, wrong version, etc.) — fall back to normal launch.
+    const executablePath = await findChrome();
+    const launchOptions = { args: CHROMIUM_ARGS, headless: true };
+    if (executablePath) launchOptions.executablePath = executablePath;
+    return playwrightCore.chromium.launch(launchOptions);
+  }
+
+  const playwrightCore = await playwrightCorePromise;
+  return playwrightCore[browserName].launch({ headless: true });
+}
 
 /**
- * Launches a Puppeteer browser (or reuses an existing one), starts the web server, and returns the page/server/browser connection object.
+ * Launches a Playwright browser (or reuses an existing one), starts the web server, and returns the page/server/browser connection object.
  * @returns {Promise<{server: object, browser: object, page: object}>}
  */
 export default async function setupBrowser(
@@ -13,51 +65,37 @@ export default async function setupBrowser(
     debug: false,
     watch: false,
     timeout: 10000,
+    browser: 'chromium',
   },
   cachedContent,
   existingBrowser = null,
 ) {
-  const [server, browser] = await Promise.all([
+  const setupStart = Date.now();
+  const [server, resolvedExistingBrowser] = await Promise.all([
     setupWebServer(config, cachedContent),
-    existingBrowser
-      ? Promise.resolve(existingBrowser)
-      : Puppeteer.launch({
-          debugger: config.debug || false,
-          args: [
-            '--no-sandbox',
-            '--disable-gpu',
-            '--remote-debugging-port=0',
-            '--window-size=1440,900',
-            '--disable-extensions',
-            '--disable-sync',
-            '--no-first-run',
-            '--disable-default-apps',
-            '--mute-audio',
-            '--disable-background-networking',
-            '--disable-background-timer-throttling',
-            '--disable-renderer-backgrounding',
-            '--disable-dev-shm-usage',
-            '--disable-translate',
-            '--metrics-recording-only',
-            '--disable-hang-monitor',
-          ],
-          executablePath: await findChrome(),
-          headless: true,
-        }),
+    Promise.resolve(existingBrowser),
   ]);
+  perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
+
+  const browser = resolvedExistingBrowser || (await launchBrowser(config));
+
+  const pageStart = Date.now();
   const [page] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
+  perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
 
-  page.on('console', async (msg) => {
-    if (config.debug) {
-      const args = await Promise.all(msg.args().map((arg) => turnToObjects(arg)));
+  await page.addInitScript(() => {
+    window.IS_PLAYWRIGHT = true;
+  });
 
-      console.log(...args);
+  page.on('console', async (msg) => {
+    if (!config.debug) return;
+    try {
+      const values = await Promise.all(msg.args().map((arg) => arg.jsonValue()));
+      console.log(...values);
+    } catch {
+      console.log(msg.text());
     }
   });
-  page.on('error', (msg) => {
-    console.error(msg, msg.stack);
-    console.log(msg, msg.stack);
-  });
   page.on('pageerror', (error) => {
     console.log(error.toString());
     console.error(error.toString());
@@ -65,7 +103,3 @@ export default async function setupBrowser(
 
   return { server, browser, page };
 }
-
-function turnToObjects(jsHandle) {
-  return jsHandle.jsonValue();
-}

package/lib/setup/default-project-config-values.js

@@ -5,4 +5,5 @@ export default {
   failFast: false,
   port: 1234,
   extensions: ['js', 'ts'],
+  browser: 'chromium',
 };

package/lib/setup/file-watcher.js

@@ -1,20 +1,42 @@
-import chokidar from 'chokidar';
+import fs from 'node:fs';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
 import { green, magenta, red, yellow } from '../utils/color.js';
 
 /**
- * Starts chokidar watchers for each lookup path and calls `onEventFunc` on JS/TS file changes, debounced via a global flag.
+ * Starts `fs.watch` watchers for each lookup path and calls `onEventFunc` on JS/TS file changes, debounced via a flag.
+ * Uses `config.fsTree` to distinguish `unlink` (tracked file) from `unlinkDir` (directory) on deletion.
  * @returns {object}
  */
 export default function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
   const extensions = config.extensions || ['js', 'ts'];
-  const fileWatchers = testFileLookupPaths.reduce((watcher, watchPath) => {
-    return Object.assign(watcher, {
-      [watchPath]: chokidar
-        .watch(watchPath, { ignoreInitial: true })
-        .on('all', (event, filePath) =>
-          handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc),
-        ),
+  const fileWatchers = testFileLookupPaths.reduce((watchers, watchPath) => {
+    let ready = false;
+    const watcher = fs.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+      if (!ready || !filename) return;
+      const fullPath = path.join(watchPath, filename);
+      if (eventType === 'change') {
+        return handleWatchEvent(config, extensions, 'change', fullPath, onEventFunc, onFinishFunc);
+      }
+      try {
+        const s = await stat(fullPath);
+        handleWatchEvent(
+          config,
+          extensions,
+          s.isDirectory() ? 'addDir' : 'add',
+          fullPath,
+          onEventFunc,
+          onFinishFunc,
+        );
+      } catch {
+        const event = config.fsTree && fullPath in config.fsTree ? 'unlink' : 'unlinkDir';
+        handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
+      }
     });
+    setImmediate(() => {
+      ready = true;
+    });
+    return Object.assign(watchers, { [watchPath]: watcher });
   }, {});
 
   return {
@@ -28,7 +50,7 @@ export default function setupFileWatchers(testFileLookupPaths, config, onEventFu
 }
 
 /**
- * Routes a chokidar event to fsTree mutation and optional rebuild trigger.
+ * Routes a file-system event to fsTree mutation and optional rebuild trigger.
  * `unlinkDir` bypasses the extension filter so deleted directories always clean up fsTree.
  * @returns {void}
  */

package/lib/setup/web-server.js

@@ -171,9 +171,9 @@ function testRuntimeToInject(port, config) {
           retryOrFail();
         });
         window.socket.addEventListener('message', function(messageEvent) {
-          if (!window.IS_PUPPETEER && messageEvent.data === 'refresh') {
+          if (!window.IS_PLAYWRIGHT && messageEvent.data === 'refresh') {
             window.location.reload(true);
-          } else if (window.IS_PUPPETEER && messageEvent.data === 'abort') {
+          } else if (window.IS_PLAYWRIGHT && messageEvent.data === 'abort') {
             window.abortQUnit = true;
             window.QUnit.config.queue.length = 0;
             window.socket.send(JSON.stringify({ event: 'abort' }));
@@ -223,12 +223,12 @@ function testRuntimeToInject(port, config) {
       }
 
       window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PUPPETEER) {
+        if (window.IS_PLAYWRIGHT) {
           window.socket.send(JSON.stringify({ event: 'connection' }));
         }
       });
       window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PUPPETEER) {
+        if (window.IS_PLAYWRIGHT) {
           window.socket.send(JSON.stringify({ event: 'moduleStart', details: details }, getCircularReplacer()));
         }
       });
@@ -240,7 +240,7 @@ function testRuntimeToInject(port, config) {
         window.testTimeout = 0;
         window.QUNIT_RESULT.finishedTests++;
         window.QUNIT_RESULT.currentTest = null;
-        if (window.IS_PUPPETEER) {
+        if (window.IS_PLAYWRIGHT) {
           window.socket.send(JSON.stringify({ event: 'testEnd', details: details, abort: window.abortQUnit }, getCircularReplacer()));
 
           if (${config.failFast} && details.status === 'failed') {
@@ -249,10 +249,15 @@ function testRuntimeToInject(port, config) {
         }
       });
       window.QUnit.done((details) => {
-        if (window.IS_PUPPETEER) {
+        if (window.IS_PLAYWRIGHT) {
           window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+          // Delay the testTimeout fallback so the WS done event can arrive at Node.js first.
+          // Without this delay, waitForFunction resolves before Node.js processes the done WS
+          // message, causing the shared COUNTER to miss testEnd results under concurrent load.
+          window.setTimeout(() => { window.testTimeout = ${config.timeout}; }, 500);
+        } else {
+          window.testTimeout = ${config.timeout};
         }
-        window.testTimeout = ${config.timeout};
       });
 
       window.QUnit.start();

package/lib/utils/chromium-args.js

@@ -0,0 +1,18 @@
+/** Launch args passed to Chromium for both the CDP pre-launch spawn and the playwright fallback launch. */
+export default [
+  '--no-sandbox',
+  '--disable-gpu',
+  '--window-size=1440,900',
+  '--disable-extensions',
+  '--disable-sync',
+  '--no-first-run',
+  '--disable-default-apps',
+  '--mute-audio',
+  '--disable-background-networking',
+  '--disable-background-timer-throttling',
+  '--disable-renderer-backgrounding',
+  '--disable-dev-shm-usage',
+  '--disable-translate',
+  '--metrics-recording-only',
+  '--disable-hang-monitor',
+];

package/lib/utils/early-chrome.js

@@ -0,0 +1,39 @@
+import findChrome from './find-chrome.js';
+import preLaunchChrome from './pre-launch-chrome.js';
+import CHROMIUM_ARGS from './chromium-args.js';
+import { perfLog } from './perf-logger.js';
+
+// This module is statically imported by cli.js so its module-level code runs
+// at the very start of the process — before the IIFE, before playwright-core loads.
+// For run commands only, Chrome is spawned immediately via CDP so it is ready
+// (or nearly ready) by the time playwright-core finishes loading (~500ms later).
+// For help/init/generate, nothing is spawned and this module costs ~0ms.
+
+const NON_RUN_COMMANDS = new Set(['help', 'h', 'p', 'print', 'new', 'n', 'g', 'generate', 'init']);
+const isRunCommand = Boolean(process.argv[2]) && !NON_RUN_COMMANDS.has(process.argv[2]);
+const browserFromArgv =
+  process.argv.find((arg) => arg.startsWith('--browser='))?.split('=')[1] || 'chromium';
+
+let earlyChromeProcRef = null;
+process.on('exit', () => earlyChromeProcRef?.kill());
+
+perfLog('early-chrome.js: module evaluated');
+
+/**
+ * Resolves to `{ proc, cdpEndpoint }` when Chrome is pre-launched and ready,
+ * or `null` if pre-launch was skipped (non-run command or non-chromium browser).
+ * @type {Promise<{proc: import('node:child_process').ChildProcess, cdpEndpoint: string} | null>}
+ */
+export const earlyBrowserPromise =
+  isRunCommand && browserFromArgv === 'chromium'
+    ? findChrome()
+        .then((chromePath) => {
+          perfLog('early-chrome.js: findChrome resolved', chromePath);
+          return preLaunchChrome(chromePath, CHROMIUM_ARGS);
+        })
+        .then((info) => {
+          perfLog('early-chrome.js: Chrome CDP ready', info?.cdpEndpoint ?? null);
+          if (info) earlyChromeProcRef = info.proc;
+          return info;
+        })
+    : Promise.resolve(null);

package/lib/utils/find-chrome.js

@@ -1,20 +1,38 @@
-import { exec } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
+import { join } from 'node:path';
 
 const CANDIDATES = ['google-chrome-stable', 'google-chrome', 'chromium', 'chromium-browser'];
+const PATH_DIRS = (process.env.PATH || '').split(':').filter(Boolean);
 
 /**
- * Resolves the Chrome/Chromium executable path from `CHROME_BIN` or by probing common binary names.
+ * Synchronously resolves the Chrome/Chromium executable path from `CHROME_BIN` or by probing
+ * common binary names in PATH directories using accessSync.
+ * Synchronous to avoid I/O saturation during the module-loading phase, which would cause async
+ * fs.access/exec-based approaches to be delayed by hundreds of milliseconds.
+ * @returns {string|null}
+ */
+function findChromeSync() {
+  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
+
+  for (const dir of PATH_DIRS) {
+    for (const name of CANDIDATES) {
+      const fullPath = join(dir, name);
+      try {
+        accessSync(fullPath, constants.X_OK);
+        return fullPath;
+      } catch {
+        // not found or not executable, try next
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolves the Chrome/Chromium executable path. Returns a Promise for API compatibility
+ * with callers, but the resolution is synchronous.
  * @returns {Promise<string|null>}
  */
 export default function findChrome() {
-  if (process.env.CHROME_BIN) return Promise.resolve(process.env.CHROME_BIN);
-
-  return Promise.any(
-    CANDIDATES.map(
-      (name) =>
-        new Promise((resolve, reject) =>
-          exec(`which ${name}`, (err, stdout) => (err ? reject() : resolve(stdout.trim()))),
-        ),
-    ),
-  ).catch(() => null);
+  return Promise.resolve(findChromeSync());
 }

package/lib/utils/parse-cli-flags.js

@@ -33,10 +33,21 @@ export default function parseCliFlags(projectRoot) {
             .split(',')
             .map((e) => e.trim()),
         });
+      } else if (arg.startsWith('--browser')) {
+        const value = arg.split('=')[1];
+        if (!['chromium', 'firefox', 'webkit'].includes(value)) {
+          console.error(
+            `Invalid --browser value: "${value}". Must be one of: chromium, firefox, webkit`,
+          );
+          process.exit(1);
+        }
+        return Object.assign(result, { browser: value });
       } else if (arg.startsWith('--before')) {
         return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
       } else if (arg.startsWith('--after')) {
         return Object.assign(result, { after: parseModule(arg.split('=')[1]) });
+      } else if (arg === '--trace-perf') {
+        return result; // consumed by perf-logger.js at module load time, not stored in config
       }
 
       // maybe set watch depth via micromatch(so incl metadata)

package/lib/utils/perf-logger.js

@@ -0,0 +1,25 @@
+/**
+ * Performance tracing logger for qunitx internals.
+ *
+ * Enable by passing `--trace-perf` to any run command:
+ *   qunitx test/foo.js --trace-perf
+ *
+ * All perfLog() calls are zero-overhead no-ops when tracing is disabled —
+ * the flag is read once at module load time, no per-call argument evaluation.
+ */
+
+const isPerfTracing = process.argv.includes('--trace-perf');
+
+const processStart = isPerfTracing ? Date.now() : 0;
+
+/**
+ * Writes a timestamped perf trace line to stderr when --trace-perf is active.
+ * @param {string} label
+ * @param {...*} details
+ */
+export function perfLog(label, ...details) {
+  if (!isPerfTracing) return;
+  const elapsed = Date.now() - processStart;
+  const suffix = details.length ? ' ' + details.join(' ') : '';
+  process.stderr.write(`[perf +${elapsed}ms] ${label}${suffix}\n`);
+}

package/lib/utils/pre-launch-chrome.js

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process';
+
+const CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
+
+/**
+ * Spawns a headless Chrome process with remote-debugging-port=0 and resolves once the
+ * CDP WebSocket endpoint is printed to stderr. Returns null if Chrome is unavailable or
+ * fails to start, so callers can fall back to playwright's normal launch.
+ * @returns {Promise<{proc: ChildProcess, cdpEndpoint: string} | null>}
+ */
+export default function preLaunchChrome(chromePath, args) {
+  if (!chromePath) return Promise.resolve(null);
+
+  return new Promise((resolve) => {
+    const proc = spawn(chromePath, ['--remote-debugging-port=0', '--headless=new', ...args], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+
+    let buffer = '';
+    proc.stderr.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const match = buffer.match(CDP_URL_REGEX);
+      if (match) resolve({ proc, cdpEndpoint: match[1] });
+    });
+
+    // Resolve null on any startup failure so launchBrowser falls back to chromium.launch()
+    proc.on('error', () => resolve(null));
+    proc.on('close', (code) => {
+      if (code !== null && code !== 0) resolve(null);
+    });
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "main": "cli.js",
   "author": "Izel Nakri",
@@ -21,13 +21,12 @@
     "lint": "deno lint lib/ cli.js",
     "lint:docs": "node scripts/lint-docs.js",
     "docs": "deno doc --html --name=\"qunitx-cli\" --output=docs/lib 'lib/**/*.js' README.md",
-    "build": "node build.js",
     "changelog:unreleased": "git-cliff --unreleased --strip all",
     "changelog:preview": "git-cliff",
     "changelog:update": "git-cliff --output CHANGELOG.md",
-    "postinstall": "deno install --allow-scripts=npm:puppeteer || true",
-    "prepack": "npm run build",
+    "postinstall": "deno install --allow-scripts=npm:playwright-core || true",
     "test": "node test/setup.js && FORCE_COLOR=0 node --test test/**/*-test.js",
+    "test:browser": "node test/setup.js && FORCE_COLOR=0 node --test test/flags/*-test.js test/inputs/*-test.js",
     "test:sanity-first": "./cli.js test/helpers/failing-tests.js test/helpers/failing-tests.ts",
     "test:sanity-second": "./cli.js test/helpers/passing-tests.js test/helpers/passing-tests.ts"
   },
@@ -43,18 +42,17 @@
     "url": "https://github.com/izelnakri/qunitx-cli.git"
   },
   "dependencies": {
-    "chokidar": "^5.0.0",
     "esbuild": "^0.27.3",
     "picomatch": "^4.0.3",
-    "puppeteer": "^24.38.0",
+    "playwright-core": "^1.58.2",
     "ws": "^8.19.0"
   },
   "devDependencies": {
     "cors": "^2.8.6",
     "express": "^5.2.1",
+    "js-yaml": "^4.1.1",
     "prettier": "^3.8.1",
-    "qunit": "^2.25.0",
-    "qunitx": "^1.0.0"
+    "qunitx": "^1.0.3"
   },
   "volta": {
     "node": "24.14.0"

package/vendor/package.json

@@ -1 +0,0 @@
-{"name":"qunitx-vendor","version":"0.0.1"}