qunitx-cli 0.9.1 → 0.9.3

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++;
 
@@ -23,7 +39,7 @@ export default function TAPDisplayTestResult(COUNTER, details) {
       details.fullName.join(' | '),
       `# (${details.runtime.toFixed(0)} ms)`,
     );
-    details.assertions.reduce((errorCount, assertion, index) => {
+    details.assertions.forEach((assertion, index) => {
       if (!assertion.passed && assertion.todo === false) {
         COUNTER.errorCount = (COUNTER.errorCount ?? 0) + 1;
         const stack = assertion.stack?.match(/\(.+\)/g);
@@ -32,7 +48,7 @@ export default function TAPDisplayTestResult(COUNTER, details) {
         console.log(
           indentString(
             dumpYaml({
-              name: `Assertion #${index + 1}`, // TODO: check what happens on runtime errors
+              name: `Assertion #${index + 1}`,
               actual: assertion.actual
                 ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer()))
                 : assertion.actual,
@@ -48,9 +64,7 @@ export default function TAPDisplayTestResult(COUNTER, details) {
         );
         console.log('  ...');
       }
-
-      return errorCount;
-    }, 0);
+    });
   } else if (details.status === 'passed') {
     COUNTER.passCount++;
     console.log(
@@ -61,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());
 }

package/lib/utils/{find-internal-assets-from-html.js → find-internal-assets-from-html.ts}

@@ -6,7 +6,7 @@ const LINK_HREF_REGEX = /<link[^>]+\bhref=['"]([^'"]+)['"]/gi;
  * Parses an HTML string and returns all internal (non-absolute-URL) `<script src>` and `<link href>` paths.
  * @returns {string[]}
  */
-export default function findInternalAssetsFromHTML(htmlContent) {
+export default function findInternalAssetsFromHTML(htmlContent: string): string[] {
   const links = [...htmlContent.matchAll(LINK_HREF_REGEX)]
     .map((m) => m[1])
     .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));

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

@@ -1,18 +1,18 @@
 import process from 'node:process';
-import searchInParentDirectories from './search-in-parent-directories.js';
+import searchInParentDirectories from './search-in-parent-directories.ts';
 
 /**
  * Walks up parent directories from `cwd` to find the nearest `package.json` and returns its directory path.
  * @returns {Promise<string>}
  */
-export default async function findProjectRoot() {
+export default async function findProjectRoot(): Promise<string> {
   try {
     const absolutePath = await searchInParentDirectories('.', 'package.json');
-    if (!absolutePath.includes('package.json')) {
+    if (!absolutePath!.includes('package.json')) {
       throw new Error('package.json mising');
     }
 
-    return absolutePath.replace('/package.json', '');
+    return absolutePath!.replace('/package.json', '');
   } catch (_error) {
     console.log('couldnt find projects package.json, did you run $ npm init ??');
     process.exit(1);

package/lib/utils/{indent-string.js → indent-string.ts}

@@ -2,12 +2,16 @@
  * Prepends `count` repetitions of `indent` (default: one space) to each non-empty line of `string`.
  * @example
  * ```js
- * import indentString from './lib/utils/indent-string.js';
+ * import indentString from './lib/utils/indent-string.ts';
  * console.assert(indentString('hello\nworld', 2) === '  hello\n  world');
  * ```
  * @returns {string}
  */
-export default function indentString(string, count = 1, options = {}) {
+export default function indentString(
+  string: string,
+  count: number = 1,
+  options: { indent?: string; includeEmptyLines?: boolean } = {},
+): string {
   const { indent = ' ', includeEmptyLines = false } = options;
 
   if (count <= 0) {

package/lib/utils/{listen-to-keyboard-key.js → listen-to-keyboard-key.ts}

@@ -1,8 +1,9 @@
 import process from 'node:process';
 
 const stdin = process.stdin;
-const targetInputs = {};
-const inputs = [];
+const targetInputs: Record<string, { caseSensitive: boolean; closure: (input: string) => void }> =
+  {};
+const inputs: (string | undefined)[] = [];
 let listenerAdded = false;
 
 /**
@@ -10,10 +11,11 @@ let listenerAdded = false;
  * @returns {void}
  */
 export default function listenToKeyboardKey(
-  inputString,
-  closure,
-  options = { caseSensitive: false },
-) {
+  inputString: string,
+  closure: (input: string) => void,
+  options: { caseSensitive: boolean } = { caseSensitive: false },
+): void {
+  if (!stdin.isTTY) return;
   stdin.setRawMode(true);
   stdin.resume();
   stdin.setEncoding('utf8');
@@ -43,7 +45,10 @@ export default function listenToKeyboardKey(
   targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
 }
 
-function targetListenerConformsToCase(targetListener, inputString) {
+function targetListenerConformsToCase(
+  targetListener: { caseSensitive: boolean },
+  inputString: string,
+): boolean {
   if (targetListener.caseSensitive) {
     return inputString === inputString.toUpperCase();
   }

package/lib/utils/{parse-cli-flags.js → parse-cli-flags.ts}

@@ -1,9 +1,24 @@
 // { inputs: [], debug: true, watch: true, failFast: true, htmlPaths: [], output }
+interface ParsedFlags {
+  inputs: string[];
+  debug?: boolean;
+  watch?: boolean;
+  failFast?: boolean;
+  timeout?: number;
+  output?: string;
+  htmlPaths?: string[];
+  port?: number;
+  extensions?: string[];
+  browser?: 'chromium' | 'firefox' | 'webkit';
+  before?: string | false;
+  after?: string | false;
+}
+
 /**
  * Parses `process.argv` into a qunitx flag object (`inputs`, `debug`, `watch`, `failFast`, `timeout`, `output`, `port`, `before`, `after`).
  * @returns {object}
  */
-export default function parseCliFlags(projectRoot) {
+export default function parseCliFlags(projectRoot: string): ParsedFlags {
   const providedFlags = process.argv.slice(2).reduce(
     (result, arg) => {
       if (arg.startsWith('--debug')) {
@@ -41,7 +56,7 @@ export default function parseCliFlags(projectRoot) {
           );
           process.exit(1);
         }
-        return Object.assign(result, { browser: value });
+        return Object.assign(result, { browser: value as 'chromium' | 'firefox' | 'webkit' });
       } else if (arg.startsWith('--before')) {
         return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
       } else if (arg.startsWith('--after')) {
@@ -55,15 +70,13 @@ export default function parseCliFlags(projectRoot) {
 
       return result;
     },
-    { inputs: new Set([]) },
+    { inputs: new Set<string>([]) } as ParsedFlags & { inputs: Set<string> },
   );
 
-  providedFlags.inputs = Array.from(providedFlags.inputs);
-
-  return providedFlags;
+  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
 }
 
-function parseBoolean(result, defaultValue = true) {
+function parseBoolean(result: string, defaultValue = true): boolean {
   if (result === 'true') {
     return true;
   } else if (result === 'false') {
@@ -73,7 +86,7 @@ function parseBoolean(result, defaultValue = true) {
   return defaultValue;
 }
 
-function parseModule(value) {
+function parseModule(value: string): string | false {
   if (['false', "'false'", '"false"', ''].includes(value)) {
     return false;
   }

package/lib/utils/{path-exists.js → path-exists.ts}

@@ -4,13 +4,13 @@ import fs from 'node:fs/promises';
  * Returns `true` if the given filesystem path is accessible, `false` otherwise.
  * @example
  * ```js
- * import pathExists from './lib/utils/path-exists.js';
+ * import pathExists from './lib/utils/path-exists.ts';
  * console.assert(await pathExists('/tmp') === true);
  * console.assert(await pathExists('/tmp/nonexistent-qunitx-file') === false);
  * ```
  * @returns {Promise<boolean>}
  */
-export default async function pathExists(path) {
+export default async function pathExists(path: string): Promise<boolean> {
   try {
     await fs.access(path);
 

package/lib/utils/{perf-logger.js → perf-logger.ts}

@@ -17,7 +17,7 @@ const processStart = isPerfTracing ? Date.now() : 0;
  * @param {string} label
  * @param {...*} details
  */
-export function perfLog(label, ...details) {
+export function perfLog(label: string, ...details: unknown[]): void {
   if (!isPerfTracing) return;
   const elapsed = Date.now() - processStart;
   const suffix = details.length ? ' ' + details.join(' ') : '';

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

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process';
+import type { EarlyChrome } from '../types.ts';
+
+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: string | null | undefined,
+  args: string[],
+): Promise<EarlyChrome | null> {
+  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) {
+        // Unref so Chrome's process + stderr pipe don't keep the Node.js event loop alive
+        // after all test work is done. Chrome is still killed via process.on('exit').
+        proc.unref();
+        proc.stderr.unref();
+        resolve({ proc, cdpEndpoint: match[1] });
+      }
+    });
+
+    // Resolve null on any startup failure so launchBrowser falls back to chromium.launch().
+    // The close handler resolves unconditionally: if Chrome exits before printing its CDP URL
+    // (code=0 for a clean exit, code=null for a signal-killed process such as OOM on CI),
+    // the original condition `code !== null && code !== 0` would leave the promise pending
+    // forever, causing launchBrowser to hang and the event loop to drain silently (exit 0).
+    // If Chrome already printed its URL and the promise is resolved, this is a no-op.
+    proc.on('error', () => resolve(null));
+    proc.on('close', () => resolve(null));
+  });
+}

package/lib/utils/{read-boilerplate.js → read-boilerplate.ts}

@@ -8,7 +8,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * Reads a boilerplate file by relative path, using the SEA asset store when running as a Node.js binary.
  * @returns {Promise<string>}
  */
-export default async function readBoilerplate(relativePath) {
+export default async function readBoilerplate(relativePath: string): Promise<string> {
   const sea = await import('node:sea').catch(() => null);
   if (sea?.isSea()) return sea.getAsset(relativePath, 'utf8');
   return (await fs.readFile(join(__dirname, '../../templates', relativePath))).toString();

package/lib/utils/{resolve-port-number-for.js → resolve-port-number-for.ts}

@@ -2,7 +2,7 @@
  * Returns `portNumber` if it is free, otherwise recursively tries `portNumber + 1` until a free port is found.
  * @returns {Promise<number>}
  */
-export default async function resolvePortNumberFor(portNumber) {
+export default async function resolvePortNumberFor(portNumber: number): Promise<number> {
   if (await portIsAvailable(portNumber)) {
     return portNumber;
   }
@@ -10,7 +10,7 @@ export default async function resolvePortNumberFor(portNumber) {
   return await resolvePortNumberFor(portNumber + 1);
 }
 
-async function portIsAvailable(portNumber) {
+async function portIsAvailable(portNumber: number): Promise<boolean> {
   const net = await import('net');
   return new Promise((resolve) => {
     const server = net.createServer();

package/lib/utils/{run-user-module.js → run-user-module.ts}

@@ -1,10 +1,14 @@
-import { red } from './color.js';
+import { red } from './color.ts';
 
 /**
  * Dynamically imports `modulePath` and calls its default export with `params`; exits with code 1 on error.
  * @returns {Promise<void>}
  */
-export default async function runUserModule(modulePath, params, scriptPosition) {
+export default async function runUserModule(
+  modulePath: string,
+  params: unknown,
+  scriptPosition: string,
+): Promise<void> {
   try {
     const func = await import(modulePath);
     if (func) {

package/lib/utils/{search-in-parent-directories.js → search-in-parent-directories.ts}

@@ -1,10 +1,13 @@
-import pathExists from './path-exists.js';
+import pathExists from './path-exists.ts';
 
 /**
  * Recursively searches `directory` and its ancestors for a file or folder named `targetEntry`; returns the absolute path or `undefined`.
  * @returns {Promise<string|undefined>}
  */
-async function searchInParentDirectories(directory, targetEntry) {
+async function searchInParentDirectories(
+  directory: string,
+  targetEntry: string,
+): Promise<string | undefined> {
   const resolvedDirectory = directory === '.' ? process.cwd() : directory;
 
   if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {

package/lib/utils/{time-counter.js → time-counter.ts}

@@ -2,14 +2,14 @@
  * Returns a timer object with a `startTime` Date and a `stop()` method that returns elapsed milliseconds.
  * @example
  * ```js
- * import timeCounter from './lib/utils/time-counter.js';
+ * import timeCounter from './lib/utils/time-counter.ts';
  * const t = timeCounter();
  * const ms = t.stop();
  * console.assert(ms >= 0);
  * ```
  * @returns {{ startTime: Date, stop: () => number }}
  */
-export default function timeCounter() {
+export default function timeCounter(): { startTime: Date; stop: () => number } {
   const startTime = new Date();
 
   return {