qunitx-cli 0.9.1 → 0.9.3

package/{cli.js → cli.ts}

@@ -1,10 +1,10 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --experimental-strip-types
 import process from 'node:process';
-import './lib/utils/early-chrome.js';
-import displayHelpOutput from './lib/commands/help.js';
-import initializeProject from './lib/commands/init.js';
-import generateTestFiles from './lib/commands/generate.js';
-import setupConfig from './lib/setup/config.js';
+import './lib/utils/early-chrome.ts';
+import displayHelpOutput from './lib/commands/help.ts';
+import initializeProject from './lib/commands/init.ts';
+import generateTestFiles from './lib/commands/generate.ts';
+import setupConfig from './lib/setup/config.ts';
 
 process.title = 'qunitx';
 
@@ -24,8 +24,16 @@ process.title = 'qunitx';
   // lets playwright-core start loading while config is being assembled.
   const [config, { default: run }] = await Promise.all([
     setupConfig(),
-    import('./lib/commands/run.js'),
+    import('./lib/commands/run.ts'),
   ]);
 
-  return await run(config);
+  try {
+    return await run(config);
+  } catch (error) {
+    console.error(error);
+    // Flush stdout before exit so any queued console.log writes (e.g. from WS testEnd
+    // handlers that fired before the exception) are not lost when process.exit() runs.
+    process.exitCode = 1;
+    process.stdout.write('\n', () => process.exit(1));
+  }
 })();

package/deno.lock

@@ -10,13 +10,14 @@
     "npm:esbuild@~0.27.3": "0.27.4",
     "npm:express@^5.2.1": "5.2.1",
     "npm:js-yaml@^4.1.1": "4.1.1",
-    "npm:picomatch@*": "4.0.3",
-    "npm:picomatch@^4.0.3": "4.0.3",
+    "npm:picomatch@*": "4.0.4",
+    "npm:picomatch@^4.0.4": "4.0.4",
     "npm:playwright-core@^1.58.2": "1.58.2",
     "npm:prettier@^3.8.1": "3.8.1",
-    "npm:qunitx@^1.0.3": "1.0.3",
-    "npm:ws@*": "8.19.0",
-    "npm:ws@^8.19.0": "8.19.0"
+    "npm:qunitx@^1.0.4": "1.0.4",
+    "npm:typescript@5": "5.9.3",
+    "npm:ws@*": "8.20.0",
+    "npm:ws@^8.20.0": "8.20.0"
   },
   "jsr": {
     "@std/fmt@1.0.9": {
@@ -473,8 +474,8 @@
     "path-to-regexp@8.3.0": {
       "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA=="
     },
-    "picomatch@4.0.3": {
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="
+    "picomatch@4.0.4": {
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="
     },
     "playwright-core@1.58.2": {
       "integrity": "sha512-yZkEtftgwS8CsfYo7nm0KE8jsvm6i/PTgVtB8DL726wNf6H2IMsDuxCpJj59KDaxCtSnrWan2AeDqM7JBaultg==",
@@ -497,8 +498,8 @@
         "side-channel"
       ]
     },
-    "qunitx@1.0.3": {
-      "integrity": "sha512-LdCQ0Sh85IvLqcAIIbIlNNC3NGEMlkuDUQl1gk3AH2d3Dv7HbEYEG+RW786c8w5gMfPh8gx1+PJKbuN2jqQf+g=="
+    "qunitx@1.0.4": {
+      "integrity": "sha512-iu3enOfQo5Ul5As+KFiN1Zm1kd8MWeeNcHFUbZpKYQn+y6f6V4yiDeehVc5LFSUFBOkutjnqHzZiqInCf0MutA=="
     },
     "range-parser@1.2.1": {
       "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="
@@ -603,6 +604,10 @@
         "mime-types"
       ]
     },
+    "typescript@5.9.3": {
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "bin": true
+    },
     "undici-types@7.18.2": {
       "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="
     },
@@ -615,8 +620,8 @@
     "wrappy@1.0.2": {
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
     },
-    "ws@8.19.0": {
-      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg=="
+    "ws@8.20.0": {
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA=="
     }
   },
   "workspace": {
@@ -631,11 +636,12 @@
         "npm:esbuild@~0.27.3",
         "npm:express@^5.2.1",
         "npm:js-yaml@^4.1.1",
-        "npm:picomatch@^4.0.3",
+        "npm:picomatch@^4.0.4",
         "npm:playwright-core@^1.58.2",
         "npm:prettier@^3.8.1",
-        "npm:qunitx@^1.0.3",
-        "npm:ws@^8.19.0"
+        "npm:qunitx@^1.0.4",
+        "npm:typescript@5",
+        "npm:ws@^8.20.0"
       ]
     }
   }

