@remix-run/test 0.2.0 → 0.4.0

package/dist/lib/worker-process.js

@@ -0,0 +1,55 @@
+import { runE2ETestFile } from "./worker-e2e-file.js";
+import { runServerTestFile } from "./worker-server.js";
+import { createFailedResults } from "./worker-results.js";
+const workerData = await readWorkerData();
+const results = await runWorkerProcessFile(workerData);
+if (results) {
+    await sendResults(results);
+}
+if (process.connected) {
+    process.disconnect();
+}
+process.exitCode = 0;
+function readWorkerData() {
+    return new Promise((resolve, reject) => {
+        function cleanup() {
+            process.off('message', onMessage);
+            process.off('disconnect', onDisconnect);
+        }
+        function onMessage(value) {
+            cleanup();
+            resolve(value);
+        }
+        function onDisconnect() {
+            cleanup();
+            reject(new Error('Test worker process disconnected'));
+        }
+        process.once('message', onMessage);
+        process.once('disconnect', onDisconnect);
+    });
+}
+async function runWorkerProcessFile(value) {
+    try {
+        if (!isRecord(value) || (value.type !== 'server' && value.type !== 'e2e')) {
+            throw new Error('Invalid test worker process data');
+        }
+        return value.type === 'e2e'
+            ? await runE2ETestFile(value, sendResults)
+            : await runServerTestFile(value);
+    }
+    catch (error) {
+        return createFailedResults(error);
+    }
+}
+async function sendResults(results) {
+    if (!process.send) {
+        throw new Error('Test worker process is missing an IPC channel');
+    }
+    let send = process.send.bind(process);
+    await new Promise((resolve, reject) => {
+        send(results, undefined, undefined, (error) => (error ? reject(error) : resolve()));
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/lib/worker-results.d.ts

@@ -0,0 +1,3 @@
+import type { TestResults } from './reporters/results.ts';
+export declare function createFailedResults(error: unknown): TestResults;
+//# sourceMappingURL=worker-results.d.ts.map

package/dist/lib/worker-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-results.d.ts","sourceRoot":"","sources":["../../src/lib/worker-results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAmB/D"}

package/dist/lib/worker-results.js

@@ -0,0 +1,20 @@
+export function createFailedResults(error) {
+    return {
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        todo: 0,
+        tests: [
+            {
+                name: '',
+                suiteName: '',
+                status: 'failed',
+                duration: 0,
+                error: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                },
+            },
+        ],
+    };
+}

package/dist/lib/worker-server.d.ts

@@ -0,0 +1,10 @@
+import type { CoverageConfig } from './coverage.ts';
+import type { TestResults } from './reporters/results.ts';
+export interface ServerTestWorkerData {
+    file: string;
+    coverage?: CoverageConfig;
+}
+export declare function runServerTestFile(value: unknown): Promise<TestResults>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parseCoverageConfig(value: unknown): CoverageConfig | undefined;
+//# sourceMappingURL=worker-server.d.ts.map

package/dist/lib/worker-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-server.d.ts","sourceRoot":"","sources":["../../src/lib/worker-server.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAKzD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAiC5E;AAaD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CA2B9E"}

package/dist/lib/worker-server.js

@@ -0,0 +1,112 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as mod from 'node:module';
+import { IS_RUNNING_FROM_SRC } from "./config.js";
+import { importModule } from "./import-module.js";
+import { runTests } from "./executor.js";
+import { IS_BUN } from "./runtime.js";
+import { createFailedResults } from "./worker-results.js";
+export async function runServerTestFile(value) {
+    let workerData;
+    try {
+        workerData = parseServerTestWorkerData(value);
+        // 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)
+            let ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js';
+            mod.register(new URL(`./coverage-loader${ext}`, import.meta.url), import.meta.url);
+            await import(__rewriteRelativeImportExtension(workerData.file));
+        }
+        else {
+            await importModule(workerData.file, import.meta);
+        }
+        let results = await runTests();
+        await takeCoverage(workerData.coverage);
+        return results;
+    }
+    catch (error) {
+        let failure = error;
+        try {
+            await takeCoverage(workerData?.coverage);
+        }
+        catch (coverageError) {
+            failure = coverageError;
+        }
+        return createFailedResults(failure);
+    }
+}
+function parseServerTestWorkerData(value) {
+    if (!isRecord(value) || typeof value.file !== 'string') {
+        throw new Error('Invalid server test worker data');
+    }
+    return {
+        file: value.file,
+        coverage: parseCoverageConfig(value.coverage),
+    };
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function parseCoverageConfig(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value) || typeof value.dir !== 'string') {
+        throw new Error('Invalid server test worker coverage config');
+    }
+    let coverage = {
+        dir: value.dir,
+    };
+    let include = parseStringArray(value.include, 'include');
+    let exclude = parseStringArray(value.exclude, 'exclude');
+    let statements = parseNumber(value.statements, 'statements');
+    let lines = parseNumber(value.lines, 'lines');
+    let branches = parseNumber(value.branches, 'branches');
+    let functions = parseNumber(value.functions, 'functions');
+    if (include)
+        coverage.include = include;
+    if (exclude)
+        coverage.exclude = exclude;
+    if (statements !== undefined)
+        coverage.statements = statements;
+    if (lines !== undefined)
+        coverage.lines = lines;
+    if (branches !== undefined)
+        coverage.branches = branches;
+    if (functions !== undefined)
+        coverage.functions = functions;
+    return coverage;
+}
+function parseStringArray(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+        throw new Error(`Invalid server test worker coverage ${name}`);
+    }
+    return value;
+}
+function parseNumber(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number') {
+        throw new Error(`Invalid server test worker coverage ${name}`);
+    }
+    return value;
+}
+async function takeCoverage(coverage) {
+    if (coverage && !IS_BUN) {
+        let v8 = await import('node:v8');
+        v8.takeCoverage();
+    }
+}

