@remix-run/test 0.4.1 → 0.4.2

package/README.md

@@ -209,8 +209,7 @@ suite('My Test Suite', () => {
 
 ### Programmatic runner
 
-`remix/test/cli` exports `runRemixTest()` for tools that want to run the test runner without
-exiting the current process:
+`remix/test/cli` exports `runRemixTest()` for tools that want to run the test runner without exiting the current process:
 
 ```ts
 import { runRemixTest } from 'remix/test/cli'
@@ -221,9 +220,7 @@ let exitCode = await runRemixTest({
 })
 ```
 
-`runRemixTest()` returns the runner exit code. The `remix test` bin wrapper calls
-`process.exit()` with that code when the run finishes so open workers, browsers, or project handles
-cannot keep the CLI alive.
+`runRemixTest()` returns the runner exit code. The `remix test` bin wrapper calls `process.exit()` with that code when the run finishes so open workers, browsers, or project handles cannot keep the CLI alive.
 
 ### Test Context
 

package/dist/app/server.d.ts

@@ -2,5 +2,6 @@ import * as http from 'node:http';
 export declare function startServer(browserFiles: string[]): Promise<{
     server: http.Server;
     port: number;
+    baseUrl: string;
 }>;
 //# sourceMappingURL=server.d.ts.map

package/dist/app/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/app/server.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAWjC,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAkChD"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/app/server.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAmBjC,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmCjE"}

package/dist/app/server.js

@@ -2,49 +2,58 @@ import { init as initEsModuleLexer, parse as parseEsModule } from 'es-module-lex
 import MagicString from 'magic-string';
 import * as fsp from 'node:fs/promises';
 import * as http from 'node:http';
-import { createRequire } from 'node:module';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { ResolverFactory } from 'oxc-resolver';
 import { SourceMapConsumer, SourceMapGenerator } from 'source-map-js';
 import { getBrowserTestRootDir, IS_RUNNING_FROM_SRC } from "../lib/config.js";
 import { transformTypeScript } from "../lib/ts-transform.js";
 const log = (str) => console.log(`[remix:test] ${str}`);
 const logError = (str, e) => console.error(`[remix:test] Error: ${str}\n`, e);
+const browserResolver = new ResolverFactory({
+    aliasFields: [['browser']],
+    conditionNames: ['browser', 'import', 'module', 'default'],
+    extensions: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'],
+    mainFields: ['browser', 'module', 'main'],
+    tsconfig: 'auto',
+});
 export async function startServer(browserFiles) {
     let handle = createRequestHandler(browserFiles);
-    let port = 44101;
-    let lastError;
-    for (let i = 0; i < 5; i++) {
-        try {
-            let server = http.createServer((req, res) => {
-                handle(req, res).catch((error) => {
-                    logError(`Unhandled error for ${req.url}`, error);
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'text/plain' });
-                    }
-                    if (!res.writableEnded)
-                        res.end();
-                });
-            });
-            await new Promise((resolve, reject) => {
-                server.once('error', reject);
-                server.listen(port, () => {
-                    server.removeListener('error', reject);
-                    log(`Test server running on http://localhost:${port}`);
+    let server = http.createServer((req, res) => {
+        handle(req, res).catch((error) => {
+            logError(`Unhandled error for ${req.url}`, error);
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+            }
+            if (!res.writableEnded)
+                res.end();
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, () => {
+            server.removeListener('error', reject);
+            resolve();
+        });
+    });
+    let address = server.address();
+    if (!isAddressInfo(address)) {
+        await new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error)
+                    reject(error);
+                else
                     resolve();
-                });
             });
-            return { server, port };
-        }
-        catch (error) {
-            if (error.code !== 'EADDRINUSE')
-                throw error;
-            lastError = error;
-            log(`Port ${port} is in use, trying another port...`);
-            port += 1;
-        }
+        });
+        throw new Error('Test server did not bind to a TCP port');
     }