package/lib/commands/{generate.js → generate.ts}

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
-import { green } from '../utils/color.js';
-import findProjectRoot from '../utils/find-project-root.js';
-import pathExists from '../utils/path-exists.js';
-import readBoilerplate from '../utils/read-boilerplate.js';
+import { green } from '../utils/color.ts';
+import findProjectRoot from '../utils/find-project-root.ts';
+import pathExists from '../utils/path-exists.ts';
+import readBoilerplate from '../utils/read-boilerplate.ts';
 
 /**
  * Generates a new test file from the boilerplate template.
@@ -10,7 +10,7 @@ import readBoilerplate from '../utils/read-boilerplate.js';
  */
 export default async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
-  const moduleName = process.argv[3]; // TODO: classify this maybe in future
+  const moduleName = process.argv[3];
   const path =
     process.argv[3].endsWith('.js') || process.argv[3].endsWith('.ts')
       ? `${projectRoot}/${process.argv[3]}`

package/lib/commands/{help.js → help.ts}

@@ -1,4 +1,4 @@
-import { blue, magenta } from '../utils/color.js';
+import { blue, magenta } from '../utils/color.ts';
 import pkg from '../../package.json' with { type: 'json' };
 
 const highlight = (text) => magenta().bold(text);

package/lib/commands/{init.js → init.ts}

@@ -1,42 +1,37 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import findProjectRoot from '../utils/find-project-root.js';
-import pathExists from '../utils/path-exists.js';
-import defaultProjectConfigValues from '../setup/default-project-config-values.js';
-import readBoilerplate from '../utils/read-boilerplate.js';
+import findProjectRoot from '../utils/find-project-root.ts';
+import pathExists from '../utils/path-exists.ts';
+import defaultProjectConfigValues from '../setup/default-project-config-values.ts';
+import readBoilerplate from '../utils/read-boilerplate.ts';
 
 /** Bootstraps a new qunitx project: writes the test HTML template, updates package.json, and optionally writes tsconfig.json. */
 export default async function initializeProject() {
   const projectRoot = await findProjectRoot();
   const oldPackageJSON = JSON.parse(await fs.readFile(`${projectRoot}/package.json`));
-  const htmlPaths = process.argv.slice(2).reduce(
-    (result, arg) => {
-      if (arg.endsWith('.html')) {
-        result.push(arg);
-      }
-
-      return result;
-    },
-    oldPackageJSON.qunitx && oldPackageJSON.qunitx.htmlPaths ? oldPackageJSON.qunitx.htmlPaths : [],
-  );
-  const newQunitxConfig = Object.assign(
-    defaultProjectConfigValues,
-    htmlPaths.length > 0 ? { htmlPaths } : { htmlPaths: ['test/tests.html'] },
-    oldPackageJSON.qunitx,
-  );
+  const existingQunitx = oldPackageJSON.qunitx || {};
+  const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith('.html'));
+  const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
+    htmlPaths:
+      cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ['test/tests.html'],
+  });
 
   await Promise.all([
-    writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON),
-    rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON),
+    writeTestsHTML(projectRoot, config, oldPackageJSON),
+    rewritePackageJSON(projectRoot, config, oldPackageJSON),
     writeTSConfigIfNeeded(projectRoot),
   ]);
 }
 
