@remix-run/test 0.3.0 → 0.4.1

package/dist/lib/worker-server.js

@@ -16,11 +16,9 @@ export async function runServerTestFile(value) {
     let workerData;
     try {
         workerData = parseServerTestWorkerData(value);
-        // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader which
-        // replaces tsx's minified transformation with a non-minified esbuild transform
-        // so V8 coverage byte offsets align with readable source lines. This hook runs
-        // before the inherited tsx hook (hooks are LIFO), so it intercepts .ts imports and
-        // short-circuits before tsx transforms them.
+        // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader with
+        // an un-minified esbuild transform so V8 coverage byte offsets align with readable
+        // source lines.
         if (workerData.coverage && !IS_BUN) {
             // Ensure we load the right file whether we're running in the monorepo (TS) or
             // from a published package (JS)
@@ -35,14 +33,15 @@ export async function runServerTestFile(value) {
         await takeCoverage(workerData.coverage);
         return results;
     }
-    catch (e) {
+    catch (error) {
+        let failure = error;
         try {
             await takeCoverage(workerData?.coverage);
         }
         catch (coverageError) {
-            e = coverageError;
+            failure = coverageError;
         }
-        return createFailedResults(e);
+        return createFailedResults(failure);
     }
 }
 function parseServerTestWorkerData(value) {

package/dist/test/framework.test.browser.js

@@ -56,8 +56,8 @@ describe('Counter', () => {
 });
 describe('FieldLabel (using decamelize)', () => {
     // Demonstrates that ESM third-party libraries are importable from test modules
-    function FieldLabel(_handle) {
-        return (props) => (_jsx("span", { "data-testid": "label", children: decamelize(props.name, { separator: ' ' }) }));
+    function FieldLabel(handle) {
+        return () => (_jsx("span", { "data-testid": "label", children: decamelize(handle.props.name, { separator: ' ' }) }));
     }
     it('renders a single word unchanged', (t) => {
         let { $, cleanup } = render(_jsx(FieldLabel, { name: "name" }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/test",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A test framework for JavaScript and TypeScript projects",
   "author": "Shopify Inc.",
   "license": "MIT",
@@ -45,9 +45,9 @@
     "istanbul-reports": "^3.2.0",
     "magic-string": "^0.30.21",
     "source-map-js": "^1.2.1",
-    "tsx": "^4.21.0",
     "v8-to-istanbul": "^9.3.0",
-    "@remix-run/terminal": "^0.1.0"
+    "@remix-run/node-tsx": "^0.1.1",
+    "@remix-run/terminal": "^0.1.1"
   },
   "peerDependencies": {
     "playwright": "^1.59.0"
@@ -66,9 +66,9 @@
     "@typescript/native-preview": "7.0.0-dev.20251125.1",
     "decamelize": "^6.0.1",
     "playwright": "^1.59.0",
-    "@remix-run/node-fetch-server": "^0.13.1",
-    "@remix-run/assert": "^0.2.0",
-    "@remix-run/ui": "^0.1.1"
+    "@remix-run/assert": "^0.2.1",
+    "@remix-run/ui": "^0.2.0",
+    "@remix-run/node-fetch-server": "^0.13.3"
   },
   "keywords": [
     "testing",

package/src/app/server.ts

@@ -9,6 +9,9 @@ import { SourceMapConsumer, SourceMapGenerator } from 'source-map-js'
 import { getBrowserTestRootDir, IS_RUNNING_FROM_SRC } from '../lib/config.ts'
 import { transformTypeScript } from '../lib/ts-transform.ts'
 
+const log = (str: string) => console.log(`[remix:test] ${str}`)
+const logError = (str: string, e: unknown) => console.error(`[remix:test] Error: ${str}\n`, e)
+
 export async function startServer(
   browserFiles: string[],
 ): Promise<{ server: http.Server; port: number }> {
@@ -20,7 +23,7 @@ export async function startServer(
     try {
       let server = http.createServer((req, res) => {
         handle(req, res).catch((error) => {
-          console.error(`[remix-test] Unhandled error for ${req.url}:`, error)
+          logError(`Unhandled error for ${req.url}`, error)
           if (!res.headersSent) {
             res.writeHead(500, { 'Content-Type': 'text/plain' })
           }
@@ -31,7 +34,7 @@ export async function startServer(
         server.once('error', reject)
         server.listen(port, () => {
           server.removeListener('error', reject)
-          console.log(`Test server running on http://localhost:${port}`)
+          log(`Test server running on http://localhost:${port}`)
           resolve()
         })
       })
@@ -39,7 +42,7 @@ export async function startServer(
     } catch (error: any) {
       if (error.code !== 'EADDRINUSE') throw error
       lastError = error
-      console.log(`Port ${port} is in use, trying another port...`)
+      log(`Port ${port} is in use, trying another port...`)
       port += 1
     }
   }
@@ -99,7 +102,7 @@ function createRequestHandler(
           await serveScript(res, filePath, url.pathname, rootDir)
           return
         } catch (error) {
-          console.error(`[remix-test] Error serving ${url.pathname}:`, error)
+          logError(`Error serving ${url.pathname}`, error)
           sendText(res, 500, String(error))
           return
         }
@@ -151,9 +154,8 @@ async function serveScript(
       let result = await transformTypeScript(source, filePath)
       code = result.code
     } catch (error) {
-      let msg = error instanceof Error ? error.message : String(error)
-      console.error(`[remix-test] Failed to transform ${urlPath}: ${msg}`)
-      sendText(res, 500, msg)
+      logError(`Failed to transform ${urlPath}`, error)
+      sendText(res, 500, `Failed to transform ${urlPath}`)
       return
     }
   } else {
@@ -163,9 +165,8 @@ async function serveScript(
   try {
     code = await rewriteImports(code, filePath, rootDir)
   } catch (error) {
-    let msg = error instanceof Error ? error.message : String(error)
-    console.error(`[remix-test] Failed to rewrite imports for ${urlPath}: ${msg}`)
-    sendText(res, 500, msg)
+    logError(`Failed to rewrite imports for ${urlPath}`, error)
+    sendText(res, 500, `Failed to rewrite imports for ${urlPath}`)
     return
   }
 

package/src/cli.ts

@@ -23,8 +23,19 @@ export { getRemixTestHelpText }
 const MISSING_PLAYWRIGHT_MESSAGE =
   'Playwright is required to run browser and E2E tests. Install it with `npm i -D playwright`.'
 
+/**
+ * Options accepted by {@link runRemixTest}.
+ */
 export interface RunRemixTestOptions {
+  /**
+   * Argument vector to parse. When omitted, `process.argv.slice(2)` is used
+   * so the regular CLI flags work transparently.
+   */
   argv?: string[]
+  /**
+   * Working directory the runner resolves config and test files against
+   * (default `process.cwd()`).
+   */
   cwd?: string
 }
 
@@ -37,6 +48,25 @@ interface DiscoveredTests {
   e2eFiles: string[]
 }
 
+/**
+ * Programmatic entry point for the `remix-test` CLI. Loads the user's
+ * {@link RemixTestConfig}, discovers test files, and runs them through the
+ * server/browser/E2E pipelines configured by the project. In watch mode the
+ * promise resolves when the user terminates the runner; otherwise it resolves
+ * once the run finishes.
+ *
+ * @param options Optional overrides for the parsed argv and working directory.
+ * @returns The exit code the host process should use (`0` on success, `1` on
+ *          test failure or unrecoverable error).
+ *
+ * @example
+ * ```ts
+ * import { runRemixTest } from '@remix-run/test/cli'
+ *
+ * let exitCode = await runRemixTest()
+ * process.exit(exitCode)
+ * ```
+ */
 export async function runRemixTest(options: RunRemixTestOptions = {}): Promise<number> {
   let argv = options.argv ?? process.argv.slice(2)
   let cwd = await resolveCwd(options.cwd ?? process.cwd())

package/src/lib/config.ts

@@ -172,8 +172,19 @@ const defaultValues: ResolvedRemixTestConfig = {
   watch: false,
 }
 
+/**
+ * Worker pool used by `remix-test` to run server and E2E test files.
+ * `'forks'` (default) uses child processes for stronger isolation; `'threads'`
+ * uses worker threads for projects that prefer lower-overhead startup.
+ */
 export type RemixTestPool = 'forks' | 'threads'
 
+/**
+ * User-facing configuration for the `remix-test` CLI. Every field is
+ * optional — unset fields fall back to runner defaults. The same shape can
+ * be exported from a config file (see `--config`) or passed inline to
+ * {@link runRemixTest} via the corresponding flags.
+ */
 export interface RemixTestConfig {
   /**
    * Options for controlling the playwright browser
@@ -285,6 +296,15 @@ export async function loadConfig(args: string[] = process.argv.slice(2), cwd = p
   return config
 }
 
+/**
+ * Returns the formatted `remix-test --help` text. Useful for embedding the
+ * runner's CLI options in higher-level tooling.
+ *
+ * @param _target Output stream the help text will be written to. Reserved
+ *                for future use (e.g. width-aware formatting); currently
+ *                unused.
+ * @returns The help text as a single string ready to write to a stream.
+ */
 export function getRemixTestHelpText(_target: NodeJS.WriteStream = process.stdout): string {
   let lines = [
     'Usage: remix-test [glob...] [options]',

package/src/lib/context.ts

@@ -15,7 +15,7 @@ export interface TestServer {
 }
 
 /**
- * Test Context providing utilities for testing via remix-test.  The context is
+ * Test Context providing utilities for testing via `remix-test`.  The context is
  * passed as the first argument to the {@link test}/{@link it} functions.
  *
  * @example
@@ -36,8 +36,8 @@ export interface TestContext {
   after(fn: () => void): void
 
   /**
-   * Mock tracker for the current test. Mirrors the shape of Node's
-   * `t.mock`. Method mocks created here are auto-restored on test completion.
+   * Mock tracker for the current test using {@link mock}. Mirrors the shape of Node's
+   * `t.mock`. Method mocks created via `t.mock` are auto-restored on test completion.
    */
   mock: {
     /**
@@ -77,8 +77,8 @@ export interface TestContext {
   /**
    * Wires a running test server up to a Playwright page so the test can drive
    * it. The server is closed automatically when the test ends. Pair with
-   * `createTestServer` from `@remix-run/node-fetch-server/test` (or any other
-   * source of a `{ baseUrl, close }` handle) to spin up the server first.
+   * {@link createTestServer} from `@remix-run/node-fetch-server/test` to spin
+   * up the server.
    *
    * @param server - The running server the page should target
    * @returns A `Page` whose `baseURL` is set to `server.baseUrl`.

package/src/lib/coverage-loader.ts

@@ -4,8 +4,8 @@ import { transformTypeScript } from './ts-transform.ts'
 
 // Custom ESM loader hook for TypeScript files.
 //
-// Replaces tsx's minified transformation with an un-minified esbuild transform
-// that preserves line structure. This ensures V8 coverage byte offsets map
+// Applies an un-minified esbuild transform that preserves line structure.
+// This ensures V8 coverage byte offsets map
 // cleanly to TypeScript source lines via the inline source map, giving
 // accurate per-line coverage rather than collapsing multiple statements onto
 // a single minified line.

package/src/lib/coverage.ts

@@ -236,7 +236,7 @@ export async function collectServerCoverageMap(
         let { code } = await transformTypeScript(tsSource, filePath)
         let success = await addV8EntryToCoverageMap(coverageMap, filePath, entry.functions, code)
         if (success) converted++
-      } catch (e) {
+      } catch {
         // Skip files that can't be converted
       }
     }

package/src/lib/fake-timers.ts

@@ -1,14 +1,46 @@
 import { mock } from './mock.ts'
 
+/**
+ * Handle returned by `mock.timers.enable()` for driving fake timers during a
+ * test. While enabled, `setTimeout`, `setInterval`, `clearTimeout`,
+ * `clearInterval`, and `Date.now` use the fake clock instead of the real one;
+ * timers fire only when the test calls `advance` (or `advanceAsync`).
+ *
+ * @example
+ * ```ts
+ * it('debounces save calls', (t) => {
+ *   let timers = t.mock.timers.enable()
+ *   let save = t.mock.fn()
+ *   let debounced = debounce(save, 100)
+ *   debounced(); debounced(); debounced()
+ *   timers.advance(100)
+ *   assert.equal(save.mock.calls.length, 1)
+ * })
+ * ```
+ */
 export interface FakeTimers {
+  /**
+   * Advance the fake clock by `ms` milliseconds, synchronously firing every
+   * timer whose deadline is reached during the advance.
+   *
+   * @param ms Number of milliseconds to advance.
+   */
   advance(ms: number): void
   /**
    * Like `advance`, but yields to microtasks between each timer firing so
    * Promise continuations (and any timers they schedule) can settle before
    * the next firing is processed. Use this when a callback awaits work that
    * itself depends on the fake clock.
+   *
+   * @param ms Number of milliseconds to advance.
+   * @returns A promise that resolves once all reachable timers have fired.
    */
   advanceAsync(ms: number): Promise<void>
+  /**
+   * Restore the original timer functions and the real clock. Called
+   * automatically after the test finishes; may also be called early to
+   * disable fake timers mid-test.
+   */
   restore(): void
 }
 

package/src/lib/framework.ts

@@ -57,6 +57,13 @@ function registerDescribe(
   }
   let suite: TestSuite = { name: fullName, tests: [], ...flags }
 
+  // Children inherit `skip`/`only` from their parent so that
+  // `describe.skip('parent', () => describe('child', () => it(...)))` actually
+  // skips the child's tests. The executor walks `rootSuites` as a flat list and
+  // only inspects each suite's own flag, so the propagation has to happen here.
+  if (currentSuite?.skip) suite.skip = true
+  if (currentSuite?.only) suite.only = true
+
   // Inherit lifecycle hooks from parent suite (or root hooks if at top level)
   let parent = currentSuite ?? rootHooks
   if (parent.beforeEach) suite.beforeEach = parent.beforeEach
@@ -80,9 +87,20 @@ function registerDescribe(
   }
 }
 
+// We implement this standalone so we can leverage multiple signatures through
+// typedoc, but we need to do the `const describe = Object.assign()` thing below to
+// get the modifiers onto the method in a typescript-aware way.
+function describeImpl(name: string, fn: () => void): void
+function describeImpl(name: string, meta: SuiteMeta, fn: () => void): void
+function describeImpl(name: string, metaOrFn: SuiteMeta | (() => void), fn?: () => void): void {
+  let meta = typeof metaOrFn === 'function' ? {} : metaOrFn
+  let suiteFn = typeof metaOrFn === 'function' ? metaOrFn : fn!
+  registerDescribe(name, suiteFn, meta)
+}
+
 /**
- * Groups related tests into a named suite. Suites can be nested snd will be displayed
- * as such or joined with ` > ` in reporter output. Lifecycle hooks registered inside
+ * Groups related tests into a named suite. Suites can be nested and will be displayed
+ * as such in reporter output. Lifecycle hooks registered inside
  * a `describe` block apply only to tests within that block.
  *
  * @example
@@ -96,26 +114,20 @@ function registerDescribe(
  * describe.todo('planned suite')
  *
  * @param name - The suite name shown in reporter output.
+ * @param meta - Suite metadata such as `skip` or `only`.
  * @param fn - A function that registers the tests and lifecycle hooks in this suite.
  */
-export const describe = Object.assign(
-  (name: string, metaOrFn: SuiteMeta | (() => void), fn?: () => void) => {
-    let meta = typeof metaOrFn === 'function' ? {} : metaOrFn
-    let suiteFn = typeof metaOrFn === 'function' ? metaOrFn : fn!
-    registerDescribe(name, suiteFn, meta)
-  },
-  {
-    skip: (name: string, fn: () => void) => registerDescribe(name, fn, { skip: true }),
-    only: (name: string, fn: () => void) => registerDescribe(name, fn, { only: true }),
-    todo: (name: string) => {
-      let fullName = currentSuite ? `${currentSuite.name} > ${name}` : name
-      if (rootSuites.some((s) => s.name === fullName)) {
-        throw new Error(`Duplicate suite name: "${fullName}"`)
-      }
-      rootSuites.push({ name: fullName, tests: [], todo: true })
-    },
+export const describe = Object.assign(describeImpl, {
+  skip: (name: string, fn: () => void) => registerDescribe(name, fn, { skip: true }),
+  only: (name: string, fn: () => void) => registerDescribe(name, fn, { only: true }),
+  todo: (name: string) => {
+    let fullName = currentSuite ? `${currentSuite.name} > ${name}` : name
+    if (rootSuites.some((s) => s.name === fullName)) {
+      throw new Error(`Duplicate suite name: "${fullName}"`)
+    }
+    rootSuites.push({ name: fullName, tests: [], todo: true })
   },
-)
+})
 
 type SuiteMeta = { skip?: boolean; only?: boolean }
 type TestMeta = { skip?: boolean; only?: boolean }
@@ -129,6 +141,17 @@ function registerIt(name: string, fn: TestFn, flags?: { only?: boolean; skip?: b
   suite.tests.push({ name, fn, suite, ...flags })
 }
 
+// We implement this standalone so we can leverage multiple signatures through
+// typedoc, but we need to do the `const it = Object.assign()` thing below to
+// get the modifiers onto the method in a typescript-aware way.
+function itImpl(name: string, fn: TestFn): void
+function itImpl(name: string, meta: TestMeta, fn: TestFn): void
+function itImpl(name: string, metaOrFn: TestMeta | TestFn, fn?: TestFn): void {
+  let meta = typeof metaOrFn === 'function' ? {} : metaOrFn
+  let testFn = typeof metaOrFn === 'function' ? metaOrFn : fn!
+  registerIt(name, testFn, meta)
+}
+
 /**
  * Defines a single test case. The optional `TestContext` argument `t` provides
  * mock helpers and per-test cleanup registration.
@@ -145,26 +168,20 @@ function registerIt(name: string, fn: TestFn, flags?: { only?: boolean; skip?: b
  * it.todo('coming soon')
  *
  * @param name - The test name shown in reporter output.
+ * @param meta - Test metadata such as `skip` or `only`.
  * @param fn - The test body, receiving a {@link TestContext} as its first argument.
  */
-export const it = Object.assign(
-  (name: string, metaOrFn: TestMeta | TestFn, fn?: TestFn) => {
-    let meta = typeof metaOrFn === 'function' ? {} : metaOrFn
-    let testFn = typeof metaOrFn === 'function' ? metaOrFn : fn!
-    registerIt(name, testFn, meta)
-  },
-  {
-    skip: (name: string, fn?: TestFn) => registerIt(name, fn ?? (() => {}), { skip: true }),
-    only: (name: string, fn: TestFn) => registerIt(name, fn, { only: true }),
-    todo: (name: string) => {
-      let suite = currentSuite ?? getImplicitRootSuite()
-      if (suite.tests.some((t) => t.name === name)) {
-        throw new Error(`Duplicate test name: "${name}" in suite "${suite.name || 'Global'}"`)
-      }
-      suite.tests.push({ name, fn: () => {}, suite, todo: true })
-    },
+export const it = Object.assign(itImpl, {
+  skip: (name: string, fn?: TestFn) => registerIt(name, fn ?? (() => {}), { skip: true }),
+  only: (name: string, fn: TestFn) => registerIt(name, fn, { only: true }),
+  todo: (name: string) => {
+    let suite = currentSuite ?? getImplicitRootSuite()
+    if (suite.tests.some((t) => t.name === name)) {
+      throw new Error(`Duplicate test name: "${name}" in suite "${suite.name || 'Global'}"`)
+    }
+    suite.tests.push({ name, fn: () => {}, suite, todo: true })
   },
-)
+})
 
 /** Alias for {@link describe}. */
 export const suite = describe

package/src/lib/import-module.ts

@@ -1,6 +1,5 @@
 import * as path from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { tsImport } from 'tsx/esm/api'
 import { IS_BUN } from './runtime.ts'
 
 interface ImportMetaWithResolve extends ImportMeta {
@@ -21,8 +20,8 @@ function hasImportMetaResolve(meta: ImportMeta): meta is ImportMetaWithResolve {
 export async function importModule(specifier: string, meta: ImportMeta): Promise<any> {
   // Absolute Windows paths (`C:\foo\bar.ts`) aren't valid ESM specifiers — only
   // `file:///C:/foo/bar.ts` URLs, relative specifiers, or POSIX absolute paths
-  // are. Convert any absolute filesystem path to its `file:` URL so loaders like
-  // `tsImport` and `import()` accept it on every platform. POSIX absolute paths
+  // are. Convert any absolute filesystem path to its `file:` URL so module
+  // loaders and `import()` accept it on every platform. POSIX absolute paths
   // happen to work as specifiers without conversion, but going through
   // `pathToFileURL` is safe and platform-agnostic.
   let resolvedSpecifier = path.isAbsolute(specifier) ? pathToFileURL(specifier).href : specifier
@@ -35,5 +34,7 @@ export async function importModule(specifier: string, meta: ImportMeta): Promise
     return import(meta.resolve(resolvedSpecifier, meta.url))
   }
 
-  return tsImport(resolvedSpecifier, meta.url)
+  // node-tsx uses Node APIs that fail in Bun if statically imported
+  let { loadModule } = await import('@remix-run/node-tsx/load-module')
+  return loadModule(resolvedSpecifier, meta.url)
 }

package/src/lib/reporters/results.ts

@@ -1,4 +1,4 @@
-import type { V8CoverageEntry } from '../coverage'
+import type { V8CoverageEntry } from '../coverage.ts'
 
 export interface TestResult {
   name: string

package/src/lib/runner-browser.ts

@@ -16,6 +16,8 @@ import {
 import type { Reporter } from './reporters/index.ts'
 import type { TestResults } from './reporters/results.ts'
 
+const BROWSER_TEST_FILE_TIMEOUT_MS = 90_000
+
 // The harness reports each test result with `filePath` set to the
 // `/scripts/<rel>` URL the iframe loaded. Reporters expect a real filesystem
 // path so they can compute `path.relative(cwd, ...)` cleanly; otherwise they
@@ -61,12 +63,10 @@ export async function runBrowserTests(options: TestRunOptions): Promise<{
       getPlaywrightLaunchOptions(options.playwrightUseOpts),
     )
     page = await browser.newPage(getPlaywrightPageOptions(options.playwrightUseOpts))
-    // Cap how long we'll wait for a browser-test file to signal completion.
-    // Playwright's default is 30s; bumping to 60s buys headroom for slower
-    // suites without letting a hung test hide forever. Plumb this through
-    // config later if anyone needs to tune it.
-    page.setDefaultTimeout(90_000)
-    page.setDefaultNavigationTimeout(90_000)
+    // Cap individual browser operations, then separately watch for per-file
+    // progress so large suites can run longer than this without hiding hangs.
+    page.setDefaultTimeout(BROWSER_TEST_FILE_TIMEOUT_MS)
+    page.setDefaultNavigationTimeout(BROWSER_TEST_FILE_TIMEOUT_MS)
 
     if (options.console) {
       page.on('console', (msg) => console.log(`${colors.dim('[browser console]')} ${msg.text()}`))
@@ -84,6 +84,32 @@ export async function runBrowserTests(options: TestRunOptions): Promise<{
     let totalSkipped = 0
     let totalTodo = 0
     let rootDir = getBrowserTestRootDir()
+    let completedFiles = 0
+    let totalFiles = options.testFiles?.length ?? 0
+    let progressTimeoutId: ReturnType<typeof setTimeout> | undefined
+    let rejectProgressTimeout: (error: Error) => void = () => {}
+    let progressTimeoutPromise = new Promise<never>((_, reject) => {
+      rejectProgressTimeout = reject
+    })
+
+    function clearProgressTimeout() {
+      if (progressTimeoutId !== undefined) {
+        clearTimeout(progressTimeoutId)
+        progressTimeoutId = undefined
+      }
+    }
+
+    function resetProgressTimeout() {
+      clearProgressTimeout()
+      progressTimeoutId = setTimeout(() => {
+        let progress = totalFiles > 0 ? ` (${completedFiles}/${totalFiles} files completed)` : ''
+        rejectProgressTimeout(
+          new Error(
+            `Timed out waiting ${BROWSER_TEST_FILE_TIMEOUT_MS}ms for browser test progress${progress}`,
+          ),
+        )
+      }, BROWSER_TEST_FILE_TIMEOUT_MS)
+    }
 
     await page.route('**/file-results', async (route) => {
       let results = route.request().postDataJSON() as TestResults
@@ -95,6 +121,8 @@ export async function runBrowserTests(options: TestRunOptions): Promise<{
       totalFailed += results.failed
       totalSkipped += results.skipped
       totalTodo += results.todo
+      completedFiles++
+      resetProgressTimeout()
       await route.fulfill({ status: 200 })
     })
 
@@ -117,9 +145,19 @@ export async function runBrowserTests(options: TestRunOptions): Promise<{
 
     // Prevent unhandled rejection if we fail before setting up the listener
     errorPromise.catch(() => {})
+    progressTimeoutPromise.catch(() => {})
 
-    await page.goto(options.baseUrl)
-    await Promise.race([page.waitForFunction('window.__testsDone'), errorPromise])
+    resetProgressTimeout()
+    try {
+      await page.goto(options.baseUrl)
+      await Promise.race([
+        page.waitForFunction('window.__testsDone', undefined, { timeout: 0 }),
+        errorPromise,
+        progressTimeoutPromise,
+      ])
+    } finally {
+      clearProgressTimeout()
+    }
 
     if (coverageEnabled) {
       let entries = (await page.coverage.stopJSCoverage()) as unknown as V8CoverageEntry[]

package/src/lib/ts-transform.ts

@@ -1,4 +1,4 @@
-import { transform, type TsconfigRaw } from 'esbuild'
+import { transform } from 'esbuild'
 import { getTsconfig, type TsConfigResult } from 'get-tsconfig'
 import * as path from 'node:path'
 

package/src/lib/worker-server.ts

@@ -18,11 +18,9 @@ export async function runServerTestFile(value: unknown): Promise<TestResults> {
   try {
     workerData = parseServerTestWorkerData(value)
 
-    // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader which
-    // replaces tsx's minified transformation with a non-minified esbuild transform
-    // so V8 coverage byte offsets align with readable source lines. This hook runs
-    // before the inherited tsx hook (hooks are LIFO), so it intercepts .ts imports and
-    // short-circuits before tsx transforms them.
+    // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader with
+    // an un-minified esbuild transform so V8 coverage byte offsets align with readable
+    // source lines.
     if (workerData.coverage && !IS_BUN) {
       // Ensure we load the right file whether we're running in the monorepo (TS) or
       // from a published package (JS)
@@ -36,14 +34,16 @@ export async function runServerTestFile(value: unknown): Promise<TestResults> {
     let results = await runTests()
     await takeCoverage(workerData.coverage)
     return results
-  } catch (e) {
+  } catch (error) {
+    let failure = error
+
     try {
       await takeCoverage(workerData?.coverage)
     } catch (coverageError) {
-      e = coverageError
+      failure = coverageError
     }
 
-    return createFailedResults(e)
+    return createFailedResults(failure)
   }
 }
 

package/tsconfig.json

@@ -3,14 +3,17 @@
     "strict": true,
     "lib": ["ES2024", "DOM", "DOM.Iterable"],
     "types": ["node", "dom-navigation"],
-    "module": "ES2022",
-    "moduleResolution": "Bundler",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "target": "ESNext",
     "allowImportingTsExtensions": true,
     "rewriteRelativeImportExtensions": true,
     "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "isolatedModules": true,
     "skipLibCheck": true,
     "jsx": "react-jsx",
     "jsxImportSource": "@remix-run/ui"
-  }
+  },
+  "exclude": ["dist"]
 }