qunitx-cli 0.9.2 → 0.9.4

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,7 +24,7 @@ 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'),
   ]);
 
   try {

package/deno.lock

@@ -11,10 +11,10 @@
     "npm:express@^5.2.1": "5.2.1",
     "npm:js-yaml@^4.1.1": "4.1.1",
     "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.4": "1.0.4",
+    "npm:typescript@5": "5.9.3",
     "npm:ws@*": "8.20.0",
     "npm:ws@^8.20.0": "8.20.0"
   },
@@ -603,6 +603,10 @@
         "mime-types"
       ]
     },
+    "typescript@5.9.3": {
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "bin": true
+    },
     "undici-types@7.18.2": {
       "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="
     },
@@ -631,10 +635,10 @@
         "npm:esbuild@~0.27.3",
         "npm:express@^5.2.1",
         "npm:js-yaml@^4.1.1",
-        "npm:picomatch@^4.0.4",
         "npm:playwright-core@^1.58.2",
         "npm:prettier@^3.8.1",
         "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.

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,9 +1,9 @@
 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() {
@@ -23,7 +23,11 @@ export default async function initializeProject() {
   ]);
 }
 
-async function writeTestsHTML(projectRoot, config, 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(
@@ -51,13 +55,17 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
   );
 }
 
-async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
+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,7 +143,11 @@ 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;
@@ -192,7 +202,11 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
   }
 }
 
-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) {
@@ -185,7 +186,7 @@ export default async function run(config) {
   }
 }
 
-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) => {
@@ -228,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 = {
@@ -244,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} ...`),
@@ -263,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)}`)

package/lib/servers/{http.js → http.ts}

@@ -1,10 +1,44 @@
 import http from 'node:http';
 // @deno-types="npm:@types/ws"
 import WebSocket, { WebSocketServer } from 'ws';
-import bindServerToPort from '../setup/bind-server-to-port.js';
+import bindServerToPort from '../setup/bind-server-to-port.ts';
+
+declare module 'node:http' {
+  interface IncomingMessage {
+    send: (data: string) => void;
+    path: string;
+    query: Record<string, string>;
+    params: Record<string, string>;
+  }
+  interface ServerResponse {
+    json: (data: unknown) => void;
+  }
+}
+
+type NodeServerWithWSS = http.Server & { wss: WebSocketServer };
+
+/** Route handler function signature for registered GET/POST/etc. routes. */
+export type RouteHandler = (
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+) => void | Promise<void>;
+/** Middleware function signature — call `next()` to continue the chain. */
+export type Middleware = (
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  next: () => void,
+) => void;
+
+interface Route {
+  path: string;
+  handler: RouteHandler;
+  paramNames: string[];
+  isWildcard: boolean;
+  paramValues?: string[];
+}
 
 /** Map of file extensions to their corresponding MIME type strings. */