-async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
+async function writeTestsHTML(
+  projectRoot: string,
+  config: { htmlPaths: string[]; output: string },
+  oldPackageJSON: Record<string, unknown>,
+): Promise<unknown[]> {
   const testHTMLTemplateBuffer = await readBoilerplate('setup/tests.hbs');
 
   return await Promise.all(
-    newQunitxConfig.htmlPaths.map(async (htmlPath) => {
+    config.htmlPaths.map(async (htmlPath) => {
       const targetPath = `${projectRoot}/${htmlPath}`;
       if (await pathExists(targetPath)) {
         return console.log(`${htmlPath} already exists`);
@@ -44,7 +39,7 @@ async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
         const targetDirectory = path.dirname(targetPath);
         const _targetOutputPath = path.relative(
           targetDirectory,
-          `${projectRoot}/${newQunitxConfig.output}/tests.js`,
+          `${projectRoot}/${config.output}/tests.js`,
         );
         const testHTMLTemplate = testHTMLTemplateBuffer.replace(
           '{{applicationName}}',
@@ -60,13 +55,17 @@ async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
   );
 }
 
-async function rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON) {
-  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: newQunitxConfig });
+async function rewritePackageJSON(
+  projectRoot: string,
+  config: unknown,
+  oldPackageJSON: Record<string, unknown>,
+): Promise<void> {
+  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
 
   await fs.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
 }
 
-async function writeTSConfigIfNeeded(projectRoot) {
+async function writeTSConfigIfNeeded(projectRoot: string): Promise<void> {
   const targetPath = `${projectRoot}/tsconfig.json`;
   if (!(await pathExists(targetPath))) {
     const tsConfigTemplate = await readBoilerplate('setup/tsconfig.json');

package/lib/commands/run/{tests-in-browser.js → tests-in-browser.ts}

@@ -1,12 +1,14 @@
 import fs from 'node:fs/promises';
-import { blue } from '../../utils/color.js';
+import { blue } from '../../utils/color.ts';
 import esbuild from 'esbuild';
-import timeCounter from '../../utils/time-counter.js';
-import runUserModule from '../../utils/run-user-module.js';
-import TAPDisplayFinalResult from '../../tap/display-final-result.js';
+import timeCounter from '../../utils/time-counter.ts';
+import runUserModule from '../../utils/run-user-module.ts';
+import TAPDisplayFinalResult from '../../tap/display-final-result.ts';
+import type { Config, CachedContent, Connections } from '../../types.ts';
+import type HTTPServer from '../../servers/http.ts';
 
 class BundleError extends Error {
-  constructor(message) {
+  constructor(message: unknown) {
     super(message);
     this.name = 'BundleError';
     this.message = `esbuild Bundle Error: ${message}`.split('\n').join('\n# ');
@@ -17,7 +19,7 @@ class BundleError extends Error {
  * Pre-builds the esbuild bundle for all test files and caches the result in `cachedContent`.
  * @returns {Promise<void>}
  */
-export async function buildTestBundle(config, cachedContent) {
+export async function buildTestBundle(config: Config, cachedContent: CachedContent): Promise<void> {
   const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
 
@@ -52,11 +54,11 @@ export async function buildTestBundle(config, cachedContent) {
  * @returns {Promise<object>}
  */
 export default async function runTestsInBrowser(
-  config,
-  cachedContent = {},
-  connections,
-  targetTestFilesToFilter,
-) {
+  config: Config,
+  cachedContent: CachedContent = {} as CachedContent,
+  connections: Connections,
+  targetTestFilesToFilter?: string[],
+): Promise<Connections | undefined> {
   const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
   const runHasFilter = !!targetTestFilesToFilter;
@@ -124,7 +126,11 @@ export default async function runTestsInBrowser(
   return connections;
 }
 
-function buildFilteredTests(filteredTests, outputPath, config) {
+function buildFilteredTests(
+  filteredTests: string[],
+  outputPath: string,
+  config: Config,
+): Promise<esbuild.BuildResult> {
   return esbuild.build({
     stdin: {
       contents: filteredTests.map((f) => `import "${f}";`).join(''),
@@ -137,31 +143,46 @@ function buildFilteredTests(filteredTests, outputPath, config) {
   });
 }
 
-async function runTestInsideHTMLFile(filePath, { page, server, browser }, config) {
+async function runTestInsideHTMLFile(
+  filePath: string,
+  { page, server, browser }: Connections,
+  config: Config,
+): Promise<void> {
   let QUNIT_RESULT;
   let targetError;
+  let timeoutHandle;
   try {
     console.log('#', blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
 
-    const testsDone = new Promise((resolve) => {
-      config._testRunDone = resolve;
+    // Single promise driven by the WS handler:
+    //   config._testRunDone()      → tests finished normally
+    //   config._resetTestTimeout() → reset idle timer; fires as timeout if silent for config.timeout ms
+    // This replaces waitForFunction (CDP polling), which raced against WS testEnd messages
+    // under load: CDP could win and trigger cleanup before Node.js processed the pending messages.
+    const testRaceResult = new Promise((resolve) => {
+      config._testRunDone = () => resolve(false);
+      config._resetTestTimeout = () => {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = setTimeout(() => resolve(true), config.timeout);
+      };
     });
 
     await page.goto(`http://localhost:${config.port}${filePath}`, {
       timeout: config.timeout + 10000,
     });
-    await Promise.race([
-      testsDone,
-      page.waitForFunction(`window.testTimeout >= ${config.timeout}`, null, {
-        timeout: config.timeout + 10000,
-      }),
-    ]);
+
+    config._resetTestTimeout(); // start idle countdown once the page is loaded
+
+    await testRaceResult;
 
     QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
   } catch (error) {
     targetError = error;
     console.log(error);
     console.error(error);
+  } finally {
+    clearTimeout(timeoutHandle);
+    config._resetTestTimeout = null;
   }
 
   if (!QUNIT_RESULT || QUNIT_RESULT.totalTests === 0) {
@@ -174,10 +195,18 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
+  } else if (QUNIT_RESULT.failedTests > config.COUNTER.failCount) {
+    // Safety net: browser tracked failures that WebSocket events never delivered to Node.js
+    // (e.g. WS connection dropped mid-run). Reconcile so the exit code is always correct.
+    config.COUNTER.failCount = QUNIT_RESULT.failedTests;
   }
 }
 
-async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false) {
+async function failOnNonWatchMode(
+  watchMode: boolean = false,
+  connections: { server?: HTTPServer; browser?: { close(): Promise<void> } } = {},
+  groupMode: boolean = false,
+): Promise<void> {
   if (!watchMode) {
     if (groupMode) {
       // Parent orchestrator handles cleanup and exit; signal failure via throw.

package/lib/commands/{run.js → run.ts}

@@ -1,23 +1,24 @@
-import setupBrowser, { launchBrowser } from '../setup/browser.js';
+import setupBrowser, { launchBrowser } from '../setup/browser.ts';
 import fs from 'node:fs/promises';
 import { normalize } from 'node:path';
 import { availableParallelism } from 'node:os';
-import { blue, yellow } from '../utils/color.js';
-import runTestsInBrowser, { buildTestBundle } from './run/tests-in-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';
-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 readBoilerplate from '../utils/read-boilerplate.js';
+import { blue, yellow } from '../utils/color.ts';
+import runTestsInBrowser, { buildTestBundle } from './run/tests-in-browser.ts';
+import fileWatcher from '../setup/file-watcher.ts';
+import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.ts';
+import runUserModule from '../utils/run-user-module.ts';
+import setupKeyboardEvents from '../setup/keyboard-events.ts';
+import writeOutputStaticFiles from '../setup/write-output-static-files.ts';
+import timeCounter from '../utils/time-counter.ts';
+import TAPDisplayFinalResult from '../tap/display-final-result.ts';
+import readBoilerplate from '../utils/read-boilerplate.ts';
+import type { Config, CachedContent } from '../types.ts';
 
 /**
  * Runs qunitx tests in headless Chrome, either in watch mode or concurrent batch mode.
  * @returns {Promise<void>}
  */
-export default async function run(config) {
+export default async function run(config: Config): Promise<void> {
   const cachedContent = await buildCachedContent(config, config.htmlPaths);
 
   if (config.watch) {
@@ -81,6 +82,8 @@ export default async function run(config) {
     }));
     const groupCachedContents = groups.map(() => ({ ...cachedContent }));
 
+    console.log('TAP version 13');
+
     // Build all group bundles and write static files while the browser is starting up.
     const [browser] = await Promise.all([
       launchBrowser(config),
@@ -93,34 +96,74 @@ export default async function run(config) {
         ),
       ),
     ]);
-
-    console.log('TAP version 13');
     const TIME_COUNTER = timeCounter();
-    let hasFatalError = false;
 
-    await Promise.allSettled(
-      groupConfigs.map(async (groupConfig, i) => {
-        const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
-        groupConfig.expressApp = connections.server;
+    // 3-minute per-group deadline. Firefox/WebKit can hang indefinitely in any Playwright
+    // operation (browser.newPage, page.evaluate, page.close) when overwhelmed by concurrent
+    // pages. Without this outer timeout, one stuck group freezes Promise.allSettled forever.
+    // After all groups settle, browser.close() (below) terminates the browser and unblocks
+    // any still-pending Playwright calls in background async fns.
+    const GROUP_TIMEOUT_MS = 3 * 60 * 1000;
 
-        if (config.before) {
-          await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, 'before');
-        }
+    // Keep the event loop alive during Promise.allSettled. The Chrome child process and its
+    // stderr pipe are unref'd (pre-launch-chrome.js). If Chrome crashes during group cleanup,
+    // all active handles close and the event loop would drain — exiting silently before
+    // allSettled resolves or results are printed. This interval holds the loop open so that
+    // unref'd group/page-close timers can still fire normally.
+    const keepAlive = setInterval(() => {}, 1000);
 
-        try {
-          await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
-        } catch {
-          hasFatalError = true;
-        } finally {
-          await Promise.all([
-            connections.server && connections.server.close(),
-            connections.page && connections.page.close(),
-          ]);
-        }
+    const groupResults = await Promise.allSettled(
+      groupConfigs.map((groupConfig, i) => {
+        const groupTimeout = new Promise((_, reject) => {
+          const t = setTimeout(
+            () => reject(new Error(`Group ${i} timed out after ${GROUP_TIMEOUT_MS}ms`)),
+            GROUP_TIMEOUT_MS,
+          );
+          t.unref();
+        });
+
+        return Promise.race([
+          (async () => {
+            const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
+            groupConfig.expressApp = connections.server;
+
+            if (config.before) {
+              await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, 'before');
+            }
+
+            try {
+              await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
+            } finally {
+              await Promise.all([
+                connections.server && connections.server.close(),
+                connections.page &&
+                  // Unref'd: the keepAlive interval above holds the event loop open, so this
+                  // timer still fires if page.close() hangs, without preventing process exit later.
+                  Promise.race([
+                    connections.page.close(),
+                    new Promise((resolve) => {
+                      const t = setTimeout(resolve, 10000);
+                      t.unref();
+                    }),
+                  ]).catch(() => {}),
+              ]);
+            }
+          })(),
+          groupTimeout,
+        ]);
       }),
     );
 
-    await browser.close();
+    const exitCode = groupResults.reduce(
+      (code, { status, reason }) => {
+        if (status !== 'rejected') return code;
+        console.error(reason);
+        return 1;
+      },
+      config.COUNTER.failCount > 0 ? 1 : 0,
+    );
+
+    process.exitCode = exitCode;
 
     TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
 
@@ -128,11 +171,22 @@ export default async function run(config) {
       await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
     }
 
-    process.exit(config.COUNTER.failCount > 0 || hasFatalError ? 1 : 0);
+    // Flush stdout then exit. keepAlive holds the event loop open until this callback fires,
+    // at which point process.exit() takes over — so clearInterval happens here, not earlier.
+    // If the write callback never fires (theoretical), the unref'd exitTimer is the fallback.
+    const exitTimer = setTimeout(() => process.exit(exitCode), 5000);
+    exitTimer.unref();
+    process.stdout.write('\n', () => {
+      clearTimeout(exitTimer);
+      clearInterval(keepAlive);
+      // Close browser after stdout is flushed; fire-and-forget since process.exit follows.
+      browser.close().catch(() => {});
+      process.exit(exitCode);
+    });
   }
 }
 
-async function buildCachedContent(config, htmlPaths) {
+async function buildCachedContent(config: Config, htmlPaths: string[]): Promise<CachedContent> {
   const htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs.readFile(htmlPath)));
   const cachedContent = htmlPaths.reduce(
     (result, _htmlPath, index) => {
@@ -175,7 +229,10 @@ async function buildCachedContent(config, htmlPaths) {
   return addCachedContentMainHTML(config.projectRoot, cachedContent);
 }
 
-async function addCachedContentMainHTML(projectRoot, cachedContent) {
+async function addCachedContentMainHTML(
+  projectRoot: string,
+  cachedContent: CachedContent,
+): Promise<CachedContent> {
   const mainHTMLPath = Object.keys(cachedContent.dynamicContentHTMLs)[0];
   if (mainHTMLPath) {
     cachedContent.mainHTML = {
@@ -191,13 +248,13 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
   return cachedContent;
 }
 
-function splitIntoGroups(files, groupCount) {
+function splitIntoGroups(files: string[], groupCount: number): string[][] {
   const groups = Array.from({ length: groupCount }, () => []);
   files.forEach((file, i) => groups[i % groupCount].push(file));
   return groups.filter((g) => g.length > 0);
 }
 
-function logWatcherAndKeyboardShortcutInfo(config, _server) {
+function logWatcherAndKeyboardShortcutInfo(config: Config, _server: unknown): void {
   console.log(
     '#',
     blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`),
@@ -210,7 +267,11 @@ function logWatcherAndKeyboardShortcutInfo(config, _server) {
   );
 }
 
-function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
+function normalizeInternalAssetPathFromHTML(
+  projectRoot: string,
+  assetPath: string,
+  htmlPath: string,
+): string {
   const currentDirectory = htmlPath ? htmlPath.split('/').slice(0, -1).join('/') : projectRoot;
   return assetPath.startsWith('./')
     ? normalize(`${currentDirectory}/${assetPath.slice(2)}`)