@remix-run/test 0.2.0 → 0.3.0

package/src/cli.ts

@@ -1,16 +1,16 @@
 import * as fsp from 'node:fs/promises'
 import type * as http from 'node:http'
 import * as path from 'node:path'
+import type * as browserTestRunner from './lib/runner-browser.ts'
 import {
   getRemixTestHelpText,
   IS_RUNNING_FROM_SRC,
   loadConfig,
   type ResolvedRemixTestConfig,
 } from './lib/config.ts'
+import type * as playwrightSupport from './lib/playwright.ts'
 import { generateCombinedCoverageReport } from './lib/coverage.ts'
-import { loadPlaywrightConfig, resolveProjects } from './lib/playwright.ts'
 import { createReporter } from './lib/reporters/index.ts'
-import { runBrowserTests } from './lib/runner-browser.ts'
 import { runServerTests } from './lib/runner.ts'
 import { createWatcher } from './lib/watcher.ts'
 import { importModule } from './lib/import-module.ts'
@@ -20,11 +20,16 @@ import { isMainThread } from 'node:worker_threads'
 
 export { getRemixTestHelpText }
 
+const MISSING_PLAYWRIGHT_MESSAGE =
+  'Playwright is required to run browser and E2E tests. Install it with `npm i -D playwright`.'
+
 export interface RunRemixTestOptions {
   argv?: string[]
   cwd?: string
 }
 
+type RunBrowserTests = typeof browserTestRunner.runBrowserTests
+
 interface DiscoveredTests {
   files: string[]
   serverFiles: string[]
@@ -157,11 +162,6 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
         browserPort = result.port
       }
 
-      let playwrightConfig =
-        config.playwrightConfig == null || typeof config.playwrightConfig === 'string'
-          ? await loadPlaywrightConfig(config.playwrightConfig, cwd)
-          : config.playwrightConfig
-
       let reporter = createReporter(config.reporter)
       let startTime = performance.now()
 
@@ -183,6 +183,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
           {
             coverage: config.coverage,
             cwd,
+            pool: config.pool,
           },
         )
         counts.failed += serverResult.failed
@@ -194,18 +195,26 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
 
       // Run browser/e2e tests for all browsers configured by the user
       if (browserFiles.length > 0 || e2eFiles.length > 0) {
+        let { loadPlaywrightConfig, resolveProjects } = await importPlaywrightSupport()
+        let runBrowserTests =
+          browserFiles.length > 0 ? (await importBrowserTestRunner()).runBrowserTests : undefined
+        let playwrightConfig =
+          config.playwrightConfig == null || typeof config.playwrightConfig === 'string'
+            ? await loadPlaywrightConfig(config.playwrightConfig, cwd)
+            : config.playwrightConfig
         let projects = resolveProjects(playwrightConfig)
+
         if (config.project) {
-          let projectNames = config.project.split(',').map((project) => project.trim())
-          projects = projects.filter(
-            (project) => project.name && projectNames.includes(project.name),
-          )
+          let projectNames = new Set(config.project)
+          projects = projects.filter((project) => project.name && projectNames.has(project.name))
           if (projects.length === 0) {
-            throw new Error(`No playwright projects found with name(s) "${config.project}"`)
+            throw new Error(
+              `No playwright projects found with name(s) "${config.project.join(', ')}"`,
+            )
           }
         }
 
-        let lastBrowserResult: Awaited<ReturnType<typeof runBrowserTests>> | null = null
+        let lastBrowserResult: Awaited<ReturnType<RunBrowserTests>> | null = null
 
         for (let project of projects) {
           reporter.onSectionStart(`\nRunning tests for project \`${project.name}\`:`)
@@ -222,7 +231,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
           }
 
           let [browserResult, e2eResult] = await Promise.all([
-            browserFiles.length > 0
+            runBrowserTests != null
               ? runBrowserTests({
                   baseUrl: `http://localhost:${browserPort}`,
                   console: config.browser?.echo,
@@ -241,6 +250,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
                   projectName: project.name,
                   coverage: config.coverage,
                   cwd,
+                  pool: config.pool,
                 })
               : null,
           ])
@@ -312,6 +322,42 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
   return await runPromise
 }
 