-    throw lastError;
+    let baseUrl = `http://localhost:${address.port}`;
+    log(`Test server running on ${baseUrl}`);
+    return { server, port: address.port, baseUrl };
+}
+function isAddressInfo(address) {
+    return address != null && typeof address === 'object';
 }
 function createRequestHandler(browserFiles) {
     let rootDir = getBrowserTestRootDir();
@@ -251,19 +260,11 @@ function resolveSpecifier(spec, importerFile, rootDir) {
         resolvedPath = path.resolve(path.dirname(importerFile), spec);
     }
     else {
-        // Bare specifiers must be resolved from the importer's filesystem
-        // location, not this module's. `import.meta.resolve(spec, parent)` looks
-        // like the right tool but its `parent` argument is gated behind
-        // `--experimental-import-meta-resolve` through at least Node 24 —
-        // without the flag, the parent argument is silently ignored and
-        // resolution happens from `import.meta.url` of the calling module. That
-        // made bare specifiers only resolvable when they were direct deps of
-        // `@remix-run/test` itself (so `remix/assert` failed even when the
-        // importing package depended on `remix`). `createRequire` walks
-        // node_modules from the importer's actual location and has been stable
-        // since Node 12 with no flags.
         try {
-            resolvedPath = createRequire(importerFile).resolve(spec);
+            let resolutionResult = browserResolver.resolveFileSync(importerFile, spec);
+            if (!resolutionResult.path)
+                return null;
+            resolvedPath = resolutionResult.path;
         }
         catch {
             return null;

package/dist/cli.js

@@ -58,7 +58,7 @@ async function runRemixTestInCwd(argv, cwd) {
     let rerunTimer;
     let browserServer;
     let browserServerFilesKey;
-    let browserPort;
+    let browserBaseUrl;
     let resolveRun;
     let runPromise = new Promise((resolve) => {
         resolveRun = resolve;
@@ -82,7 +82,7 @@ async function runRemixTestInCwd(argv, cwd) {
         await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
         browserServer = undefined;
         browserServerFilesKey = undefined;
-        browserPort = undefined;
+        browserBaseUrl = undefined;
     };
     let queueRerun = (reason) => {
         if (!config.watch || hasExited)
@@ -135,7 +135,7 @@ async function runRemixTestInCwd(argv, cwd) {
                 let result = await startServer(browserFiles);
                 browserServer = result.server;
                 browserServerFilesKey = browserFilesKey;
-                browserPort = result.port;
+                browserBaseUrl = result.baseUrl;
             }
             let reporter = createReporter(config.reporter);
             let startTime = performance.now();
@@ -186,30 +186,33 @@ async function runRemixTestInCwd(argv, cwd) {
                             project.playwrightUseOpts = { ...project.playwrightUseOpts, headless: false };
                         }
                     }
-                    let [browserResult, e2eResult] = await Promise.all([
-                        runBrowserTests != null
-                            ? runBrowserTests({
-                                baseUrl: `http://localhost:${browserPort}`,
-                                console: config.browser?.echo,
-                                coverage: !!config.coverage,
-                                open: config.browser?.open,
-                                playwrightUseOpts: project.playwrightUseOpts,
-                                projectName: project.name,
-                                reporter,
-                                testFiles: browserFiles,
-                            })
-                            : null,
-                        e2eFiles.length > 0
-                            ? runServerTests(e2eFiles, reporter, config.concurrency, 'e2e', {
-                                open: config.browser?.open,
-                                playwrightUseOpts: project.playwrightUseOpts,
-                                projectName: project.name,
-                                coverage: config.coverage,
-                                cwd,
-                                pool: config.pool,
-                            })
-                            : null,
-                    ]);
+                    let browserResult = null;
+                    if (runBrowserTests != null) {
+                        let activeBrowserBaseUrl = browserBaseUrl;
+                        if (activeBrowserBaseUrl == null) {
+                            throw new Error('Browser test server was not started');
+                        }
+                        browserResult = await runBrowserTests({
+                            baseUrl: activeBrowserBaseUrl,
+                            console: config.browser?.echo,
+                            coverage: !!config.coverage,
+                            open: config.browser?.open,
+                            playwrightUseOpts: project.playwrightUseOpts,
+                            projectName: project.name,
+                            reporter,
+                            testFiles: browserFiles,
+                        });
+                    }
+                    let e2eResult = e2eFiles.length > 0
+                        ? await runServerTests(e2eFiles, reporter, config.concurrency, 'e2e', {
+                            open: config.browser?.open,
+                            playwrightUseOpts: project.playwrightUseOpts,
+                            projectName: project.name,
+                            coverage: config.coverage,
+                            cwd,
+                            pool: config.pool,
+                        })
+                        : null;
                     counts.passed += (browserResult?.results.passed ?? 0) + (e2eResult?.passed ?? 0);
                     counts.failed += (browserResult?.results.failed ?? 0) + (e2eResult?.failed ?? 0);
                     counts.skipped += (browserResult?.results.skipped ?? 0) + (e2eResult?.skipped ?? 0);

package/dist/lib/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/lib/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAE/E,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAErE,wBAAsB,QAAQ,CAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GAChE,OAAO,CAAC,WAAW,CAAC,CA0ItB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/lib/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,wBAAwB,EAAoB,MAAM,cAAc,CAAA;AAEjG,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAwBrE,wBAAsB,QAAQ,CAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GAChE,OAAO,CAAC,WAAW,CAAC,CA2JtB"}

package/dist/lib/executor.js

@@ -1,6 +1,6 @@
 import { createTestContext } from "./context.js";
 export async function runTests(options) {
-    let suites = globalThis.__testSuites || [];
+    let suites = getRegisteredSuites();
     let e2eCoverageEntries = [];
     let results = {
         passed: 0,
@@ -9,7 +9,7 @@ export async function runTests(options) {
         todo: 0,
         tests: [],
     };
-    let hasOnlySuites = suites.some((s) => s.only);
+    let hasOnlySuites = suites.some((suite) => suite.only);
     for (let suite of suites) {
         // If any suite uses .only, skip all non-only suites
         if (hasOnlySuites && !suite.only) {
@@ -38,15 +38,17 @@ export async function runTests(options) {
             continue;
         }
         if (suite.beforeAll) {
+            let startTime = performance.now();
             try {
                 await suite.beforeAll();
             }
             catch (error) {
-                console.error(`beforeAll failed in suite "${suite.name}":`, error);
+                results.tests.push(createFailedHookResult('beforeAll', suite.name, error, performance.now() - startTime));
+                results.failed++;
                 continue;
             }
         }
-        let hasOnlyTests = suite.tests.some((t) => t.only);
+        let hasOnlyTests = suite.tests.some((test) => test.only);
         for (let test of suite.tests) {
             // If any test uses .only, skip all non-only tests in this suite
             if (hasOnlyTests && !test.only) {
@@ -72,6 +74,10 @@ export async function runTests(options) {
                 status: 'passed',
                 duration: 0,
             };
+            let testError;
+            let afterEachError;
+            let testFailed = false;
+            let afterEachFailed = false;
             let contextOpts = options
                 ? {
                     ...options,
@@ -84,16 +90,10 @@ export async function runTests(options) {
                     await suite.beforeEach();
                 }
                 await test.fn(testContext);
-                result.status = 'passed';
-                results.passed++;
             }
             catch (error) {
-                result.status = 'failed';
-                result.error = {
-                    message: error.message || String(error),
-                    stack: error.stack,
-                };
-                results.failed++;
+                testFailed = true;
+                testError = error;
             }
             finally {
                 await cleanup();
@@ -102,19 +102,30 @@ export async function runTests(options) {
                         await suite.afterEach();
                     }
                     catch (error) {
-                        console.error('afterEach failed:', error);
+                        afterEachFailed = true;
+                        afterEachError = error;
                     }
                 }
+                if (testFailed || afterEachFailed) {
+                    result.status = 'failed';
+                    result.error = createTestError(testFailed ? testError : undefined, afterEachFailed ? createHookFailure('afterEach', afterEachError) : undefined);
+                    results.failed++;
+                }
+                else {
+                    results.passed++;
+                }
                 result.duration = performance.now() - startTime;
                 results.tests.push(result);
             }
         }
         if (suite.afterAll) {
+            let startTime = performance.now();
             try {
                 await suite.afterAll();
             }
             catch (error) {
-                console.error(`afterAll failed in suite "${suite.name}":`, error);
+                results.tests.push(createFailedHookResult('afterAll', suite.name, error, performance.now() - startTime));
+                results.failed++;
             }
         }
     }
@@ -126,3 +137,38 @@ export async function runTests(options) {
     }
     return results;
 }
+function getRegisteredSuites() {
+    let global = globalThis;
+    return global.__testSuites ?? [];
+}
+function createFailedHookResult(hookName, suiteName, error, duration) {
+    return {
+        name: hookName,
+        suiteName,
+        status: 'failed',
+        error: createTestError(createHookFailure(hookName, error)),
+        duration,
+    };
+}
+function createHookFailure(hookName, error) {
+    let cause = error instanceof Error ? error : new Error(String(error));
+    return new Error(`${hookName} failed: ${cause.message}`, { cause });
+}
+function createTestError(primaryError, secondaryError = undefined) {
+    let message = primaryError !== undefined ? getErrorMessage(primaryError) : undefined;
+    let stack = primaryError instanceof Error ? primaryError.stack : undefined;
+    if (secondaryError) {
+        message = message ? `${message}\n${secondaryError.message}` : secondaryError.message;
+        stack =
+            stack && secondaryError.stack
+                ? `${stack}\n${secondaryError.stack}`
+                : (stack ?? secondaryError.stack);
+    }
+    return {
+        message: message ?? 'Test failed',
+        stack,
+    };
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@remix-run/ui/jsx-runtime";
 import decamelize from 'decamelize';
+import cx from 'clsx';
 import * as assert from '@remix-run/assert';
 import { describe, it } from '@remix-run/test';
 import { on } from '@remix-run/ui';
@@ -75,6 +76,24 @@ describe('FieldLabel (using decamelize)', () => {
         assert.equal($('[data-testid="label"]')?.textContent, 'date of birth');
     });
 });
+describe('MobileMenu (using clsx)', () => {
+    function MobileMenu(handle) {
+        return () => {
+            let { isOpen } = handle.props;
+            return (_jsxs("nav", { "aria-label": "Mobile navigation", className: cx('mobile-menu', {
+                    'mobile-menu--open': isOpen,
+                    'mobile-menu--closed': !isOpen,
+                }), children: [
+                    _jsx("a", { href: "/docs", children: "Docs" }), _jsx("a", { href: "/blog", children: "Blog" })
+                ] }));
+        };
+    }
+    it('resolves browser-oriented package exports for default imports', (t) => {
+        let { $, cleanup } = render(_jsx(MobileMenu, { isOpen: true }));
+        t.after(cleanup);
+        assert.equal($('[aria-label="Mobile navigation"]')?.className, 'mobile-menu mobile-menu--open');
+    });
+});
 describe('DOM Tests', () => {
     it('can interact with DOM', async () => {
         let div = document.createElement('div');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/test",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "A test framework for JavaScript and TypeScript projects",
   "author": "Shopify Inc.",
   "license": "MIT",
@@ -44,13 +44,14 @@
     "istanbul-lib-report": "^3.0.1",
     "istanbul-reports": "^3.2.0",
     "magic-string": "^0.30.21",
+    "oxc-resolver": "^11.19.1",
     "source-map-js": "^1.2.1",
     "v8-to-istanbul": "^9.3.0",
     "@remix-run/node-tsx": "^0.1.1",
     "@remix-run/terminal": "^0.1.1"
   },
   "peerDependencies": {
-    "playwright": "^1.59.0"
+    "playwright": "^1.60.0"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -64,10 +65,11 @@
     "@types/istanbul-reports": "^3.0.4",
     "@types/node": "^24.6.0",
     "@typescript/native-preview": "7.0.0-dev.20251125.1",
-    "decamelize": "^6.0.1",
-    "playwright": "^1.59.0",
+    "clsx": "2.1.1",
+    "decamelize": "6.0.1",
+    "playwright": "^1.60.0",
     "@remix-run/assert": "^0.2.1",
-    "@remix-run/ui": "^0.2.0",
+    "@remix-run/ui": "^0.3.0",
     "@remix-run/node-fetch-server": "^0.13.3"
   },
   "keywords": [

package/src/app/server.ts

@@ -2,52 +2,65 @@ import { init as initEsModuleLexer, parse as parseEsModule } from 'es-module-lex
 import MagicString from 'magic-string'
 import * as fsp from 'node:fs/promises'
 import * as http from 'node:http'
-import { createRequire } from 'node:module'
+import type { AddressInfo } from 'node:net'
 import * as path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { ResolverFactory } from 'oxc-resolver'
 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)
+const browserResolver = new ResolverFactory({
+  aliasFields: [['browser']],
+  conditionNames: ['browser', 'import', 'module', 'default'],
+  extensions: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'],
+  mainFields: ['browser', 'module', 'main'],
+  tsconfig: 'auto',
+})
 
 export async function startServer(
   browserFiles: string[],
-): Promise<{ server: http.Server; port: number }> {
+): Promise<{ server: http.Server; port: number; baseUrl: string }> {
   let handle = createRequestHandler(browserFiles)
-  let port = 44101
 
-  let lastError: unknown
-  for (let i = 0; i < 5; i++) {
-    try {
-      let server = http.createServer((req, res) => {
-        handle(req, res).catch((error) => {
-          logError(`Unhandled error for ${req.url}`, error)
-          if (!res.headersSent) {
-            res.writeHead(500, { 'Content-Type': 'text/plain' })
-          }
-          if (!res.writableEnded) res.end()
-        })
-      })
-      await new Promise<void>((resolve, reject) => {
-        server.once('error', reject)
-        server.listen(port, () => {
-          server.removeListener('error', reject)
-          log(`Test server running on http://localhost:${port}`)
-          resolve()
-        })
+  let server = http.createServer((req, res) => {
+    handle(req, res).catch((error) => {
+      logError(`Unhandled error for ${req.url}`, error)
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' })
+      }
+      if (!res.writableEnded) res.end()
+    })
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, () => {
+      server.removeListener('error', reject)
+      resolve()
+    })
+  })
+
+  let address = server.address()
+  if (!isAddressInfo(address)) {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error) reject(error)
+        else resolve()
       })
-      return { server, port }
-    } catch (error: any) {
-      if (error.code !== 'EADDRINUSE') throw error
-      lastError = error
-      log(`Port ${port} is in use, trying another port...`)
-      port += 1
-    }
+    })
+    throw new Error('Test server did not bind to a TCP port')
   }
 
-  throw lastError
+  let baseUrl = `http://localhost:${address.port}`
+  log(`Test server running on ${baseUrl}`)
+  return { server, port: address.port, baseUrl }
+}
+
+function isAddressInfo(address: ReturnType<http.Server['address']>): address is AddressInfo {
+  return address != null && typeof address === 'object'
 }
 
 function createRequestHandler(
@@ -280,19 +293,10 @@ function resolveSpecifier(spec: string, importerFile: string, rootDir: string):
   if (spec.startsWith('.') || spec.startsWith('/')) {
     resolvedPath = path.resolve(path.dirname(importerFile), spec)
   } else {
-    // Bare specifiers must be resolved from the importer's filesystem
-    // location, not this module's. `import.meta.resolve(spec, parent)` looks
-    // like the right tool but its `parent` argument is gated behind
-    // `--experimental-import-meta-resolve` through at least Node 24 —
-    // without the flag, the parent argument is silently ignored and
-    // resolution happens from `import.meta.url` of the calling module. That
-    // made bare specifiers only resolvable when they were direct deps of
-    // `@remix-run/test` itself (so `remix/assert` failed even when the
-    // importing package depended on `remix`). `createRequire` walks
-    // node_modules from the importer's actual location and has been stable
-    // since Node 12 with no flags.
     try {
-      resolvedPath = createRequire(importerFile).resolve(spec)
+      let resolutionResult = browserResolver.resolveFileSync(importerFile, spec)
+      if (!resolutionResult.path) return null
+      resolvedPath = resolutionResult.path
     } catch {
       return null
     }

package/src/cli.ts

@@ -99,7 +99,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
   let rerunTimer: NodeJS.Timeout | undefined
   let browserServer: http.Server | undefined
   let browserServerFilesKey: string | undefined
-  let browserPort: number | undefined
+  let browserBaseUrl: string | undefined
   let resolveRun: ((exitCode: number) => void) | undefined
 
   let runPromise = new Promise<number>((resolve) => {
@@ -127,7 +127,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
     )
     browserServer = undefined
     browserServerFilesKey = undefined
-    browserPort = undefined
+    browserBaseUrl = undefined
   }
 
   let queueRerun = (reason: string) => {
@@ -189,7 +189,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
         let result = await startServer(browserFiles)
         browserServer = result.server
         browserServerFilesKey = browserFilesKey
-        browserPort = result.port
+        browserBaseUrl = result.baseUrl
       }
 
       let reporter = createReporter(config.reporter)
@@ -260,21 +260,28 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
             }
           }
 
-          let [browserResult, e2eResult] = await Promise.all([
-            runBrowserTests != null
-              ? runBrowserTests({
-                  baseUrl: `http://localhost:${browserPort}`,
-                  console: config.browser?.echo,
-                  coverage: !!config.coverage,
-                  open: config.browser?.open,
-                  playwrightUseOpts: project.playwrightUseOpts,
-                  projectName: project.name,
-                  reporter,
-                  testFiles: browserFiles,
-                })
-              : null,
+          let browserResult: Awaited<ReturnType<RunBrowserTests>> | null = null
+          if (runBrowserTests != null) {
+            let activeBrowserBaseUrl = browserBaseUrl
+            if (activeBrowserBaseUrl == null) {
+              throw new Error('Browser test server was not started')
+            }
+
+            browserResult = await runBrowserTests({
+              baseUrl: activeBrowserBaseUrl,
+              console: config.browser?.echo,
+              coverage: !!config.coverage,
+              open: config.browser?.open,
+              playwrightUseOpts: project.playwrightUseOpts,
+              projectName: project.name,
+              reporter,
+              testFiles: browserFiles,
+            })
+          }
+
+          let e2eResult =
             e2eFiles.length > 0
-              ? runServerTests(e2eFiles, reporter, config.concurrency, 'e2e', {
+              ? await runServerTests(e2eFiles, reporter, config.concurrency, 'e2e', {
                   open: config.browser?.open,
                   playwrightUseOpts: project.playwrightUseOpts,
                   projectName: project.name,
@@ -282,8 +289,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
                   cwd,
                   pool: config.pool,
                 })
-              : null,
-          ])
+              : null
 
           counts.passed += (browserResult?.results.passed ?? 0) + (e2eResult?.passed ?? 0)
           counts.failed += (browserResult?.results.failed ?? 0) + (e2eResult?.failed ?? 0)

package/src/lib/executor.ts

@@ -1,11 +1,33 @@
-import { createTestContext, type CreateTestContextOptions } from './context.ts'
+import { createTestContext, type CreateTestContextOptions, type TestContext } from './context.ts'
 import type { V8CoverageEntry } from './coverage.ts'
 import type { TestResult, TestResults } from './reporters/results.ts'
 
+type LifecycleHook = () => void | Promise<void>
+
+interface RegisteredSuite {
+  name: string
+  tests: RegisteredTest[]
+  only?: boolean
+  skip?: boolean
+  todo?: boolean
+  beforeEach?: LifecycleHook
+  afterEach?: LifecycleHook
+  beforeAll?: LifecycleHook
+  afterAll?: LifecycleHook
+}
+
+interface RegisteredTest {
+  name: string
+  fn: (t: TestContext) => void | Promise<void>
+  only?: boolean
+  skip?: boolean
+  todo?: boolean
+}
+
 export async function runTests(
   options?: Omit<CreateTestContextOptions, 'addE2ECoverageEntries'>,
 ): Promise<TestResults> {
-  let suites = (globalThis as any).__testSuites || []
+  let suites = getRegisteredSuites()
   let e2eCoverageEntries: Array<{ entries: V8CoverageEntry[]; baseUrl: string }> = []
   let results: TestResults = {
     passed: 0,
@@ -15,7 +37,7 @@ export async function runTests(
     tests: [],
   }
 
-  let hasOnlySuites = suites.some((s: any) => s.only)
+  let hasOnlySuites = suites.some((suite) => suite.only)
 
   for (let suite of suites) {
     // If any suite uses .only, skip all non-only suites
@@ -47,15 +69,19 @@ export async function runTests(
     }
 
     if (suite.beforeAll) {
+      let startTime = performance.now()
       try {
         await suite.beforeAll()
       } catch (error) {
-        console.error(`beforeAll failed in suite "${suite.name}":`, error)
+        results.tests.push(
+          createFailedHookResult('beforeAll', suite.name, error, performance.now() - startTime),
+        )
+        results.failed++
         continue
       }
     }
 
-    let hasOnlyTests = suite.tests.some((t: any) => t.only)
+    let hasOnlyTests = suite.tests.some((test) => test.only)
 
     for (let test of suite.tests) {
       // If any test uses .only, skip all non-only tests in this suite
@@ -84,6 +110,10 @@ export async function runTests(
         status: 'passed',
         duration: 0,
       }
+      let testError: unknown
+      let afterEachError: unknown
+      let testFailed = false
+      let afterEachFailed = false
 
       let contextOpts: CreateTestContextOptions | undefined = options
         ? {
@@ -99,36 +129,45 @@ export async function runTests(
         }
 
         await test.fn(testContext)
-
-        result.status = 'passed'
-        results.passed++
-      } catch (error: any) {
-        result.status = 'failed'
-        result.error = {
-          message: error.message || String(error),
-          stack: error.stack,
-        }
-        results.failed++
+      } catch (error) {
+        testFailed = true
+        testError = error
       } finally {
         await cleanup()
         if (suite.afterEach) {
           try {
             await suite.afterEach()
           } catch (error) {
-            console.error('afterEach failed:', error)
+            afterEachFailed = true
+            afterEachError = error
           }
         }
 
+        if (testFailed || afterEachFailed) {
+          result.status = 'failed'
+          result.error = createTestError(
+            testFailed ? testError : undefined,
+            afterEachFailed ? createHookFailure('afterEach', afterEachError) : undefined,
+          )
+          results.failed++
+        } else {
+          results.passed++
+        }
+
         result.duration = performance.now() - startTime
         results.tests.push(result)
       }
     }
 
     if (suite.afterAll) {
+      let startTime = performance.now()
       try {
         await suite.afterAll()
       } catch (error) {
-        console.error(`afterAll failed in suite "${suite.name}":`, error)
+        results.tests.push(
+          createFailedHookResult('afterAll', suite.name, error, performance.now() - startTime),
+        )
+        results.failed++
       }
     }
   }
@@ -143,3 +182,53 @@ export async function runTests(
 
   return results
 }
+
+function getRegisteredSuites(): RegisteredSuite[] {
+  let global = globalThis as typeof globalThis & { __testSuites?: RegisteredSuite[] }
+  return global.__testSuites ?? []
+}
+
+function createFailedHookResult(
+  hookName: string,
+  suiteName: string,
+  error: unknown,
+  duration: number,
+): TestResult {
+  return {
+    name: hookName,
+    suiteName,
+    status: 'failed',
+    error: createTestError(createHookFailure(hookName, error)),
+    duration,
+  }
+}
+
+function createHookFailure(hookName: string, error: unknown): Error {
+  let cause = error instanceof Error ? error : new Error(String(error))
+  return new Error(`${hookName} failed: ${cause.message}`, { cause })
+}
+
+function createTestError(
+  primaryError: unknown,
+  secondaryError: Error | undefined = undefined,
+): TestResult['error'] {
+  let message = primaryError !== undefined ? getErrorMessage(primaryError) : undefined
+  let stack = primaryError instanceof Error ? primaryError.stack : undefined
+
+  if (secondaryError) {
+    message = message ? `${message}\n${secondaryError.message}` : secondaryError.message
+    stack =
+      stack && secondaryError.stack
+        ? `${stack}\n${secondaryError.stack}`
+        : (stack ?? secondaryError.stack)
+  }
+
+  return {
+    message: message ?? 'Test failed',
+    stack,
+  }
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}