qunitx-cli 0.9.2 → 0.9.4

package/lib/setup/config.ts

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import defaultProjectConfigValues from './default-project-config-values.ts';
+import findProjectRoot from '../utils/find-project-root.ts';
+import setupFSTree from './fs-tree.ts';
+import setupTestFilePaths from './test-file-paths.ts';
+import parseCliFlags from '../utils/parse-cli-flags.ts';
+import type { Config } from '../types.ts';
+
+/**
+ * Builds the merged qunitx config from package.json settings and CLI flags.
+ * @returns {Promise<object>}
+ */
+export default async function setupConfig(): Promise<Config> {
+  const projectRoot = await findProjectRoot();
+  const cliConfigFlags = parseCliFlags(projectRoot);
+  const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
+  const inputs = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
+  const config = {
+    ...defaultProjectConfigValues,
+    htmlPaths: [] as string[],
+    ...((projectPackageJSON.qunitx as Partial<Config>) || {}),
+    ...cliConfigFlags,
+    projectRoot,
+    inputs,
+    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs),
+    lastFailedTestFiles: null as string[] | null,
+    lastRanTestFiles: null as string[] | null,
+    COUNTER: { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 },
+    _testRunDone: null as (() => void) | null,
+    _resetTestTimeout: null as (() => void) | null,
+  };
+  config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
+  config.fsTree = await setupFSTree(config.testFileLookupPaths, config);
+
+  return config as Config;
+}
+
+async function readConfigFromPackageJSON(projectRoot: string) {
+  const packageJSON = await fs.readFile(`${projectRoot}/package.json`);
+
+  return JSON.parse(packageJSON.toString()) as { qunitx?: unknown; [key: string]: unknown };
+}
+
+function normalizeHTMLPaths(projectRoot: string, htmlPaths: string[]): string[] {
+  return Array.from(new Set(htmlPaths.map((htmlPath) => `${projectRoot}/${htmlPath}`)));
+}
+
+function readInputsFromPackageJSON(packageJSON: {
+  qunitx?: unknown;
+  [key: string]: unknown;
+}): string[] {
+  const qunitx = packageJSON.qunitx as { inputs?: string[] } | undefined;
+
+  return qunitx && qunitx.inputs ? qunitx.inputs : [];
+}

package/lib/setup/{file-watcher.js → file-watcher.ts}

@@ -1,14 +1,21 @@
 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';
+import { green, magenta, red, yellow } from '../utils/color.ts';
+import type { FSWatcher } from 'node:fs';
+import type { Config, FSTree } from '../types.ts';
 
 /**
  * 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) {
+export default function setupFileWatchers(
+  testFileLookupPaths: string[],
+  config: Config,
+  onEventFunc: (event: string, file: string) => unknown,
+  onFinishFunc: ((path: string, event: string) => void) | null | undefined,
+): { fileWatchers: Record<string, FSWatcher>; killFileWatchers: () => Record<string, FSWatcher> } {
   const extensions = config.extensions || ['js', 'ts'];
   const fileWatchers = testFileLookupPaths.reduce((watchers, watchPath) => {
     let ready = false;
@@ -54,7 +61,14 @@ export default function setupFileWatchers(testFileLookupPaths, config, onEventFu
  * `unlinkDir` bypasses the extension filter so deleted directories always clean up fsTree.
  * @returns {void}
  */
