@remix-run/test 0.2.0 → 0.4.0

package/src/lib/config.ts

@@ -44,19 +44,23 @@ const cliOptions = {
   },
   'glob.browser': {
     type: 'string',
-    description: 'Glob pattern for browser test files',
+    multiple: true,
+    description: 'Glob pattern(s) for browser test files',
   },
   'glob.e2e': {
     type: 'string',
-    description: 'Glob pattern for E2E test files',
+    multiple: true,
+    description: 'Glob pattern(s) for E2E test files',
   },
   'glob.exclude': {
     type: 'string',
-    description: 'Glob pattern for paths to exclude from discovery',
+    multiple: true,
+    description: 'Glob pattern(s) for paths to exclude from discovery',
   },
   'glob.test': {
     type: 'string',
-    description: 'Glob pattern for all test files',
+    multiple: true,
+    description: 'Glob pattern(s) for all test files',
   },
   concurrency: {
     type: 'string',
@@ -113,7 +117,12 @@ const cliOptions = {
   project: {
     type: 'string',
     short: 'p',
-    description: 'Filter to a specific Playwright project (comma-separated)',
+    multiple: true,
+    description: 'Filter to specific Playwright project(s)',
+  },
+  pool: {
+    type: 'string',
+    description: 'Pool used to run server and E2E test files: forks, threads (default: forks)',
   },
   reporter: {
     type: 'string',
@@ -123,7 +132,8 @@ const cliOptions = {
   type: {
     type: 'string',
     short: 't',
-    description: 'Comma-separated test types to run (default: server,browser,e2e)',
+    multiple: true,
+    description: 'Test types to run (default: server, browser, e2e)',
   },
   watch: {
     type: 'boolean',
@@ -148,19 +158,33 @@ const defaultValues: ResolvedRemixTestConfig = {
     functions: undefined,
   },
   glob: {
-    test: '**/*.test{,.e2e,.browser}.{ts,tsx}',
-    browser: '**/*.test.browser.{ts,tsx}',
-    e2e: '**/*.test.e2e.{ts,tsx}',
-    exclude: 'node_modules/**',
+    test: ['**/*.test{,.e2e,.browser}.{ts,tsx}'],
+    browser: ['**/*.test.browser.{ts,tsx}'],
+    e2e: ['**/*.test.e2e.{ts,tsx}'],
+    exclude: ['node_modules/**'],
   },
-  reporter: process.env.CI === 'true' ? 'files' : 'spec',
-  type: 'server,browser,e2e',
-  setup: undefined,
+  pool: 'forks',
   playwrightConfig: undefined,
   project: undefined,
+  reporter: process.env.CI === 'true' ? 'files' : 'spec',
+  setup: undefined,
+  type: ['server', 'browser', 'e2e'],
   watch: false,
-} as const
+}
 
+/**
+ * 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
@@ -172,17 +196,18 @@ export interface RemixTestConfig {
     open?: boolean
   }
   /**
-   * Glob patterns to identify test files
-   *  - `glob.test`: Glob pattern for all test files (--glob.test)
-   *  - `glob.browser`: Glob pattern for the subset of browser test files (--glob.browser)
-   *  - `glob.e2e`: Glob pattern for the subset of e2e test files (--glob.e2e)
-   *  - `glob.exclude`: Glob pattern for paths to exclude from discovery (--glob.exclude)
+   * Glob patterns to identify test files. Each field accepts a single pattern
+   * or an array of patterns; arrays are unioned during discovery.
+   *  - `glob.test`: Glob pattern(s) for all test files (--glob.test)
+   *  - `glob.browser`: Glob pattern(s) for the subset of browser test files (--glob.browser)
+   *  - `glob.e2e`: Glob pattern(s) for the subset of e2e test files (--glob.e2e)
+   *  - `glob.exclude`: Glob pattern(s) for paths to exclude from discovery (--glob.exclude)
    */
   glob?: {
-    test?: string
-    browser?: string
-    e2e?: string
-    exclude?: string
+    test?: string | string[]
+    browser?: string | string[]
+    e2e?: string | string[]
+    exclude?: string | string[]
   }
   /** Max number of concurrent test workers (--concurrency) */
   concurrency?: number | string
@@ -194,8 +219,8 @@ export interface RemixTestConfig {
     | boolean
     | {
         dir?: string
-        include?: string[]
-        exclude?: string[]
+        include?: string | string[]
+        exclude?: string | string[]
         statements?: number | string
         lines?: number | string
         branches?: number | string
@@ -211,12 +236,23 @@ export interface RemixTestConfig {
    * PlaywrightTestConfig object. CLI `--playwrightConfig` only accepts a file path.
    */
   playwrightConfig?: string | PlaywrightTestConfig
-  /** Filter tests to a specific playwright project or comma-separated list of projects (--project) */
-  project?: string
+  /**
+   * Pool used to run server and E2E test files. Forked child processes are the default,
+   * but worker threads are available for projects that prefer the previous behavior.
+   */
+  pool?: RemixTestPool
+  /**
+   * Filter tests to specific playwright project(s) (--project). Accepts a single
+   * project name or an array of names; `--project` may be repeated on the CLI.
+   */
+  project?: string | string[]
   /** Test reporter (--reporter) */
   reporter?: string
-  /** Comma-separated list of test types to run (--type) */
-  type?: string
+  /**
+   * Test type(s) to run (--type). Accepts a single type or an array of types;
+   * `--type` may be repeated on the CLI. Valid values: "server", "browser", "e2e".
+   */
+  type?: string | string[]
   /** Watch mode — re-run tests on file changes (--watch) */
   watch?: boolean
 }
@@ -239,16 +275,17 @@ export interface ResolvedRemixTestConfig {
       }
     | undefined
   glob: {
-    test: string
-    browser: string
-    e2e: string
-    exclude: string
+    test: string[]
+    browser: string[]
+    e2e: string[]
+    exclude: string[]
   }
   playwrightConfig: string | PlaywrightTestConfig | undefined
-  project: string | undefined
+  project: string[] | undefined
   reporter: string
+  pool: RemixTestPool
   setup: string | undefined
-  type: string
+  type: string[]
   watch: boolean
 }
 
@@ -259,12 +296,21 @@ 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]',
+    'Usage: remix-test [glob...] [options]',
     '',
     'Arguments:',
-    `  glob                     Glob pattern for test files (default: "${defaultValues.glob.test}")`,
+    `  glob                     Glob pattern(s) for test files (default: "${defaultValues.glob.test.join(', ')}")`,
     '',
     'Options:',
   ]
@@ -284,6 +330,19 @@ function parseCliArgs(args: string[]) {
   return util.parseArgs({ args, options: cliOptions, allowPositionals: true })
 }
 
+function toArray<T>(value: T | readonly T[]): T[] {
+  return Array.isArray(value) ? [...value] : [value as T]
+}
+
+function toCommaSeparatedArray(value: string | readonly string[]): string[] {
+  return toArray(value).flatMap((item) =>
+    item
+      .split(',')
+      .map((part) => part.trim())
+      .filter(Boolean),
+  )
+}
+
 function resolveConfig(
   fileConfig: RemixTestConfig,
   { values: cliValues, positionals }: ReturnType<typeof parseCliArgs>,
@@ -291,14 +350,18 @@ function resolveConfig(
   let fileCoverage = typeof fileConfig.coverage === 'boolean' ? {} : fileConfig.coverage || {}
   return {
     glob: {
-      test:
-        positionals[0] ??
-        cliValues['glob.test'] ??
-        fileConfig.glob?.test ??
-        defaultValues.glob.test,
-      browser: cliValues['glob.browser'] ?? fileConfig.glob?.browser ?? defaultValues.glob.browser,
-      e2e: cliValues['glob.e2e'] ?? fileConfig.glob?.e2e ?? defaultValues.glob.e2e,
-      exclude: cliValues['glob.exclude'] ?? fileConfig.glob?.exclude ?? defaultValues.glob.exclude,
+      test: toArray(
+        positionals.length > 0
+          ? positionals
+          : (cliValues['glob.test'] ?? fileConfig.glob?.test ?? defaultValues.glob.test),
+      ),
+      browser: toArray(
+        cliValues['glob.browser'] ?? fileConfig.glob?.browser ?? defaultValues.glob.browser,
+      ),
+      e2e: toArray(cliValues['glob.e2e'] ?? fileConfig.glob?.e2e ?? defaultValues.glob.e2e),
+      exclude: toArray(
+        cliValues['glob.exclude'] ?? fileConfig.glob?.exclude ?? defaultValues.glob.exclude,
+      ),
     },
     browser: {
       echo: cliValues['browser.echo'] ?? fileConfig.browser?.echo ?? defaultValues.browser.echo,
@@ -311,14 +374,20 @@ function resolveConfig(
       cliValues.coverage === true || !!fileConfig.coverage
         ? {
             dir: cliValues['coverage.dir'] ?? fileCoverage.dir ?? defaultValues.coverage!.dir,
-            include:
-              cliValues['coverage.include'] ??
-              fileCoverage.include ??
-              defaultValues.coverage!.include,
-            exclude:
-              cliValues['coverage.exclude'] ??
-              fileCoverage.exclude ??
-              defaultValues.coverage!.exclude,
+            include: (() => {
+              let raw =
+                cliValues['coverage.include'] ??
+                fileCoverage.include ??
+                defaultValues.coverage!.include
+              return raw === undefined ? undefined : toArray(raw)
+            })(),
+            exclude: (() => {
+              let raw =
+                cliValues['coverage.exclude'] ??
+                fileCoverage.exclude ??
+                defaultValues.coverage!.exclude
+              return raw === undefined ? undefined : toArray(raw)
+            })(),
             statements:
               cliValues['coverage.statements'] !== undefined
                 ? Number(cliValues['coverage.statements'])
@@ -348,13 +417,25 @@ function resolveConfig(
     setup: cliValues.setup ?? fileConfig.setup ?? defaultValues.setup,
     playwrightConfig:
       cliValues.playwrightConfig ?? fileConfig.playwrightConfig ?? defaultValues.playwrightConfig,
-    project: cliValues.project ?? fileConfig.project ?? defaultValues.project,
+    pool: resolvePool(cliValues.pool ?? fileConfig.pool ?? defaultValues.pool),
+    project: (() => {
+      let raw = cliValues.project ?? fileConfig.project ?? defaultValues.project
+      return raw === undefined ? undefined : toCommaSeparatedArray(raw)
+    })(),
     reporter: cliValues.reporter ?? fileConfig.reporter ?? defaultValues.reporter,
-    type: cliValues.type ?? fileConfig.type ?? defaultValues.type,
+    type: toCommaSeparatedArray(cliValues.type ?? fileConfig.type ?? defaultValues.type),
     watch: cliValues.watch ?? fileConfig.watch ?? defaultValues.watch,
   }
 }
 
+function resolvePool(value: string): RemixTestPool {
+  if (value === 'forks' || value === 'threads') {
+    return value
+  }
+
+  throw new Error(`Unsupported test pool "${value}". Supported pools are: forks, threads`)
+}
+
 async function loadConfigFile(
   configPath: string | undefined,
   cwd: string,
@@ -366,11 +447,16 @@ async function loadConfigFile(
   for (let candidate of candidates) {
     try {
       await fsp.access(candidate)
-      let mod = await importModule(candidate, import.meta)
-      return mod.default ?? mod
     } catch {
-      // not found or failed to load — try next
+      // not found — try the next candidate
+      continue
     }
+    // The file exists; let import errors propagate rather than silently
+    // falling through to defaults — that masking is what hid "Windows
+    // absolute paths aren't valid ESM specifiers" by classifying every
+    // browser test as a server test.
+    let mod = await importModule(candidate, import.meta)
+    return mod.default ?? mod
   }
 
   return {}

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,7 +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
 }
 
@@ -35,20 +74,38 @@ export function createFakeTimers(): FakeTimers {
     cancel as unknown as typeof clearInterval,
   )
 
+  function takeNext(targetTime: number) {
+    let next = pending.filter((t) => t.time <= targetTime).sort((a, b) => a.time - b.time)[0]
+    if (!next) return null
+    currentTime = next.time
+    pending = pending.filter((t) => t.id !== next.id)
+    // Requeue intervals before running the callback so that calling
+    // clearInterval(id) from inside the callback can cancel the next firing.
+    if (next.repeatMs !== undefined) {
+      pending.push({ ...next, time: next.time + Math.max(1, next.repeatMs) })
+    }
+    return next
+  }
+
   return {
     advance(ms: number) {
       let targetTime = currentTime + ms
       while (true) {
-        let next = pending.filter((t) => t.time <= targetTime).sort((a, b) => a.time - b.time)[0]
+        let next = takeNext(targetTime)
+        if (!next) break
+        next.fn()
+      }
+      currentTime = targetTime
+    },
+    async advanceAsync(ms: number) {
+      let targetTime = currentTime + ms
+      while (true) {
+        let next = takeNext(targetTime)
         if (!next) break
-        currentTime = next.time
-        pending = pending.filter((t) => t.id !== next.id)
-        // Requeue intervals before running the callback so that calling
-        // clearInterval(id) from inside the callback can cancel the next firing.
-        if (next.repeatMs !== undefined) {
-          pending.push({ ...next, time: next.time + Math.max(1, next.repeatMs) })
-        }
         next.fn()
+        // Drain microtasks so Promise continuations (and any timers they
+        // schedule) can settle before we look for the next firing.
+        await Promise.resolve()
       }
       currentTime = targetTime
     },

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,4 +1,5 @@
-import { tsImport } from 'tsx/esm/api'
+import * as path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { IS_BUN } from './runtime.ts'
 
 interface ImportMetaWithResolve extends ImportMeta {
@@ -17,13 +18,23 @@ function hasImportMetaResolve(meta: ImportMeta): meta is ImportMetaWithResolve {
  * @returns The imported module namespace.
  */
 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 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
+
   if (IS_BUN) {
     if (!hasImportMetaResolve(meta)) {
       throw new Error('importModule() requires import.meta.resolve() in Bun')
     }
 
-    return import(meta.resolve(specifier, meta.url))
+    return import(meta.resolve(resolvedSpecifier, meta.url))
   }
 
-  return tsImport(specifier, 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/dot.ts

@@ -6,10 +6,17 @@ import type { Counts, TestResult, TestResults } from './results.ts'
 export class DotReporter implements Reporter {
   #failures: { name: string; error: TestResult['error'] }[] = []
   #dotCount = 0
+  #files = new Set<string>()
+  #suites = new Set<string>()
 
   onSectionStart(_label: string) {}
 
   onResult(results: TestResults, _env?: string) {
+    for (let test of results.tests) {
+      if (test.filePath) this.#files.add(test.filePath)
+      if (test.suiteName) this.#suites.add(test.suiteName)
+    }
+
     for (let test of results.tests) {
       if (test.status === 'passed') {
         process.stdout.write(colors.green('.'))
@@ -47,6 +54,8 @@ export class DotReporter implements Reporter {
     let { passed, failed, skipped, todo } = counts
     let info = colors.cyan('ℹ')
     console.log()
+    console.log(`${info} files ${this.#files.size}`)
+    console.log(`${info} suites ${this.#suites.size}`)
     console.log(`${info} tests ${passed + failed + skipped + todo}`)
     console.log(`${info} pass ${passed}`)
     console.log(`${info} fail ${failed}`)