-export const MIME_TYPES = {
+export const MIME_TYPES: Record<string, string> = {
   html: 'text/html; charset=UTF-8',
   js: 'application/javascript',
   css: 'text/css',
@@ -17,13 +51,27 @@ export const MIME_TYPES = {
 
 /** Minimal HTTP + WebSocket server used to serve test bundles and push reload events. */
 export default class HTTPServer {
+  /** Registered routes keyed by HTTP method then path. */
+  routes: Record<string, Record<string, Route>>;
+  /** Registered middleware functions, applied in order before each route handler. */
+  middleware: Middleware[];
+  /** Underlying Node.js HTTP server instance. */
+  _server: http.Server;
+  /** WebSocket server attached to the HTTP server for live-reload broadcasts. */
+  wss: WebSocketServer;
+
   /**
    * Creates and starts a plain `http.createServer` instance on the given port.
    * @returns {Promise<object>}
    */
-  static serve(config = { port: 1234 }, handler) {
-    const onListen = config.onListen || ((_server) => {});
-    const onError = config.onError || ((_error) => {});
+  static serve(
+    config: { port: number; onListen?: (s: object) => void; onError?: (e: Error) => void } = {
+      port: 1234,
+    },
+    handler: (req: http.IncomingMessage, res: http.ServerResponse) => void,
+  ): Promise<http.Server> {
+    const onListen = config.onListen || ((_server: object) => {});
+    const onError = config.onError || ((_error: Error) => {});
 
     return new Promise((resolve, reject) => {
       const server = http.createServer((req, res) => {
@@ -38,14 +86,13 @@ export default class HTTPServer {
           onListen(Object.assign({ hostname: '127.0.0.1', server }, config));
           resolve(server);
         });
-
-      server.wss = new WebSocketServer({ server });
-      server.wss.on('error', (error) => {
+      (server as NodeServerWithWSS).wss = new WebSocketServer({ server });
+      (server as NodeServerWithWSS).wss.on('error', (error: Error) => {
         console.log('# [WebSocketServer] Error:');
         console.trace(error);
       });
 
-      bindServerToPort(server, config);
+      bindServerToPort(server as unknown as HTTPServer, config as { port: number });
     });
   }
 
@@ -58,11 +105,11 @@ export default class HTTPServer {
     };
     this.middleware = [];
     this._server = http.createServer((req, res) => {
-      res.send = (data) => {
+      req.send = (data: string) => {
         res.setHeader('Content-Type', 'text/plain');
         res.end(data);
       };
-      res.json = (data) => {
+      res.json = (data: unknown) => {
         res.setHeader('Content-Type', 'application/json');
         res.end(JSON.stringify(data));
       };
@@ -81,13 +128,13 @@ export default class HTTPServer {
    * Promise that resolves once the server is fully closed.
    * @returns {Promise<void>}
    */
-  close() {
+  close(): Promise<void> {
     this._server.closeAllConnections?.();
-    return new Promise((resolve) => this._server.close(resolve));
+    return new Promise((resolve) => this._server.close(resolve as () => void));
   }
 
   /** Registers a GET route handler. */
-  get(path, handler) {
+  get(path: string, handler: RouteHandler): void {
     this.#registerRouteHandler('GET', path, handler);
   }
 
@@ -95,9 +142,9 @@ export default class HTTPServer {
    * Starts listening on the given port (0 = OS-assigned).
    * @returns {Promise<void>}
    */
-  listen(port = 0, callback = () => {}) {
+  listen(port = 0, callback: () => void = () => {}): Promise<void> {
     return new Promise((resolve, reject) => {
-      const onError = (err) => {
+      const onError = (err: Error) => {
         this._server.off('listening', onListening);
         reject(err);
       };
@@ -112,7 +159,7 @@ export default class HTTPServer {
   }
 
   /** Broadcasts a message to all connected WebSocket clients. */
-  publish(data) {
+  publish(data: string): void {
     this.wss.clients.forEach((client) => {
       if (client.readyState === WebSocket.OPEN) {
         client.send(data);
@@ -121,26 +168,26 @@ export default class HTTPServer {
   }
 
   /** Registers a POST route handler. */
-  post(path, handler) {
+  post(path: string, handler: RouteHandler): void {
     this.#registerRouteHandler('POST', path, handler);
   }
 
   /** Registers a DELETE route handler. */
-  delete(path, handler) {
+  delete(path: string, handler: RouteHandler): void {
     this.#registerRouteHandler('DELETE', path, handler);
   }
 
   /** Registers a PUT route handler. */
-  put(path, handler) {
+  put(path: string, handler: RouteHandler): void {
     this.#registerRouteHandler('PUT', path, handler);
   }
 
   /** Adds a middleware function to the chain. */
-  use(middleware) {
+  use(middleware: Middleware): void {
     this.middleware.push(middleware);
   }
 
-  #registerRouteHandler(method, path, handler) {
+  #registerRouteHandler(method: string, path: string, handler: RouteHandler): void {
     if (!this.routes[method]) {
       this.routes[method] = {};
     }
@@ -153,13 +200,13 @@ export default class HTTPServer {
     };
   }
 
-  #handleRequest(req, res) {
+  #handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
     const { method, url } = req;
-    const urlObj = new URL(url, 'http://localhost');
+    const urlObj = new URL(url!, 'http://localhost');
     const pathname = urlObj.pathname;
     req.path = pathname;
     req.query = Object.fromEntries(urlObj.searchParams);
-    const matchingRoute = this.#findRouteHandler(method, pathname);
+    const matchingRoute = this.#findRouteHandler(method!, pathname);
 
     if (matchingRoute) {
       req.params = this.#extractParams(matchingRoute, pathname);
@@ -171,7 +218,11 @@ export default class HTTPServer {
     }
   }
 
-  #runMiddleware(req, res, callback) {
+  #runMiddleware(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    callback: RouteHandler,
+  ): void {
     let index = 0;
     const next = () => {
       if (index >= this.middleware.length) {
@@ -185,7 +236,7 @@ export default class HTTPServer {
     next();
   }
 
-  #findRouteHandler(method, url) {
+  #findRouteHandler(method: string, url: string): Route | null {
     const routes = this.routes[method];
     if (!routes) {
       return null;
@@ -219,7 +270,7 @@ export default class HTTPServer {
     );
   }
 
-  #matchPathSegments(path, url) {
+  #matchPathSegments(path: string, url: string): boolean {
     const pathSegments = path.split('/');
     const urlSegments = url.split('/');
 
@@ -243,26 +294,26 @@ export default class HTTPServer {
     return true;
   }
 
-  #buildRegexPattern(path, _paramNames) {
+  #buildRegexPattern(path: string, _paramNames: string[]): string {
     let regexPattern = path.replace(/:[^/]+/g, '([^/]+)');
     regexPattern = regexPattern.replace(/\//g, '\\/');
 
     return regexPattern;
   }
 
-  #extractParamNames(path) {
+  #extractParamNames(path: string): string[] {
     const paramRegex = /:(\w+)/g;
     const paramMatches = path.match(paramRegex);
 
     return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
   }
 
-  #extractParams(route, _url) {
+  #extractParams(route: Route, _url: string): Record<string, string> {
     const { paramNames, paramValues } = route;
-    const params = {};
+    const params: Record<string, string> = {};
 
     for (let i = 0; i < paramNames.length; i++) {
-      params[paramNames[i]] = paramValues[i];
+      params[paramNames[i]] = paramValues![i];
     }
 
     return params;

package/lib/setup/bind-server-to-port.ts

@@ -0,0 +1,14 @@
+import type HTTPServer from '../servers/http.ts';
+
+/**
+ * Binds an HTTPServer to an OS-assigned port and writes the resolved port back to `config.port`.
+ * @returns {Promise<object>}
+ */
+export default async function bindServerToPort(
+  server: HTTPServer,
+  config: { port: number },
+): Promise<HTTPServer> {
+  await server.listen(0);
+  config.port = (server._server.address() as import('node:net').AddressInfo).port;
+  return server;
+}

package/lib/setup/{browser.js → browser.ts}

@@ -1,15 +1,17 @@
-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';
+import setupWebServer from './web-server.ts';
+import bindServerToPort from './bind-server-to-port.ts';
+import findChrome from '../utils/find-chrome.ts';
+import CHROMIUM_ARGS from '../utils/chromium-args.ts';
+import { earlyBrowserPromise } from '../utils/early-chrome.ts';
+import { perfLog } from '../utils/perf-logger.ts';
+import type { Browser } from 'playwright-core';
+import type { Config, CachedContent, Connections } from '../types.ts';
 
 // 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,
+// early-chrome.ts (statically imported by cli.ts) 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');
@@ -21,7 +23,7 @@ perfLog('browser.js: playwright-core import started');
  * For firefox/webkit: uses playwright's standard launch (requires `npx playwright install [browser]`).
  * @returns {Promise<object>}
  */
-export async function launchBrowser(config) {
+export async function launchBrowser(config: Config): Promise<Browser> {
   const browserName = config.browser || 'chromium';
 
   if (browserName === 'chromium') {
@@ -60,16 +62,10 @@ export async function launchBrowser(config) {
  * @returns {Promise<{server: object, browser: object, page: object}>}
  */
 export default async function setupBrowser(
-  config = {
-    port: 1234,
-    debug: false,
-    watch: false,
-    timeout: 10000,
-    browser: 'chromium',
-  },
-  cachedContent,
-  existingBrowser = null,
-) {
+  config: Config,
+  cachedContent: CachedContent,
+  existingBrowser: Browser | null = null,
+): Promise<Connections> {
   const setupStart = Date.now();
   const [server, resolvedExistingBrowser] = await Promise.all([
     setupWebServer(config, cachedContent),