+async function importPlaywrightSupport(): Promise<typeof playwrightSupport> {
+  try {
+    return await import('./lib/playwright.ts')
+  } catch (error) {
+    throw toPlaywrightImportError(error)
+  }
+}
+
+async function importBrowserTestRunner(): Promise<typeof browserTestRunner> {
+  try {
+    return await import('./lib/runner-browser.ts')
+  } catch (error) {
+    throw toPlaywrightImportError(error)
+  }
+}
+
+function toPlaywrightImportError(error: unknown): unknown {
+  return isMissingPlaywrightImport(error) ? new Error(MISSING_PLAYWRIGHT_MESSAGE) : error
+}
+
+function isMissingPlaywrightImport(error: unknown): boolean {
+  if (!isRecord(error) || typeof error.message !== 'string') {
+    return false
+  }
+
+  return (
+    (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'MODULE_NOT_FOUND') &&
+    (error.message.includes("Cannot find package 'playwright'") ||
+      error.message.includes("Cannot find module 'playwright'"))
+  )
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
 async function resolveCwd(cwd: string): Promise<string> {
   try {
     return await fsp.realpath(cwd)
@@ -327,13 +373,13 @@ async function discoverTests(
   let files = await findFiles(config.glob.test, config.glob.exclude, cwd)
 
   if (files.length === 0) {
-    console.log(`No test files found matching pattern: ${config.glob.test}`)
+    console.log(`No test files found matching pattern: ${config.glob.test.join(', ')}`)
     return null
   }
 
   let browserSet = new Set(await findFiles(config.glob.browser, config.glob.exclude, cwd))
   let e2eSet = new Set(await findFiles(config.glob.e2e, config.glob.exclude, cwd))
-  let types = new Set(config.type.split(','))
+  let types = new Set(config.type)
   let browserFiles = types.has('browser') ? files.filter((f) => browserSet.has(f)) : []
   let e2eFiles = types.has('e2e') ? files.filter((file) => e2eSet.has(file)) : []
   let serverFiles = types.has('server')
@@ -342,7 +388,7 @@ async function discoverTests(
   let totalFiles = browserFiles.length + serverFiles.length + e2eFiles.length
 
   if (totalFiles === 0) {
-    console.log(`No test files remain after filtering for type ${config.type}`)
+    console.log(`No test files remain after filtering for type ${config.type.join(', ')}`)
     return null
   }
 
@@ -358,8 +404,12 @@ async function discoverTests(
   }
 }
 
-async function findFiles(pattern: string, excludePattern: string, cwd: string): Promise<string[]> {
-  let files: string[] = []
+async function findFiles(
+  patterns: string[],
+  excludePatterns: string[],
+  cwd: string,
+): Promise<string[]> {
+  let files = new Set<string>()
 
   if (IS_BUN) {
     // Bun's `fs.promises.glob` follows symlinks and doesn't prune traversal
@@ -367,18 +417,31 @@ async function findFiles(pattern: string, excludePattern: string, cwd: string):
     // Use Bun's native Glob, which defaults to `followSymlinks: false`.
     // @ts-expect-error — bun module is only resolvable under the Bun runtime
     let { Glob } = await import('bun')
-    let glob = new Glob(pattern)
-    let excludeGlob = new Glob(excludePattern)
-    for await (let file of glob.scan({ cwd, absolute: true })) {
-      if (!excludeGlob.match(path.relative(cwd, file))) {
-        files.push(file)
+    let excludeGlobs = excludePatterns.map((p) => new Glob(p))
+    for (let pattern of patterns) {
+      let glob = new Glob(pattern)
+      for await (let file of glob.scan({ cwd, absolute: true })) {
+        let rel = toPosix(path.relative(cwd, file))
+        if (!excludeGlobs.some((eg: { match: (s: string) => boolean }) => eg.match(rel))) {
+          files.add(toPosix(file))
+        }
       }
     }
-    return files
+    return [...files]
   }
 
-  for await (let file of fsp.glob(pattern, { cwd, exclude: [excludePattern] })) {
-    files.push(path.resolve(cwd, file))
+  for (let pattern of patterns) {
+    for await (let file of fsp.glob(pattern, { cwd, exclude: excludePatterns })) {
+      files.add(toPosix(path.resolve(cwd, file)))
+    }
   }
-  return files
+  return [...files]
+}
+
+// Normalize discovered paths so set membership across the test/browser/e2e
+// `findFiles` calls is byte-stable on every platform. Node accepts forward
+// slashes for filesystem operations on Windows, so downstream `fs.readFile`
+// etc. work without further conversion.
+function toPosix(p: string): string {
+  return path.sep === '/' ? p : p.replace(/\\/g, '/')
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export type { RemixTestConfig } from './lib/config.ts'
+export type { RemixTestConfig, RemixTestPool } from './lib/config.ts'
 export {
   describe,
   it,

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,18 +158,21 @@ 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
+}
+
+export type RemixTestPool = 'forks' | 'threads'
 
 export interface RemixTestConfig {
   /**
@@ -172,17 +185,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 +208,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 +225,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 +264,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
 }
 
@@ -261,10 +287,10 @@ export async function loadConfig(args: string[] = process.argv.slice(2), cwd = p
 
 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 +310,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 +330,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 +354,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 +397,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 +427,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/fake-timers.ts

@@ -2,6 +2,13 @@ import { mock } from './mock.ts'
 
 export interface FakeTimers {
   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.
+   */
+  advanceAsync(ms: number): Promise<void>
   restore(): void
 }
 
@@ -35,20 +42,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/import-module.ts

@@ -1,3 +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'
 
@@ -17,13 +19,21 @@ 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 loaders like
+  // `tsImport` 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)
+  return tsImport(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}`)