-export function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc) {
+export function handleWatchEvent(
+  config: Config,
+  extensions: string[],
+  event: string,
+  filePath: string,
+  onEventFunc: (event: string, file: string) => unknown,
+  onFinishFunc: ((path: string, event: string) => void) | null | undefined,
+): void {
   const isFileEvent = extensions.some((ext) => filePath.endsWith(`.${ext}`));
 
   if (!isFileEvent && event !== 'unlinkDir') return;
@@ -97,7 +111,7 @@ export function handleWatchEvent(config, extensions, event, filePath, onEventFun
  * Mutates `fsTree` in place based on a chokidar file-system event.
  * @returns {void}
  */
-export function mutateFSTree(fsTree, event, path) {
+export function mutateFSTree(fsTree: FSTree, event: string, path: string): void {
   if (event === 'add') {
     fsTree[path] = null;
   } else if (event === 'unlink') {
@@ -109,7 +123,7 @@ export function mutateFSTree(fsTree, event, path) {
   }
 }
 
-function getEventColor(event) {
+function getEventColor(event: string): unknown {
   if (event === 'change') {
     return yellow('CHANGED:');
   } else if (event === 'add' || event === 'addDir') {

package/lib/setup/{fs-tree.js → fs-tree.ts}

@@ -1,9 +1,12 @@
-import fs from 'node:fs/promises';
+import fs, { glob as fsGlob } from 'node:fs/promises';
 import path from 'node:path';
-// @deno-types="npm:@types/picomatch"
-import picomatch from 'picomatch';
+import type { FSTree } from '../types.ts';
 
-async function readDirRecursive(dir, filter) {
+function isGlob(str: string): boolean {
+  return /[*?{[]/.test(str);
+}
+
+async function readDirRecursive(dir: string, filter: (name: string) => boolean): Promise<string[]> {
   const entries = await fs.readdir(dir, { recursive: true, withFileTypes: true });
   return entries
     .filter((e) => e.isFile() && filter(e.name))
@@ -14,32 +17,29 @@ async function readDirRecursive(dir, filter) {
  * Resolves an array of file paths, directories, or glob patterns into a flat `{ absolutePath: null }` map.
  * @returns {Promise<object>}
  */
-export default async function buildFSTree(fileAbsolutePaths, config = {}) {
+export default async function buildFSTree(
+  fileAbsolutePaths: string[],
+  config: { extensions?: string[] } = {},
+): Promise<FSTree> {
   const targetExtensions = config.extensions || ['js', 'ts'];
   const fsTree = {};
 
   await Promise.all(
     fileAbsolutePaths.map(async (fileAbsolutePath) => {
-      const glob = picomatch.scan(fileAbsolutePath);
-
       try {
-        if (glob.isGlob) {
-          const fileNames = await readDirRecursive(glob.base, (name) => {
-            return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
-          });
-
-          fileNames.forEach((fileName) => {
-            if (picomatch.isMatch(fileName, fileAbsolutePath, { bash: true })) {
+        if (isGlob(fileAbsolutePath)) {
+          for await (const fileName of fsGlob(fileAbsolutePath)) {
+            if (targetExtensions.some((ext) => fileName.endsWith(`.${ext}`))) {
               fsTree[fileName] = null;
             }
-          });
+          }
         } else {
           const entry = await fs.stat(fileAbsolutePath);
 
           if (entry.isFile()) {
             fsTree[fileAbsolutePath] = null;
           } else if (entry.isDirectory()) {
-            const fileNames = await readDirRecursive(glob.base, (name) => {
+            const fileNames = await readDirRecursive(fileAbsolutePath, (name) => {
               return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
             });
 

package/lib/setup/{keyboard-events.js → keyboard-events.ts}

@@ -1,12 +1,17 @@
-import { blue } from '../utils/color.js';
-import listenToKeyboardKey from '../utils/listen-to-keyboard-key.js';
-import runTestsInBrowser from '../commands/run/tests-in-browser.js';
+import { blue } from '../utils/color.ts';
+import listenToKeyboardKey from '../utils/listen-to-keyboard-key.ts';
+import runTestsInBrowser from '../commands/run/tests-in-browser.ts';
+import type { Config, CachedContent, Connections } from '../types.ts';
 
 /**
  * Registers watch-mode keyboard shortcuts: `qq` to abort, `qa` to run all, `qf` for last failed, `ql` for last run.
  * @returns {void}
  */
-export default function setupKeyboardEvents(config, cachedContent, connections) {
+export default function setupKeyboardEvents(
+  config: Config,
+  cachedContent: CachedContent,
+  connections: Connections,
+): void {
   listenToKeyboardKey('qq', () => abortBrowserQUnit(config, connections));
   listenToKeyboardKey('qa', () => {
     abortBrowserQUnit(config, connections);
@@ -28,6 +33,6 @@ export default function setupKeyboardEvents(config, cachedContent, connections)
   });
 }
 
-function abortBrowserQUnit(_config, connections) {
+function abortBrowserQUnit(_config: Config, connections: Connections): void {
   connections.server.publish('abort', 'abort');
 }

package/lib/setup/{test-file-paths.js → test-file-paths.ts}

@@ -1,28 +1,29 @@
-// @deno-types="npm:@types/picomatch"
-import picomatch from 'picomatch';
+import { matchesGlob } from 'node:path';
+
+function isGlob(str: string): boolean {
+  return /[*?{[]/.test(str);
+}
+
+interface PathMeta {
+  input: string;
+  isFile: boolean;
+  isGlob: boolean;
+}
 
 /**
  * Deduplicates a list of file, folder, and glob inputs so that more-specific paths covered by broader ones are removed.
  * @returns {string[]}
  */
-export default function setupTestFilePaths(_projectRoot, inputs) {
+export default function setupTestFilePaths(_projectRoot: string, inputs: string[]): string[] {
   // NOTE: very complex algorithm, order is very important
   const [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce(
     (result, input) => {
-      const isGlob = picomatch.scan(input).isGlob;
+      const glob = isGlob(input);
 
       if (!pathIsFile(input)) {
-        result[0].push({
-          input,
-          isFile: false,
-          isGlob,
-        });
+        result[0].push({ input, isFile: false, isGlob: glob });
       } else {
-        result[isGlob ? 1 : 2].push({
-          input,
-          isFile: true,
-          isGlob,
-        });
+        result[glob ? 1 : 2].push({ input, isFile: true, isGlob: glob });
       }
 
       return result;
@@ -52,35 +53,22 @@ export default function setupTestFilePaths(_projectRoot, inputs) {
   return result.map((metaItem) => metaItem.input);
 }
 
-function pathIsFile(path) {
+function pathIsFile(path: string): boolean {
   const inputs = path.split('/');
 
   return inputs[inputs.length - 1].includes('.');
 }
 
-function pathIsIncludedInPaths(paths, targetPath) {
+function pathIsIncludedInPaths(paths: PathMeta[], targetPath: PathMeta): boolean {
   return paths.some((path) => {
     if (path === targetPath) {
       return false;
     }
 
-    const globFormat = buildGlobFormat(path);
-
-    return picomatch.isMatch(targetPath.input, globFormat, { bash: true });
+    return matchesGlob(targetPath.input, buildGlobFormat(path));
   });
 }
 
-function buildGlobFormat(path) {
-  if (!path.isFile) {
-    if (!path.isGlob) {
-      return `${path.input}/*`;
-    } else if (path.input.endsWith('*')) {
-      // NOTE: could be problematic in future, investigate if I should check endsWith /*
-      return path.input;
-    }
-
-    return `${path.input}/*`;
-  }
-
-  return path.input;
+function buildGlobFormat(path: PathMeta): string {
+  return path.isFile ? path.input : `${path.input}/**`;
 }

package/lib/setup/{web-server.js → web-server.ts}

@@ -1,9 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
-import TAPDisplayTestResult from '../tap/display-test-result.js';
-import pathExists from '../utils/path-exists.js';
-import HTTPServer, { MIME_TYPES } from '../servers/http.js';
+import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.ts';
+import TAPDisplayTestResult from '../tap/display-test-result.ts';
+import pathExists from '../utils/path-exists.ts';
+import HTTPServer, { MIME_TYPES } from '../servers/http.ts';
+import type { Config, CachedContent } from '../types.ts';
 
 const fsPromise = fs.promises;
 
@@ -11,15 +12,7 @@ const fsPromise = fs.promises;
  * Creates and returns an HTTPServer with routes for the test HTML, filtered test page, and static assets, plus a WebSocket handler that streams TAP events.
  * @returns {object}
  */
-export default function setupWebServer(
-  config = {
-    port: 1234,
-    debug: false,
-    watch: false,
-    timeout: 10000,
-  },
-  cachedContent,
-) {
+export default function setupWebServer(config: Config, cachedContent: CachedContent): HTTPServer {
   const STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
   const server = new HTTPServer();
 
@@ -135,7 +128,7 @@ export default function setupWebServer(
   return server;
 }
 
-function replaceAssetPaths(html, htmlPath, projectRoot) {
+function replaceAssetPaths(html: string, htmlPath: string, projectRoot: string): string {
   const assetPaths = findInternalAssetsFromHTML(html);
   const htmlDirectory = htmlPath.split('/').slice(0, -1).join('/');
 
@@ -146,7 +139,7 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
   }, html);
 }
 
-function testRuntimeToInject(port, config) {
+function testRuntimeToInject(port: number, config: Config): string {
   return `<script>
     window.testTimeout = 0;
     setInterval(() => {
@@ -269,7 +262,11 @@ function testRuntimeToInject(port, config) {
   </script>`;
 }
 
-function escapeAndInjectTestsToHTML(html, testRuntimeCode, testContentCode) {
+function escapeAndInjectTestsToHTML(
+  html: string,
+  testRuntimeCode: string,
+  testContentCode: Buffer | string | null | undefined,
+): string {
   return html.replace(
     '{{content}}',
     testRuntimeCode.replace('{{allTestCode}}', testContentCode).replace('</script>', '<\/script>'), // NOTE: remove this when simple-html-tokenizer PR gets merged

package/lib/setup/{write-output-static-files.js → write-output-static-files.ts}

@@ -1,10 +1,14 @@
 import fs from 'node:fs/promises';
+import type { CachedContent } from '../types.ts';
 
 /**
  * Copies static HTML files and referenced assets from the project into the configured output directory.
  * @returns {Promise<void>}
  */
-export default async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
+export default async function writeOutputStaticFiles(
+  { projectRoot, output }: { projectRoot: string; output: string },
+  cachedContent: CachedContent,
+): Promise<void> {
   const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
     const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
 
@@ -24,6 +28,6 @@ export default async function writeOutputStaticFiles({ projectRoot, output }, ca
   await Promise.all(staticHTMLPromises.concat(assetPromises));
 }
 
-async function ensureFolderExists(assetPath) {
+async function ensureFolderExists(assetPath: string): Promise<void> {
   await fs.mkdir(assetPath.split('/').slice(0, -1).join('/'), { recursive: true });
 }

package/lib/tap/{display-final-result.js → display-final-result.ts}

@@ -1,11 +1,14 @@
+import type { Counter } from '../types.ts';
+
 /**
  * Prints the TAP plan line and test-run summary (total, pass, skip, fail, duration).
  * @returns {void}
  */
+
 export default function TAPDisplayFinalResult(
-  { testCount, passCount, skipCount, failCount },
-  timeTaken,
-) {
+  { testCount, passCount, skipCount, failCount }: Counter,
+  timeTaken: number,
+): void {
   console.log('');
   console.log(`1..${testCount}`);
   console.log(`# tests ${testCount}`);

package/lib/tap/{display-test-result.js → display-test-result.ts}

@@ -1,5 +1,21 @@
-import dumpYaml from './dump-yaml.js';
-import indentString from '../utils/indent-string.js';
+import dumpYaml from './dump-yaml.ts';
+import indentString from '../utils/indent-string.ts';
+import type { Counter } from '../types.ts';
+
+interface TestAssertion {
+  passed: boolean;
+  todo: boolean;
+  stack?: string;
+  actual?: unknown;
+  expected?: unknown;
+  message?: string;
+}
+interface TestDetails {
+  status: string;
+  fullName: string[];
+  runtime: number;
+  assertions: TestAssertion[];
+}
 
 // tape TAP output: ['operator', 'stack', 'at', 'expected', 'actual']
 // ava TAP output: ['message', 'name', 'at', 'assertion', 'values'] // Assertion #5, message
@@ -7,7 +23,7 @@ import indentString from '../utils/indent-string.js';
  * Formats and prints a single QUnit testEnd event as a TAP `ok`/`not ok` line with optional YAML failure block.
  * @returns {void}
  */
-export default function TAPDisplayTestResult(COUNTER, details) {
+export default function TAPDisplayTestResult(COUNTER: Counter, details: TestDetails): void {
   // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
   COUNTER.testCount++;
 
@@ -59,9 +75,9 @@ export default function TAPDisplayTestResult(COUNTER, details) {
   }
 }
 
-function getCircularReplacer() {
-  const ancestors = [];
-  return function (_key, value) {
+function getCircularReplacer(): (_key: string, value: unknown) => unknown {
+  const ancestors: object[] = [];
+  return function (this: object, _key: string, value: unknown) {
     if (typeof value !== 'object' || value === null) {
       return value;
     }

package/lib/tap/{dump-yaml.js → dump-yaml.ts}

@@ -17,11 +17,11 @@
 const NEEDS_QUOTING =
   /^$|^(null|true|false|~|yes|no|on|off|y|n)$|^[{[!|>'"#%@`]|^[-?:](\s|$)|^---|^[-+]?(\d|\.\d)|^\d{4}-\d{2}-\d{2}|: |#/i;
 
-function needsQuoting(str) {
+function needsQuoting(str: string): boolean {
   return NEEDS_QUOTING.test(str);
 }
 
-function dumpString(str, indent) {
+function dumpString(str: string, indent: string): string {
   if (str === '') return "''";
   if (str.includes('\n')) {
     // Block scalar |- (strip trailing newline), each line indented by current indent + 2
@@ -31,7 +31,7 @@ function dumpString(str, indent) {
   return str;
 }
 
-function dumpValue(value, indent) {
+function dumpValue(value: unknown, indent: string): string {
   if (value === null || value === undefined) return 'null';
   if (typeof value === 'boolean' || typeof value === 'number') return String(value);
   if (typeof value === 'string') return dumpString(value, indent);
@@ -48,7 +48,7 @@ function dumpValue(value, indent) {
 }
 
 // Emits `key: value\n` or `key:\n  ...\n` — no trailing space before block scalars.
-function yamlLine(key, value) {
+function yamlLine(key: string, value: unknown): string {
   const v = dumpValue(value, '');
   return v[0] === '\n' ? `${key}:${v}\n` : `${key}: ${v}\n`;
 }
@@ -58,7 +58,21 @@ function yamlLine(key, value) {
  * Uses a template literal (no Object.entries overhead) for the known top-level keys.
  * @returns {string}
  */
-export default function dumpYaml({ name, actual, expected, message, stack, at }) {
+export default function dumpYaml({
+  name,
+  actual,
+  expected,
+  message,
+  stack,
+  at,
+}: {
+  name: string;
+  actual: unknown;
+  expected: unknown;
+  message: string | null;
+  stack: string | null;
+  at: string | null;
+}): string {
   return (
     `name: ${dumpString(name, '')}\n` +
     yamlLine('actual', actual) +

package/lib/types.ts

@@ -0,0 +1,61 @@
+import type HTTPServer from './servers/http.ts';
+import type { Browser, Page } from 'playwright-core';
+import type { ChildProcess } from 'node:child_process';
+import type { Buffer } from 'node:buffer';
+
+export interface Counter {
+  testCount: number;
+  failCount: number;
+  skipCount: number;
+  passCount: number;
+  errorCount: number;
+}
+
+export type FSTree = Record<string, null>;
+
+export interface CachedContent {
+  allTestCode: Buffer | string | null;
+  filteredTestCode?: string;
+  assets: Set<string>;
+  htmlPathsToRunTests: string[];
+  mainHTML: { filePath: string | null; html: string | null };
+  staticHTMLs: Record<string, string>;
+  dynamicContentHTMLs: Record<string, string>;
+}
+
+export interface Config {
+  output: string;
+  timeout: number;
+  failFast: boolean;
+  port: number;
+  extensions: string[];
+  browser: 'chromium' | 'firefox' | 'webkit';
+  projectRoot: string;
+  inputs: string[];
+  htmlPaths: string[];
+  testFileLookupPaths: string[];
+  fsTree: FSTree;
+  before?: string | false;
+  after?: string | false;
+  watch?: boolean;
+  debug?: boolean;
+  COUNTER: Counter;
+  lastFailedTestFiles: string[] | null;
+  lastRanTestFiles: string[] | null;
+  _testRunDone: (() => void) | null;
+  _resetTestTimeout: (() => void) | null;
+  _groupMode?: boolean;
+  _building?: boolean;
+  expressApp?: unknown;
+}
+
+export interface Connections {
+  server: HTTPServer;
+  browser: Browser;
+  page: Page;
+}
+
+export interface EarlyChrome {
+  proc: ChildProcess;
+  cdpEndpoint: string;
+}

package/lib/utils/{chromium-args.js → chromium-args.ts}

@@ -15,4 +15,4 @@ export default [
   '--disable-translate',
   '--metrics-recording-only',
   '--disable-hang-monitor',
-];
+] as string[];

package/lib/utils/{color.js → color.ts}

@@ -5,8 +5,18 @@
  * Use `createColors(enabled)` in tests to exercise both enabled and disabled branches directly.
  */
 
-export function createColors(enabled) {
-  const c = (open, close) => (text) =>
+interface MagentaReturn {
+  bold: (t: string) => string;
+}
+
+interface MagentaFn {
+  (text: string): string;
+  (): MagentaReturn;
+}
+
+/** Creates a set of ANSI color helpers with coloring enabled or disabled. */
+export function createColors(enabled: boolean) {
+  const c = (open: number, close: number) => (text: string) =>
     enabled ? `\x1b[${open}m${text}\x1b[${close}m` : String(text);
 
   const red = c(31, 39);
@@ -15,10 +25,10 @@ export function createColors(enabled) {
   const blue = c(34, 39);
 
   /** `magenta(text)` — colored text. `magenta()` — chainable: `.bold(text)`. */
-  const magenta = (text) => {
+  const magenta = ((text?: string): string | MagentaReturn => {
     if (text !== undefined) return enabled ? `\x1b[35m${text}\x1b[39m` : String(text);
-    return { bold: (t) => (enabled ? `\x1b[35m\x1b[1m${t}\x1b[22m\x1b[39m` : String(t)) };
-  };
+    return { bold: (t: string) => (enabled ? `\x1b[35m\x1b[1m${t}\x1b[22m\x1b[39m` : String(t)) };
+  }) as MagentaFn;
 
   return { red, green, yellow, blue, magenta };
 }
@@ -32,22 +42,25 @@ const enabled =
 const _c = createColors(enabled);
 
 /** ANSI red text. */
-export function red(text) {
+export function red(text: string): string {
   return _c.red(text);
 }
 /** ANSI green text. */
-export function green(text) {
+export function green(text: string): string {
   return _c.green(text);
 }
 /** ANSI yellow text. */
-export function yellow(text) {
+export function yellow(text: string): string {
   return _c.yellow(text);
 }
 /** ANSI blue text. */
-export function blue(text) {
+export function blue(text: string): string {
   return _c.blue(text);
 }
 /** ANSI magenta text. Call without arguments to chain: `magenta().bold(text)`. */
-export function magenta(text) {
-  return _c.magenta(text);
+export function magenta(text: string): string;
+/** ANSI magenta text. Call without arguments to chain: `magenta().bold(text)`. */
+export function magenta(): MagentaReturn;
+export function magenta(text?: string): string | MagentaReturn {
+  return _c.magenta(text as string);
 }

package/lib/utils/{early-chrome.js → early-chrome.ts}

@@ -1,9 +1,9 @@
-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';
+import findChrome from './find-chrome.ts';
+import preLaunchChrome from './pre-launch-chrome.ts';
+import CHROMIUM_ARGS from './chromium-args.ts';
+import { perfLog } from './perf-logger.ts';
 
-// This module is statically imported by cli.js so its module-level code runs
+// This module is statically imported by cli.ts 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).

package/lib/utils/{find-chrome.js → find-chrome.ts}

@@ -11,7 +11,7 @@ const PATH_DIRS = (process.env.PATH || '').split(':').filter(Boolean);
  * fs.access/exec-based approaches to be delayed by hundreds of milliseconds.
  * @returns {string|null}
  */
-function findChromeSync() {
+function findChromeSync(): string | null {
   if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
 
   for (const dir of PATH_DIRS) {
@@ -33,6 +33,6 @@ function findChromeSync() {
  * with callers, but the resolution is synchronous.
  * @returns {Promise<string|null>}
  */
-export default function findChrome() {
+export default function findChrome(): Promise<string | null> {
   return Promise.resolve(findChromeSync());
 }