package/dist/lib/worker.js

@@ -1,57 +1,8 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import * as mod from 'node:module';
-import * as path from 'node:path';
 import { parentPort, workerData } from 'node:worker_threads';
-import { runTests } from "./executor.js";
-import { importModule } from "./import-module.js";
-import { IS_BUN } from "./runtime.js";
-import { IS_RUNNING_FROM_SRC } from "./config.js";
-try {
-    // 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.
-    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)
-        let ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js';
-        mod.register(new URL(`./coverage-loader${ext}`, import.meta.url), import.meta.url);
-        await import(__rewriteRelativeImportExtension(workerData.file));
-    }
-    else {
-        await importModule(workerData.file, import.meta);
-    }
-    let results = await runTests();
-    parentPort.postMessage(results);
-    process.exit(0);
-}
-catch (e) {
-    let results = {
-        passed: 0,
-        failed: 1,
-        skipped: 0,
-        todo: 0,
-        tests: [
-            {
-                name: '',
-                suiteName: '',
-                status: 'failed',
-                duration: 0,
-                error: {
-                    message: e instanceof Error ? e.message : String(e),
-                    stack: e instanceof Error ? e.stack : undefined,
-                },
-            },
-        ],
-    };
-    parentPort.postMessage(results);
-    process.exit(0);
+import { runServerTestFile } from "./worker-server.js";
+if (!parentPort) {
+    throw new Error('Server test worker is missing a parent port');
 }
+const results = await runServerTestFile(workerData);
+parentPort.postMessage(results);
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/test",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A test framework for JavaScript and TypeScript projects",
   "author": "Shopify Inc.",
   "license": "MIT",
@@ -45,8 +45,8 @@
     "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/node-tsx": "^0.1.0",
     "@remix-run/terminal": "^0.1.0"
   },
   "peerDependencies": {
@@ -66,9 +66,9 @@
     "@typescript/native-preview": "7.0.0-dev.20251125.1",
     "decamelize": "^6.0.1",
     "playwright": "^1.59.0",
-    "@remix-run/assert": "^0.1.0",
-    "@remix-run/node-fetch-server": "^0.13.0",
-    "@remix-run/ui": "^0.1.0"
+    "@remix-run/assert": "^0.2.0",
+    "@remix-run/ui": "^0.1.2",
+    "@remix-run/node-fetch-server": "^0.13.2"
   },
   "keywords": [
     "testing",

package/src/app/client/entry.ts

@@ -185,6 +185,10 @@ function runInIframe(testFile: string): Promise<FileResults> {
   return new Promise((resolve) => {
     let iframe = document.createElement('iframe')
     iframe.src = `/iframe?file=${encodeURIComponent(testFile)}`
+    // Make the iframe as big so we don't get unintentional scrolling in test UIs
+    let parentBody = iframe.contentWindow?.document.body
+    iframe.width = Math.max(parentBody?.scrollWidth ?? 0, 800).toString()
+    iframe.height = Math.max(Math.round((parentBody?.scrollHeight ?? 0) / 2), 400).toString()
     document.body.appendChild(iframe)
 
     function onMessage(event: MessageEvent) {

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

@@ -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,27 @@ 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`.'
+
+/**
+ * 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
 }
 
+type RunBrowserTests = typeof browserTestRunner.runBrowserTests
+
 interface DiscoveredTests {
   files: string[]
   serverFiles: string[]
@@ -32,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())
@@ -157,11 +192,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 +213,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
           {
             coverage: config.coverage,
             cwd,
+            pool: config.pool,
           },
         )
         counts.failed += serverResult.failed
@@ -194,18 +225,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 +261,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 +280,7 @@ async function runRemixTestInCwd(argv: string[], cwd: string): Promise<number> {
                   projectName: project.name,
                   coverage: config.coverage,
                   cwd,
+                  pool: config.pool,
                 })
               : null,
           ])
@@ -312,6 +352,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 +403,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 +418,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 +434,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 +447,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,