@remix-run/test 0.1.0 → 0.2.0

package/dist/lib/config.js

@@ -1,8 +1,31 @@
+import * as fsp from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import * as fsp from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 import * as util from 'node:util';
-import { tsImport } from 'tsx/esm/api';
+import { importModule } from "./import-module.js";
+export const IS_RUNNING_FROM_SRC = path.extname(new URL(import.meta.url).pathname) === '.ts';
+/*
+ * The root directory for the test code. Coverage URLs are emitted as
+ * `/scripts/<rel-from-rootDir>` and resolved back via the same anchor.
+ *
+ *   - In a published install: `process.cwd()`, since deps and user source all
+ *     live under it.
+ *   - In monorepo src mode: the monorepo root, computed by walking back from
+ *     the resolved `@remix-run/test` source path. `process.cwd()` doesn't work
+ *     here because workspace deps and node_modules live above the per-package
+ *     cwd.
+ */
+export function getBrowserTestRootDir() {
+    return IS_RUNNING_FROM_SRC
+        ? // Resolve to packages/test/src/index.ts and the pop 3 directories off to the repo root
+            path
+                .dirname(fileURLToPath(import.meta.resolve('@remix-run/test')))
+                .split(path.sep)
+                .slice(0, -3)
+                .join(path.sep)
+        : process.cwd();
+}
 // prettier-ignore
 // Note: `description` is not a field used by parseArgs(), it's an additional field
 // we use for `--help`
@@ -15,10 +38,18 @@ const cliOptions = {
         type: 'boolean',
         description: 'Open browser window and keep open after tests finish',
     },
+    'glob.browser': {
+        type: 'string',
+        description: 'Glob pattern for browser test files',
+    },
     'glob.e2e': {
         type: 'string',
         description: 'Glob pattern for E2E test files',
     },
+    'glob.exclude': {
+        type: 'string',
+        description: 'Glob pattern for paths to exclude from discovery',
+    },
     'glob.test': {
         type: 'string',
         description: 'Glob pattern for all test files',
@@ -32,6 +63,40 @@ const cliOptions = {
         type: 'string',
         description: 'Path to config file (default: remix-test.config.ts)',
     },
+    coverage: {
+        type: 'boolean',
+        description: 'Enable or disable coverage collection (default: false)',
+    },
+    'coverage.dir': {
+        type: 'string',
+        description: 'Directory to output coverage reports (default: .coverage)',
+    },
+    'coverage.include': {
+        type: 'string',
+        multiple: true,
+        description: 'Glob pattern(s) for files to include in coverage',
+    },
+    'coverage.exclude': {
+        type: 'string',
+        multiple: true,
+        description: 'Glob pattern(s) for files to exclude from coverage',
+    },
+    'coverage.branches': {
+        type: 'string',
+        description: 'Branches coverage threshold percentage',
+    },
+    'coverage.functions': {
+        type: 'string',
+        description: 'Functions coverage threshold percentage',
+    },
+    'coverage.lines': {
+        type: 'string',
+        description: 'Lines coverage threshold percentage',
+    },
+    'coverage.statements': {
+        type: 'string',
+        description: 'Statements coverage threshold percentage',
+    },
     setup: {
         type: 'string',
         short: 's',
@@ -54,7 +119,7 @@ const cliOptions = {
     type: {
         type: 'string',
         short: 't',
-        description: 'Comma-separated test types to run (default: server,e2e)',
+        description: 'Comma-separated test types to run (default: server,browser,e2e)',
     },
     watch: {
         type: 'boolean',
@@ -68,28 +133,35 @@ const defaultValues = {
         open: false,
     },
     concurrency: os.availableParallelism(),
+    coverage: {
+        dir: '.coverage',
+        include: undefined,
+        exclude: undefined,
+        statements: undefined,
+        lines: undefined,
+        branches: undefined,
+        functions: undefined,
+    },
     glob: {
-        test: '**/*.test?(.e2e).{ts,tsx}',
+        test: '**/*.test{,.e2e,.browser}.{ts,tsx}',
+        browser: '**/*.test.browser.{ts,tsx}',
         e2e: '**/*.test.e2e.{ts,tsx}',
+        exclude: 'node_modules/**',
     },
-    reporter: process.env.CI === 'true' ? 'dot' : 'spec',
-    type: 'server,e2e',
+    reporter: process.env.CI === 'true' ? 'files' : 'spec',
+    type: 'server,browser,e2e',
     setup: undefined,
     playwrightConfig: undefined,
     project: undefined,
     watch: false,
 };
-export async function loadConfig() {
-    if (process.argv.includes('--help') || process.argv.includes('-h')) {
-        console.log(generateHelp());
-        process.exit(0);
-    }
-    let parsed = parseCliArgs();
-    let fileConfig = await loadConfigFile(parsed.values.config);
+export async function loadConfig(args = process.argv.slice(2), cwd = process.cwd()) {
+    let parsed = parseCliArgs(args);
+    let fileConfig = await loadConfigFile(parsed.values.config, cwd);
     let config = resolveConfig(fileConfig, parsed);
     return config;
 }
-function generateHelp() {
+export function getRemixTestHelpText(_target = process.stdout) {
     let lines = [
         'Usage: remix-test [glob] [options]',
         '',
@@ -106,23 +178,57 @@ function generateHelp() {
     lines.push(`  ${'-h, --help'.padEnd(30)} Show this help message`);
     return lines.join('\n');
 }
-function parseCliArgs(args = process.argv.slice(2)) {
+function parseCliArgs(args) {
     return util.parseArgs({ args, options: cliOptions, allowPositionals: true });
 }
 function resolveConfig(fileConfig, { values: cliValues, positionals }) {
+    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,
         },
         browser: {
             echo: cliValues['browser.echo'] ?? fileConfig.browser?.echo ?? defaultValues.browser.echo,
             open: cliValues['browser.open'] ?? fileConfig.browser?.open ?? defaultValues.browser.open,
         },
         concurrency: Number(cliValues.concurrency ?? fileConfig.concurrency ?? defaultValues.concurrency),
+        coverage: 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,
+                statements: cliValues['coverage.statements'] !== undefined
+                    ? Number(cliValues['coverage.statements'])
+                    : fileCoverage.statements !== undefined
+                        ? Number(fileCoverage.statements)
+                        : undefined,
+                lines: cliValues['coverage.lines'] !== undefined
+                    ? Number(cliValues['coverage.lines'])
+                    : fileCoverage.lines !== undefined
+                        ? Number(fileCoverage.lines)
+                        : undefined,
+                branches: cliValues['coverage.branches'] !== undefined
+                    ? Number(cliValues['coverage.branches'])
+                    : fileCoverage.branches !== undefined
+                        ? Number(fileCoverage.branches)
+                        : undefined,
+                functions: cliValues['coverage.functions'] !== undefined
+                    ? Number(cliValues['coverage.functions'])
+                    : fileCoverage.functions !== undefined
+                        ? Number(fileCoverage.functions)
+                        : undefined,
+            }
+            : undefined,
         setup: cliValues.setup ?? fileConfig.setup ?? defaultValues.setup,
         playwrightConfig: cliValues.playwrightConfig ?? fileConfig.playwrightConfig ?? defaultValues.playwrightConfig,
         project: cliValues.project ?? fileConfig.project ?? defaultValues.project,
@@ -131,17 +237,14 @@ function resolveConfig(fileConfig, { values: cliValues, positionals }) {
         watch: cliValues.watch ?? fileConfig.watch ?? defaultValues.watch,
     };
 }
-async function loadConfigFile(configPath) {
+async function loadConfigFile(configPath, cwd) {
     let candidates = configPath
-        ? [path.resolve(process.cwd(), configPath)]
-        : [
-            path.join(process.cwd(), 'remix-test.config.ts'),
-            path.join(process.cwd(), 'remix-test.config.js'),
-        ];
+        ? [path.resolve(cwd, configPath)]
+        : [path.join(cwd, 'remix-test.config.ts'), path.join(cwd, 'remix-test.config.js')];
     for (let candidate of candidates) {
         try {
             await fsp.access(candidate);
-            let mod = await tsImport(candidate, { parentURL: import.meta.url });
+            let mod = await importModule(candidate, import.meta);
             return mod.default ?? mod;
         }
         catch {

package/dist/lib/context.d.ts

@@ -1,7 +1,17 @@
 import type { Browser, Page } from 'playwright';
-import { type MockFunction, type MockCall, type MockContext } from './mock.ts';
-import type { CreateServerFunction } from './e2e-server.ts';
+import type { V8CoverageEntry } from './coverage.ts';
+import { type FakeTimers } from './fake-timers.ts';
+import { type MockCall, type MockContext, type MockFunction } from './mock.ts';
 import type { getPlaywrightPageOptions } from './playwright.ts';
+/**
+ * The shape `t.serve()` consumes. Matches the result of `createTestServer`
+ * from `@remix-run/node-fetch-server/test`, but any object with a `baseUrl`
+ * and async `close()` works.
+ */
+export interface TestServer {
+    baseUrl: string;
+    close(): Promise<void>;
+}
 /**
  * Test Context providing utilities for testing via remix-test.  The context is
  * passed as the first argument to the {@link test}/{@link it} functions.
@@ -49,21 +59,35 @@ export interface TestContext {
         method<T extends object, K extends keyof T>(obj: T, methodName: K, impl?: Function): MockFunction;
     };
     /**
-     * Starts a test server with the provided request handler.
+     * Activates fake timers for testing time-dependent code.
      *
-     * @param {(req: Request) => Promise<Response>} handler - Function handling incoming requests
-     * @returns {Promise<Page>} A promise resolving to a page instance for the server
+     * @returns {FakeTimers} A fake timers instance for controlling time
      */
-    serve(handler: (req: Request) => Promise<Response>): Promise<Page>;
+    useFakeTimers(): FakeTimers;
+    /**
+     * 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.
+     *
+     * @param server - The running server the page should target
+     * @returns A `Page` whose `baseURL` is set to `server.baseUrl`.
+     */
+    serve(server: TestServer): Promise<Page>;
+}
+export interface CreateTestContextOptions {
+    addE2ECoverageEntries: (value: {
+        entries: V8CoverageEntry[];
+        baseUrl: string;
+    }) => void;
+    browser: Browser;
+    coverage: boolean;
+    open: boolean;
+    playwrightPageOptions: ReturnType<typeof getPlaywrightPageOptions>;
 }
-export declare function createTestContext(options: {
-    createServer?: CreateServerFunction;
-    browser?: Browser;
-    open?: boolean;
-    playwrightPageOptions?: ReturnType<typeof getPlaywrightPageOptions>;
-}): {
+export declare function createTestContext(options?: CreateTestContextOptions): {
     testContext: TestContext;
     cleanup(): Promise<void>;
 };
-export type { MockFunction, MockCall, MockContext };
+export type { MockCall, MockContext, MockFunction };
 //# sourceMappingURL=context.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAQ,KAAK,YAAY,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAEpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAE3B;;;OAGG;IACH,IAAI,EAAE;QACJ;;;;;;WAMG;QACH,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAEhE;;;;;;;;;;WAUG;QACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,CAAC,EACb,IAAI,CAAC,EAAE,QAAQ,GACd,YAAY,CAAA;KAChB,CAAA;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,YAAY,CAAC,EAAE,oBAAoB,CAAA;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,qBAAqB,CAAC,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;CACpE,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAkDzD;AAED,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACpE,OAAO,EAAQ,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AACpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAE/D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAE3B;;;OAGG;IACH,IAAI,EAAE;QACJ;;;;;;WAMG;QACH,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAEhE;;;;;;;;;;WAUG;QACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,CAAC,EACb,IAAI,CAAC,EAAE,QAAQ,GACd,YAAY,CAAA;KAChB,CAAA;IAED;;;;OAIG;IACH,aAAa,IAAI,UAAU,CAAA;IAE3B;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC;AAED,MAAM,WAAW,wBAAwB;IACvC,qBAAqB,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IACvF,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,qBAAqB,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG;IACrE,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAkEA;AAED,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAA"}

package/dist/lib/context.js

@@ -1,3 +1,4 @@
+import { createFakeTimers } from "./fake-timers.js";
 import { mock } from "./mock.js";
 export function createTestContext(options) {
     let cleanups = [];
@@ -14,11 +15,15 @@ export function createTestContext(options) {
         after(fn) {
             cleanups.push(fn);
         },
-        async serve(handler) {
-            if (!options.createServer || !options.browser) {
+        useFakeTimers() {
+            let timers = createFakeTimers();
+            cleanups.push(timers.restore);
+            return timers;
+        },
+        async serve(server) {
+            if (!options || !options.browser) {
                 throw new Error('t.serve() is only available in E2E test suites');
             }
-            let server = await options.createServer(handler);
             let page = await options.browser.newPage({
                 ...options.playwrightPageOptions,
                 baseURL: server.baseUrl,
@@ -29,6 +34,17 @@ export function createTestContext(options) {
             if (options.playwrightPageOptions?.actionTimeout != null) {
                 page.setDefaultTimeout(options.playwrightPageOptions.actionTimeout);
             }
+            let coverageEnabled = options.coverage && options.browser.browserType().name() === 'chromium';
+            if (coverageEnabled) {
+                await page.coverage.startJSCoverage({ resetOnNavigation: false });
+                cleanups.push(async () => {
+                    let entries = await page.coverage.stopJSCoverage();
+                    options.addE2ECoverageEntries?.({
+                        entries: entries,
+                        baseUrl: server.baseUrl,
+                    });
+                });
+            }
             cleanups.push(async () => {
                 if (!options.open) {
                     await page.close();

package/dist/lib/coverage-loader.d.ts

@@ -0,0 +1,16 @@
+export declare function load(url: string, context: {
+    format?: string;
+}, nextLoad: (url: string, context: {
+    format?: string;
+}) => Promise<{
+    format: string;
+    source: string;
+}>): Promise<{
+    format: string;
+    source: string;
+} | {
+    format: string;
+    source: string;
+    shortCircuit: boolean;
+}>;
+//# sourceMappingURL=coverage-loader.d.ts.map

package/dist/lib/coverage-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-loader.d.ts","sourceRoot":"","sources":["../../src/lib/coverage-loader.ts"],"names":[],"mappings":"AAYA,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5B,QAAQ,EAAE,CACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KACzB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;;;;;;;GAYjD"}

package/dist/lib/coverage-loader.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformTypeScript } from "./ts-transform.js";
+// 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
+// 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.
+export async function load(url, context, nextLoad) {
+    let cleanUrl = url.includes('?') ? url.slice(0, url.indexOf('?')) : url;
+    if (!cleanUrl.endsWith('.ts') && !cleanUrl.endsWith('.tsx')) {
+        return nextLoad(url, context);
+    }
+    let filePath = fileURLToPath(cleanUrl);
+    let source = await readFile(filePath, 'utf-8');
+    let { code } = await transformTypeScript(source, filePath);
+    return { format: 'module', source: code, shortCircuit: true };
+}

package/dist/lib/coverage.d.ts

@@ -0,0 +1,28 @@
+import type { createCoverageMap as CreateCoverageMap } from 'istanbul-lib-coverage';
+export interface CoverageConfig {
+    dir: string;
+    include?: string[];
+    exclude?: string[];
+    statements?: number;
+    lines?: number;
+    branches?: number;
+    functions?: number;
+}
+export interface V8CoverageEntry {
+    url: string;
+    source?: string;
+    functions: Array<{
+        functionName: string;
+        isBlockCoverage: boolean;
+        ranges: Array<{
+            startOffset: number;
+            endOffset: number;
+            count: number;
+        }>;
+    }>;
+}
+export type CoverageMap = ReturnType<typeof CreateCoverageMap>;
+export declare function collectServerCoverageMap(coverageDataDir: string, cwd: string, testFiles: Set<string>): Promise<CoverageMap | null>;
+export declare function collectCoverageMapFromPlaywright(entries: V8CoverageEntry[], rootDir: string, testFiles: Set<string>, resolveRelativePath: (url: string) => Promise<string | null>): Promise<CoverageMap | null>;
+export declare function generateCombinedCoverageReport(maps: (CoverageMap | null | undefined)[], cwd: string, config: CoverageConfig): Promise<boolean>;
+//# sourceMappingURL=coverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/lib/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAsCnF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,KAAK,CAAC;QACf,YAAY,EAAE,MAAM,CAAA;QACpB,eAAe,EAAE,OAAO,CAAA;QACxB,MAAM,EAAE,KAAK,CAAC;YAAE,WAAW,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACzE,CAAC,CAAA;CACH;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAmI9D,wBAAsB,wBAAwB,CAC5C,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAuD7B;AAED,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,mBAAmB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAC3D,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA2C7B;AAED,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACxC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,OAAO,CAAC,CAelB"}

package/dist/lib/coverage.js

@@ -0,0 +1,212 @@
+import * as fsp from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { colors } from "./colors.js";
+import { transformTypeScript } from "./ts-transform.js";
+// Istanbul packages are loaded lazily so that FORCE_COLOR can be set based on
+// the actual TTY state before supports-color caches its detection result.
+let _istanbul;
+function getIstanbul() {
+    if (!_istanbul) {
+        process.env.FORCE_COLOR ??= process.stdout.isTTY ? '1' : '0';
+        let require = createRequire(import.meta.url);
+        _istanbul = {
+            V8ToIstanbul: require('v8-to-istanbul'),
+            createCoverageMap: require('istanbul-lib-coverage').createCoverageMap,
+            createContext: require('istanbul-lib-report')
+                .createContext,
+            reports: require('istanbul-reports'),
+        };
+    }
+    return _istanbul;
+}
+function matchesGlobs(filePath, globs) {
+    return globs.some((glob) => path.matchesGlob(filePath, glob));
+}
+function filterCoverageMap(coverageMap, cwd, config) {
+    let filtered = getIstanbul().createCoverageMap({});
+    for (let filePath of coverageMap.files()) {
+        let relative = path.relative(cwd, filePath);
+        if (config.include && config.include.length > 0) {
+            if (!matchesGlobs(relative, config.include))
+                continue;
+        }
+        if (config.exclude && config.exclude.length > 0) {
+            if (matchesGlobs(relative, config.exclude))
+                continue;
+        }
+        let fc = coverageMap.fileCoverageFor(filePath);
+        filtered.addFileCoverage({ ...fc.toJSON(), path: relative });
+    }
+    return filtered;
+}
+function checkThresholds(coverageMap, config) {
+    let { statements, lines, branches, functions } = config;
+    if (statements === undefined &&
+        lines === undefined &&
+        branches === undefined &&
+        functions === undefined)
+        return true;
+    let summary = coverageMap.getCoverageSummary();
+    let passed = true;
+    if (statements !== undefined) {
+        let pct = summary.statements.pct;
+        if (pct < statements) {
+            console.error(colors.red(`\nError: Coverage threshold not met (statements ${pct.toFixed(2)}% < ${statements}%)`));
+            passed = false;
+        }
+    }
+    if (lines !== undefined) {
+        let pct = summary.lines.pct;
+        if (pct < lines) {
+            console.error(colors.red(`\nError: Coverage threshold not met (lines ${pct.toFixed(2)}% < ${lines}%)`));
+            passed = false;
+        }
+    }
+    if (branches !== undefined) {
+        let pct = summary.branches.pct;
+        if (pct < branches) {
+            console.error(colors.red(`\nError: Coverage threshold not met (branches ${pct.toFixed(2)}% < ${branches}%)`));
+            passed = false;
+        }
+    }
+    if (functions !== undefined) {
+        let pct = summary.functions.pct;
+        if (pct < functions) {
+            console.error(colors.red(`\nError: Coverage threshold not met (functions ${pct.toFixed(2)}% < ${functions}%)`));
+            passed = false;
+        }
+    }
+    return passed;
+}
+async function writeIstanbulReports(coverageMap, cwd, outDir) {
+    await fsp.mkdir(outDir, { recursive: true });
+    let { createContext, reports } = getIstanbul();
+    let ctx = createContext({ coverageMap, dir: outDir });
+    console.log('\nCoverage report:');
+    reports.create('text').execute(ctx);
+    reports.create('lcovonly').execute(ctx);
+    console.log(`\nLCOV coverage written to ${path.relative(cwd, path.join(outDir, 'lcov.info'))}`);
+}
+// Convert a single V8 coverage entry to Istanbul format and merge it into the
+// coverage map.
+//
+// V8 reports byte offsets against the JS bytes it actually instrumented. When
+// the entry already carries that source (Playwright's `coverage.stopJSCoverage`
+// returns it on each entry, including the inline source map), we hand it
+// straight to v8-to-istanbul so the offsets line up exactly. The server path
+// uses Node's `NODE_V8_COVERAGE` JSON, which doesn't include source — there we
+// re-derive by re-running our esbuild transform on the original TS file.
+async function addV8EntryToCoverageMap(coverageMap, filePath, functions, source) {
+    let { V8ToIstanbul } = getIstanbul();
+    let converter = new V8ToIstanbul(filePath, undefined, { source });
+    await converter.load();
+    converter.applyCoverage(functions);
+    coverageMap.merge(converter.toIstanbul());
+    return true;
+}
+function shouldExcludeFromCoverage(filePath, rootDir, testFiles) {
+    return (!filePath.startsWith(rootDir + path.sep) ||
+        filePath.includes(`${path.sep}node_modules${path.sep}`) ||
+        testFiles.has(filePath));
+}
+export async function collectServerCoverageMap(coverageDataDir, cwd, testFiles) {
+    let { createCoverageMap } = getIstanbul();
+    let coverageMap = createCoverageMap({});
+    let converted = 0;
+    let files;
+    try {
+        files = (await fsp.readdir(coverageDataDir)).filter((f) => f.startsWith('coverage-') && f.endsWith('.json'));
+    }
+    catch {
+        return null;
+    }
+    for (let file of files) {
+        let data = JSON.parse(await fsp.readFile(path.join(coverageDataDir, file), 'utf-8'));
+        let scriptCoverages = data.result ?? [];
+        for (let entry of scriptCoverages) {
+            if (!entry.url.startsWith('file://'))
+                continue;
+            let filePath;
+            try {
+                filePath = fileURLToPath(entry.url);
+            }
+            catch {
+                continue;
+            }
+            if (!filePath ||
+                !['.ts', '.tsx'].includes(path.extname(filePath)) ||
+                shouldExcludeFromCoverage(filePath, cwd, testFiles)) {
+                continue;
+            }
+            try {
+                // For server unit tests, we transform the TS with a module loader and V8 tracks
+                // coverage using byte offsets from the transformed JS. Re-transform with the
+                // same `esbuild` call here so offsets align, then pass the result with its
+                // inline source map to v8-to-istanbul.
+                let tsSource = await fsp.readFile(filePath, 'utf-8');
+                let { code } = await transformTypeScript(tsSource, filePath);
+                let success = await addV8EntryToCoverageMap(coverageMap, filePath, entry.functions, code);
+                if (success)
+                    converted++;
+            }
+            catch (e) {
+                // Skip files that can't be converted
+            }
+        }
+    }
+    // Clean up raw V8 coverage JSON files now that we've processed them
+    //await Promise.all(files.map((f) => fsp.rm(path.join(coverageDataDir, f), { force: true })))
+    return converted > 0 ? coverageMap : null;
+}
+export async function collectCoverageMapFromPlaywright(entries, rootDir, testFiles, resolveRelativePath) {
+    let { createCoverageMap } = getIstanbul();
+    let coverageMap = createCoverageMap({});
+    let converted = 0;
+    for (let entry of entries) {
+        let filePath;
+        try {
+            let relativePath = await resolveRelativePath(new URL(entry.url).pathname);
+            if (!relativePath)
+                continue;
+            // Ignore entries outside the root dir, entries in node_modules, and test files
+            filePath = path.resolve(rootDir, relativePath);
+            if (shouldExcludeFromCoverage(filePath, rootDir, testFiles)) {
+                continue;
+            }
+            // Ensure file exists
+            await fsp.access(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (!entry.source) {
+            throw new Error(`Entry for ${entry.url} is missing source, cannot convert coverage. Ensure the browser launched with Playwright's JS coverage enabled.`);
+        }
+        try {
+            let success = await addV8EntryToCoverageMap(coverageMap, filePath, entry.functions, entry.source);
+            if (success)
+                converted++;
+        }
+        catch {
+            // Skip files that can't be converted
+        }
+    }
+    return converted > 0 ? coverageMap : null;
+}
+export async function generateCombinedCoverageReport(maps, cwd, config) {
+    let { createCoverageMap } = getIstanbul();
+    let combined = createCoverageMap({});
+    for (let map of maps) {
+        if (map)
+            combined.merge(map);
+    }
+    if (combined.files().length === 0) {
+        console.log('No coverage data collected.');
+        return true;
+    }
+    let filtered = filterCoverageMap(combined, cwd, config);
+    await writeIstanbulReports(filtered, cwd, config.dir);
+    return checkThresholds(filtered, config);
+}

package/dist/lib/executor.d.ts

@@ -1,27 +1,4 @@
-import type { Browser, BrowserContextOptions } from 'playwright';
-import type { CreateServerFunction } from './e2e-server.ts';
-export interface TestResult {
-    name: string;
-    suiteName: string;
-    filePath?: string;
-    status: 'passed' | 'failed' | 'skipped' | 'todo';
-    error?: {
-        message: string;
-        stack?: string;
-    };
-    duration: number;
-}
-export interface TestResults {
-    passed: number;
-    failed: number;
-    skipped: number;
-    todo: number;
-    tests: TestResult[];
-}
-export declare function runTests(options?: {
-    createServer?: CreateServerFunction;
-    browser?: Browser;
-    open?: boolean;
-    playwrightPageOptions?: BrowserContextOptions;
-}): Promise<TestResults>;
+import { type CreateTestContextOptions } from './context.ts';
+import type { TestResults } from './reporters/results.ts';
+export declare function runTests(options?: Omit<CreateTestContextOptions, 'addE2ECoverageEntries'>): Promise<TestResults>;
 //# sourceMappingURL=executor.d.ts.map