e2e 0.16.0 → 0.18.0

package/dist/config/esm-hooks.js

@@ -1,57 +1,64 @@
 /**
- * Module customization hook: the TypeScript a project owns is ESM, whatever
- * the nearest package.json says, and a module graph loaded afresh stays
- * fresh down every path import.
+ * e2e's TypeScript loader: synchronous module customization hooks
+ * (`module.registerHooks`) that run config, test, and helper TypeScript and
+ * JSX on Node.js, for `import` and `require` alike. `compiled-files.ts` says
+ * which files it compiles and which tsconfig.json governs them.
  *
- * Config and tests load through tsx's ESM API. tsx types a `.ts` file by its
- * package scope and hands a CommonJS-scoped one to Node's require, which that
- * API never hooks, so the import fails as "cannot find module" on a path that
- * carries e2e's cache-busting query. Registered before tsx, this hook runs
- * inside tsx's chain: tsx's resolve receives `format: 'module'` from it and
- * transforms the file as ESM. A Next.js app, or any package without
- * `"type": "module"`, keeps its module type.
+ * Resolve: an import written in a compiled file follows TypeScript's rules;
+ * every other import, JavaScript's included, resolves as Node.js resolves it.
+ * - A relative or absolute path: `./x.js` names the first of `x.ts`,
+ *   `x.tsx`, `x.js`, and `x.jsx` that exists (`./x.jsx` tries `x.tsx`, `x.ts`,
+ *   `x.jsx`, `x.js`; `./x.mjs` names `x.mts`, `./x.cjs` names `x.cts`), an
+ *   extensionless `./x` names `x.ts`, `x.tsx`, `x.js`, `x.jsx`, or `x.json`,
+ *   and a directory names its index the same way.
+ * - A bare specifier the project's tsconfig.json maps through `paths` or
+ *   `baseUrl` names the mapped file, before any package of that name.
+ * - A `#` import or package export that names a missing `./x.js` (or `.jsx`,
+ *   `.mjs`, `.cjs`) names the TypeScript file behind it, for an `import`.
  *
- * Forced: a file reached by path (the entry file URL, `./helper.ts`, and
- * tsconfig `paths` aliases, which tsx maps to `file:` URLs on every platform
- * before calling this hook), and TypeScript a bare or `#` specifier resolves
- * to outside `node_modules` from a module tsx loads for e2e: a workspace
- * package that exports its `.ts` source, the monorepo pattern, would
- * otherwise hit the same dead end. A module Node loads itself, such as one a
- * `.cjs` helper requires, keeps its format, so Node strips its types; forced
- * to ESM there, nothing would. An installed package under `node_modules`
- * keeps the format its own manifest declares; `.cts` files stay CommonJS.
+ * Format: `.ts`, `.mts`, `.tsx`, and `.jsx` are ES modules wherever they are
+ * and whatever the nearest package.json says, so a Next.js app, or any
+ * package without `"type": "module"`, keeps its module type and still runs
+ * its TypeScript tests, whether it is imported or a CommonJS file requires it;
+ * `.cts` is CommonJS. A JSON file imported without `with { type: 'json' }`
+ * loads as a module whose default export is the parsed file.
  *
- * A module imported with the `e2e-graph` query parameter hands it on to every
- * file it reaches by path or `#` import outside `node_modules`, so the project's own graph
- * (a config and the base config or targets file it imports) evaluates afresh
- * with it, while packages stay one shared instance.
+ * Freshness: a module imported with the `e2e-graph` query parameter hands it
+ * on to every file it reaches by path or `#` import outside `node_modules`,
+ * so the project's own graph (a config and the base config or targets file
+ * it imports) evaluates afresh with it, while packages stay one shared
+ * instance. The graph's tsconfig.json and file lookups are its own too
+ * (`tsconfig.ts`).
+ *
+ * This module, and everything it imports from e2e, is loaded by Node.js's
+ * own type stripping when a worker runs from source (`register.ts`), so it
+ * holds to erasable TypeScript: no enums, namespaces, or parameter
+ * properties.
  */
-import { pathToFileURL } from 'node:url';
-const TYPESCRIPT_MODULE = /\.(?:ts|mts|tsx)$/;
-const PATH_SPECIFIER = /^(?:\.{1,2}\/|\/|file:)/;
-/** A file inside an installed package. */
-const INSTALLED = /\/node_modules\//;
-/** The tsx namespace e2e registers; tsx tags every URL it loads with it. */
-export const TSX_NAMESPACE = 'e2e';
+import { readFileSync } from 'node:fs';
+import nodeModule, {} from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { InfrastructureError } from '../internal/errors.js';
+import { unsupportedRuntimeMessage } from '../internal/node-version.js';
+import { realmSlot } from '../internal/realm-slot.js';
+import { compiledSource, HOOKED_REQUIRE_KEY, IMPLIED_EXTENSIONS, isProjectFile, writtenCandidates } from './compiled-files.js';
+import { isPathSpecifier, pathTarget } from './specifiers.js';
+import { projectView } from './tsconfig.js';
+import { compileTypeScript } from './typescript.js';
+/** A URL scheme other than `file:` (`node:`, `data:`, `https:`); never a tsconfig alias. */
+const URL_SCHEME = /^[a-z][\d+.a-z-]*:/i;
 /** The query parameter a fresh module graph carries on every project file. */
 const GRAPH_PARAM = 'e2e-graph';
-/** How `specifier` reaches its file. */
+/** How `specifier`, as written, reaches its file. */
 function reach(specifier) {
-    if (PATH_SPECIFIER.test(specifier))
+    if (isPathSpecifier(specifier, false))
         return 'path';
     return specifier.startsWith('#') ? 'own-imports' : 'package';
 }
-/** A file the project owns: a `file:` URL outside `node_modules`. */
-function projectFile(url) {
-    if (!url.startsWith('file:'))
-        return undefined;
-    const parsed = new URL(url);
-    return INSTALLED.test(parsed.pathname) ? undefined : parsed;
-}
-/** A query parameter of the importing module's URL. */
-function parentParam(context, name) {
-    const { parentURL } = context;
-    return parentURL?.startsWith('file:') === true ? new URL(parentURL).searchParams.get(name) : null;
+/** The `e2e-graph` value of a module URL: the fresh graph it belongs to, or null. */
+function graphOf(url) {
+    return url?.startsWith('file:') === true ? new URL(url).searchParams.get(GRAPH_PARAM) : null;
 }
 /**
  * A URL that evaluates `absolutePath` afresh under `key`; with `graph`,
@@ -64,19 +71,80 @@ export function freshModuleURL(absolutePath, key, graph) {
         url.searchParams.set(GRAPH_PARAM, key);
     return url.href;
 }
+/** The first of `candidates` that is a file. */
+function firstFile(candidates, view) {
+    return candidates.find((candidate) => view.isFile(candidate));
+}
+/** The TypeScript file behind `target`'s written extension (`x.ts` for `x.js`), or the file as written. */
+function swappedFile(target, view) {
+    const extension = path.extname(target);
+    const stem = target.slice(0, target.length - extension.length);
+    return firstFile(writtenCandidates(extension).map((candidate) => `${stem}${candidate}`), view);
+}
+/** The `main` a directory's package.json names, as a path, or undefined. */
+function directoryMain(directory, view) {
+    const manifest = path.join(directory, 'package.json');
+    if (!view.isFile(manifest))
+        return undefined;
+    let main;
+    try {
+        ({ main } = JSON.parse(readFileSync(manifest, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+    return typeof main === 'string' && main !== '' ? path.resolve(directory, main) : undefined;
+}
 /**
- * The resolution, with TypeScript marked as an ES module when it is reached
- * by path, or is a project file reached any other way from a module tsx
- * loads under e2e's namespace.
+ * The file an import of the path `target` names under TypeScript's rules:
+ * the TypeScript file behind a written extension, the file itself, the file
+ * an extensionless path leaves out, or for a directory the file its
+ * package.json `main` names, else its index.
  */
-export function asModule(specifier, context, resolution) {
-    if (resolution.format === 'module' || resolution.format === 'module-typescript')
-        return resolution;
-    if (!resolution.url.startsWith('file:') || !TYPESCRIPT_MODULE.test(new URL(resolution.url).pathname))
-        return resolution;
-    const forced = reach(specifier) === 'path' ||
-        (projectFile(resolution.url) !== undefined && parentParam(context, 'tsx-namespace') === TSX_NAMESPACE);
-    return forced ? { ...resolution, format: 'module' } : resolution;
+function typeScriptFile(target, view) {
+    if (writtenCandidates(path.extname(target)).length > 0)
+        return swappedFile(target, view);
+    if (view.isFile(target))
+        return target;
+    const implied = firstFile(IMPLIED_EXTENSIONS.map((extension) => `${target}${extension}`), view);
+    if (implied !== undefined)
+        return implied;
+    const main = directoryMain(target, view);
+    const fromMain = main === undefined || main === target ? undefined : typeScriptFile(main, view);
+    return fromMain ?? firstFile(IMPLIED_EXTENSIONS.map((extension) => `${path.join(target, 'index')}${extension}`), view);
+}
+/**
+ * The file an import written in `importer` names under TypeScript's rules,
+ * when that is not what Node.js would resolve: a path (`./x.js`, `./x`,
+ * `./dir`), or a bare specifier the project's tsconfig maps.
+ */
+function typeScriptTarget(specifier, importer, requiring, view) {
+    const byPath = pathTarget(specifier, importer.file, requiring);
+    if (byPath !== undefined) {
+        const file = typeScriptFile(byPath.file, view);
+        return file === undefined || file === byPath.file ? undefined : { file, suffix: byPath.suffix };
+    }
+    if (!importer.project || specifier.startsWith('#') || URL_SCHEME.test(specifier) || nodeModule.isBuiltin(specifier))
+        return undefined;
+    for (const candidate of view.tsconfigFor(importer.file)?.paths?.(specifier) ?? []) {
+        const file = typeScriptFile(candidate, view);
+        if (file !== undefined)
+            return { file, suffix: '' };
+    }
+    return undefined;
+}
+/** Whether `context` is a `require()`, whose resolver takes paths where `import` takes `file:` URLs. */
+function requires(context) {
+    return context.conditions.includes('require');
+}
+/** `target` as a specifier the resolver behind `context` accepts. */
+function targetSpecifier(target, context) {
+    return requires(context) ? target.file : `${pathToFileURL(target.file).href}${target.suffix}`;
+}
+/** The resolution, with a compiled file's format set to the one the loader compiles it for. */
+function withFormat(resolution) {
+    const format = compiledSource(resolution.url)?.kind.format;
+    return format === undefined || resolution.format === format ? resolution : { ...resolution, format };
 }
 /**
  * The resolution, joined to its importer's fresh graph: a project file
@@ -85,17 +153,124 @@ export function asModule(specifier, context, resolution) {
  * instance, even a workspace package that resolves outside `node_modules`: a
  * second instance of it would import a second instance of e2e itself.
  */
-export function inGraph(specifier, context, resolution) {
-    if (reach(specifier) === 'package')
+function inGraph(how, parentURL, resolution) {
+    if (how === 'package' || !resolution.url.startsWith('file:'))
         return resolution;
-    const graph = parentParam(context, GRAPH_PARAM);
-    const file = projectFile(resolution.url);
-    if (graph === null || file === undefined || file.searchParams.has(GRAPH_PARAM))
+    const graph = graphOf(parentURL);
+    const file = new URL(resolution.url);
+    if (graph === null || !isProjectFile(file) || file.searchParams.has(GRAPH_PARAM))
         return resolution;
     file.searchParams.set(GRAPH_PARAM, graph);
     return { ...resolution, url: file.href };
 }
-/** For `module.registerHooks`. */
-export const resolveSync = (specifier, context, nextResolve) => inGraph(specifier, context, asModule(specifier, context, nextResolve(specifier, context)));
-/** For `module.register`, which reads this export from the hook module. */
-export const resolve = async (specifier, context, nextResolve) => inGraph(specifier, context, asModule(specifier, context, await nextResolve(specifier, context)));
+/** The file TypeScript's rules find for `missing`, a target URL that is not on disk, as a URL with the target's query and hash. */
+function typeScriptFileFor(missing, view) {
+    const target = fileURLToPath(missing);
+    const file = typeScriptFile(target, view);
+    // The file keeps the target's query and hash, which are part of its module identity.
+    return file === undefined || file === target ? undefined : `${pathToFileURL(file).href}${missing.search}${missing.hash}`;
+}
+/**
+ * The resolution of `request`, a `#` import or package export written in a
+ * compiled file, moved to the file TypeScript's rules find when the target
+ * the map names is not there (`x.ts` for a mapped `./x.js` or `./x`, a
+ * directory's index). Node.js throws for such a target, naming it on the
+ * error of an `import` (not of a `require()`); a resolver earlier in the
+ * chain may return it anyway (Yarn PnP's does), to fail when it loads.
+ */
+function resolveExport(request, context, nextResolve, view) {
+    let resolution;
+    try {
+        resolution = nextResolve(request, context);
+    }
+    catch (error) {
+        const { code, url } = error;
+        const file = code === 'ERR_MODULE_NOT_FOUND' && typeof url === 'string' && url.startsWith('file:') ? typeScriptFileFor(new URL(url), view) : undefined;
+        if (file === undefined)
+            throw error;
+        return nextResolve(file, context);
+    }
+    if (!resolution.url.startsWith('file:'))
+        return resolution;
+    const target = new URL(resolution.url);
+    const file = view.isFile(fileURLToPath(target)) ? undefined : typeScriptFileFor(target, view);
+    return file === undefined ? resolution : nextResolve(requires(context) ? fileURLToPath(file) : file, context);
+}
+export const resolve = (specifier, context, nextResolve) => {
+    const importer = compiledSource(context.parentURL);
+    // Only an import written in a compiled file looks at the project's files.
+    const view = importer === undefined ? undefined : projectView(graphOf(context.parentURL));
+    const target = importer === undefined || view === undefined ? undefined : typeScriptTarget(specifier, importer, requires(context), view);
+    const how = target === undefined ? reach(specifier) : 'path';
+    const request = target === undefined ? specifier : targetSpecifier(target, context);
+    const resolution = withFormat(view !== undefined && how !== 'path' ? resolveExport(request, context, nextResolve, view) : nextResolve(request, context));
+    // CommonJS caches modules by file, with no query to make one fresh.
+    return requires(context) ? resolution : inGraph(how, context.parentURL, resolution);
+};
+export const load = (url, context, nextLoad) => {
+    const source = compiledSource(url);
+    if (source !== undefined) {
+        const { format } = source.kind;
+        const loaded = nextLoad(url, { ...context, format });
+        const compilerOptions = source.project ? (projectView(graphOf(url)).tsconfigFor(source.file)?.compilerOptions ?? {}) : {};
+        return { format, source: compileTypeScript(source.file, text(loaded.source, source.file), source.kind, compilerOptions), shortCircuit: true };
+    }
+    // A require() has no import attributes, whatever the hook types say.
+    if (url.startsWith('file:') && path.extname(new URL(url).pathname) === '.json' && !requires(context) && context.importAttributes?.type === undefined) {
+        const loaded = nextLoad(url, { ...context, format: 'json', importAttributes: { ...context.importAttributes, type: 'json' } });
+        return { format: 'module', source: `export default JSON.parse(${JSON.stringify(text(loaded.source, fileURLToPath(url)))});\n`, shortCircuit: true };
+    }
+    return nextLoad(url, context);
+};
+/**
+ * Module source as text, a byte order mark dropped, whichever form the next
+ * hook returned it in. A hook may hand CommonJS on with no source at all,
+ * for Node.js's CommonJS loader to read (Yarn PnP's does); the loader reads
+ * the file itself then, as that loader would.
+ */
+function text(source, file) {
+    if (source === undefined || source === null)
+        return readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+    return typeof source === 'string' ? source.replace(/^\uFEFF/, '') : new TextDecoder().decode(source);
+}
+/**
+ * `require` for the CommonJS module at `filename`, for compiled CommonJS on
+ * a Node.js whose `require` in a CommonJS module an ES module imported skips
+ * resolve hooks (`typescript.ts`). Its `resolve` runs this module's resolve
+ * hook itself: before nodejs/node#62028 (24.15.0; not in Node.js 22),
+ * `require.resolve` skips module hooks even on a `require` from
+ * `module.createRequire`.
+ */
+function hookedRequire(filename) {
+    const base = nodeModule.createRequire(filename);
+    const parentURL = pathToFileURL(filename).href;
+    const resolveRequest = (request, options) => {
+        const { url } = resolve(request, { conditions: ['require', 'node'], importAttributes: {}, parentURL }, (next) => {
+            const resolved = base.resolve(next, options);
+            return { url: nodeModule.isBuiltin(resolved) ? resolved : pathToFileURL(resolved).href };
+        });
+        return url.startsWith('file:') ? fileURLToPath(url) : url;
+    };
+    const hooked = ((request) => base(request));
+    return Object.assign(hooked, base, { resolve: Object.assign(resolveRequest, { paths: base.resolve.paths }) });
+}
+/** Marks the process whose module loader already runs these hooks, whichever copy of e2e registered them. */
+const registration = realmSlot('e2e.typescript-loader.v1');
+/** Where compiled CommonJS finds `hookedRequire`. */
+const hookedRequireSlot = realmSlot(HOOKED_REQUIRE_KEY);
+/**
+ * Registers the hooks once per process, and has stack traces follow the
+ * source maps the compiled files carry. Refuses a Node.js whose module hooks
+ * the loader cannot rely on (`node-version.ts`).
+ */
+export function registerLoader() {
+    if (registration.get(globalThis) === true)
+        return;
+    const unsupported = unsupportedRuntimeMessage();
+    if (unsupported !== undefined)
+        throw new InfrastructureError('NODE_UNSUPPORTED', unsupported);
+    nodeModule.registerHooks({ resolve, load });
+    registration.set(globalThis, true);
+    hookedRequireSlot.set(globalThis, hookedRequire);
+    process.setSourceMapsEnabled(true);
+}

package/dist/config/load.d.ts

@@ -18,12 +18,6 @@ export declare function discoverConfig(cwd: string, explicitPath?: string): Disc
  * never for a supplied config value.
  */
 export declare function missingConfigError(cwd: string): ConfigurationError;
-/**
- * Whether tsx registers synchronous hooks on this Node.js. Hook chains only
- * compose within a kind, so e2e's hook has to be registered the same way.
- * A TypeScript `--import` in NODE_OPTIONS makes tsx fall back to async hooks.
- */
-export declare function tsxUsesSyncHooks(version?: string, hasRegisterHooks?: boolean, nodeOptions?: string): boolean;
 export interface ConfigLoadOptions {
     /**
      * Evaluates every project file the config reaches by path or `#` import
@@ -38,7 +32,7 @@ export interface ConfigLoadOptions {
     readonly graph?: boolean | undefined;
 }
 /**
- * Imports a TypeScript/ESM module with erasable-syntax support. Every call
+ * Imports a TypeScript or JavaScript module through e2e's loader. Every call
  * evaluates the module file afresh: the query carries the caller's key (what
  * the instance is for) plus a process-unique sequence, so a realm never
  * receives another realm's instance of it and a second `run()` in one

package/dist/config/load.js

@@ -1,11 +1,17 @@
 /** Config discovery and ESM/TypeScript loading. */
+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 { existsSync } from 'node:fs';
-import nodeModule from 'node:module';
 import path from 'node:path';
-import { register } from 'tsx/esm/api';
-import { ConfigurationError, isForeignE2EError } from '../internal/errors.js';
+import { ConfigurationError, InfrastructureError, isE2EError } from '../internal/errors.js';
 import { explainModuleError } from './diagnose.js';
-import { freshModuleURL, resolveSync, TSX_NAMESPACE } from './esm-hooks.js';
+import { freshModuleURL, registerLoader } from './esm-hooks.js';
 const CONFIG_NAMES = ['e2e.config.ts', 'e2e.config.mts'];
 /** Spellings a config author might reach for that the loader does not read. */
 const CONFIG_LOOKALIKES = [
@@ -67,64 +73,7 @@ export function missingConfigError(cwd) {
     return new ConfigurationError('CONFIG_NOT_FOUND', `${searched}; ${remedy}`);
 }
 /**
- * The process-wide TypeScript loader, registered on first use. `tsImport`
- * would register a fresh, never-removed loader hook per call - once per
- * collected file and once per realm, so every import would slow every later
- * one. One namespaced registration serves them all.
- */
-let loader;
-let imports = 0;
-/**
- * Node.js floors per major above which tsx registers synchronous hooks,
- * mirroring tsx 4.23.13's `supportsRegisterHooks`: `module.registerHooks`
- * exists and CommonJS can reload from a sync hook. Earlier releases, and
- * Node 23, get asynchronous hooks.
- */
-const TSX_SYNC_HOOK_FLOORS = [
-    [22, 22, 3],
-    [24, 11, 1],
-    [25, 1, 0],
-    [26, 0, 0],
-];
-/**
- * Whether tsx registers synchronous hooks on this Node.js. Hook chains only
- * compose within a kind, so e2e's hook has to be registered the same way.
- * A TypeScript `--import` in NODE_OPTIONS makes tsx fall back to async hooks.
- */
-export function tsxUsesSyncHooks(version = process.versions.node, hasRegisterHooks = typeof nodeModule.registerHooks === 'function', nodeOptions = process.env.NODE_OPTIONS ?? '') {
-    if (!hasRegisterHooks)
-        return false;
-    if (/(?:^|\s)--import(?:=|\s+)\S+\.(?:[cm]?ts|tsx)(?:[?#]\S*)?(?=\s|$)/.test(nodeOptions))
-        return false;
-    const [major = 0, minor = 0, patch = 0] = version.split('.').map(Number);
-    const last = TSX_SYNC_HOOK_FLOORS.length - 1;
-    const floor = TSX_SYNC_HOOK_FLOORS.find((entry, index) => index === last || entry[0] === major);
-    if (floor === undefined)
-        return false;
-    if (major !== floor[0])
-        return major > floor[0];
-    if (minor !== floor[1])
-        return minor > floor[1];
-    return patch >= floor[2];
-}
-/**
- * Registers e2e's ESM hook, then tsx. The last registered hook runs first, so
- * tsx's resolve calls e2e's and receives `format: 'module'` for project
- * TypeScript; see esm-hooks.ts.
- */
-function registerLoader() {
-    if (tsxUsesSyncHooks()) {
-        nodeModule.registerHooks({ resolve: resolveSync });
-    }
-    else {
-        // The sibling module with this module's own extension: .js in dist, .ts when
-        // tests run from source (tsc rewrites import specifiers, not URLs).
-        nodeModule.register(import.meta.url.replace(/load(\.[jt]s)$/, 'esm-hooks$1'));
-    }
-    return register({ namespace: TSX_NAMESPACE });
-}
-/**
- * Imports a TypeScript/ESM module with erasable-syntax support. Every call
+ * Imports a TypeScript or JavaScript module through e2e's loader. Every call
  * evaluates the module file afresh: the query carries the caller's key (what
  * the instance is for) plus a process-unique sequence, so a realm never
  * receives another realm's instance of it and a second `run()` in one
@@ -134,13 +83,17 @@ function registerLoader() {
 export async function importModule(absolutePath, cacheKey = 'module') {
     return importFresh(absolutePath, cacheKey, false);
 }
+/** Process-unique sequence that keeps every fresh import's URL distinct. */
+let imports = 0;
 async function importFresh(absolutePath, cacheKey, graph) {
     imports += 1;
-    loader ??= registerLoader();
-    return loader.import(freshModuleURL(absolutePath, `${cacheKey}-${imports}`, graph), import.meta.url);
+    registerLoader();
+    return import(__rewriteRelativeImportExtension(freshModuleURL(absolutePath, `${cacheKey}-${imports}`, graph)));
 }
 /** Loads and returns the raw default export of a config module. */
 export async function loadConfigModule(configPath, options = {}) {
+    // Outside the try: an unsupported Node.js is that, not a config that failed to load.
+    registerLoader();
     let moduleValue;
     try {
         moduleValue = await importFresh(configPath, 'module', options.graph === true);
@@ -149,11 +102,15 @@ export async function loadConfigModule(configPath, options = {}) {
         // A factory the config calls (web(), mobile()) or
         // `secrets.get()` refusing its options at evaluation is a config error
         // with its own code; only a failed import is a load failure.
-        if (cause instanceof ConfigurationError)
+        // So is the loader's own failure (oxc's native binding missing): the project's config is not at fault.
+        if (cause instanceof ConfigurationError || cause instanceof InfrastructureError)
             throw cause;
-        if (isForeignE2EError(cause) && cause.category === 'configuration') {
+        if (isE2EError(cause) && cause.category === 'configuration') {
             throw new ConfigurationError(cause.code, cause.message, { cause });
         }
+        if (isE2EError(cause) && cause.category === 'infrastructure') {
+            throw new InfrastructureError(cause.code, cause.message, { cause });
+        }
         throw new ConfigurationError('CONFIG_LOAD_FAILED', `failed to load config ${configPath}: ${explainModuleError(cause, configPath)}`, { cause });
     }
     const defaultExport = moduleValue.default;

package/dist/config/register.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Registers e2e's TypeScript loader as a side effect, for `node --import`:
+ * how a worker runs e2e from its TypeScript source in this repository
+ * (`run/worker/handle.ts`). Node.js loads this module and `esm-hooks.ts`
+ * with its own type stripping, before the loader exists, so they hold to
+ * erasable TypeScript.
+ */
+export {};

package/dist/config/register.js

@@ -0,0 +1,9 @@
+/**
+ * Registers e2e's TypeScript loader as a side effect, for `node --import`:
+ * how a worker runs e2e from its TypeScript source in this repository
+ * (`run/worker/handle.ts`). Node.js loads this module and `esm-hooks.ts`
+ * with its own type stripping, before the loader exists, so they hold to
+ * erasable TypeScript.
+ */
+import { registerLoader } from './esm-hooks.js';
+registerLoader();

package/dist/config/resolve.d.ts

@@ -34,6 +34,7 @@ export interface ResolvedConfig {
     readonly assertionTimeout: number;
     readonly cleanupTimeout: number;
     readonly retries: number;
+    readonly failOnSkippedFailure: boolean;
     readonly workers: number;
     /** Host store every produced artifact is handed to; undefined keeps files local only. */
     readonly artifactStore: ArtifactStore | undefined;

package/dist/config/resolve.js

@@ -25,6 +25,7 @@ const TOP_LEVEL_KEYS = new Set([
     'assertionTimeout',
     'cleanupTimeout',
     'retries',
+    'failOnSkippedFailure',
     'workers',
     'artifacts',
     'output',
@@ -111,6 +112,10 @@ export function resolveConfig(raw, options) {
     const workers = boundedInt(cli.workers, '--workers', 1, 1024) ??
         boundedInt(raw.workers, 'workers', 1, 1024) ??
         (ci ? 1 : Math.max(1, Math.floor(os.availableParallelism() / 2)));
+    const failOnSkippedFailure = raw.failOnSkippedFailure === undefined ? false : raw.failOnSkippedFailure;
+    if (typeof failOnSkippedFailure !== 'boolean') {
+        throw new ConfigurationError('INVALID_CONFIG', 'failOnSkippedFailure must be a boolean');
+    }
     const artifactStore = resolveArtifactStore(raw);
     const { reporters, customReporters } = resolveReporters(raw, cli);
     const projectId = resolveProjectId(raw.projectId, options.projectRoot);
@@ -134,6 +139,7 @@ export function resolveConfig(raw, options) {
         assertionTimeout,
         cleanupTimeout,
         retries,
+        failOnSkippedFailure,
         workers,
         artifactStore,
         output,
@@ -533,6 +539,8 @@ function resolveSecrets(raw, env) {
     const credentials = new Map();
     const secrets = new Map();
     const allSecrets = new Map();
+    checkEnvNameCollisions('E2E_USER', 'credentials', Object.keys(raw.credentials ?? {}));
+    checkEnvNameCollisions('E2E_SECRET', 'secrets', Object.keys(raw.secrets ?? {}));
     for (const [name, credential] of Object.entries(raw.credentials ?? {})) {
         const prefix = envName('E2E_USER', name);
         const username = env[`${prefix}_USERNAME`] ?? credential.username;
@@ -561,6 +569,29 @@ function resolveSecrets(raw, env) {
     }
     return { credentials, secrets, allSecrets };
 }
+/**
+ * Two entries of one namespace whose names map to the same override variable
+ * (`api-key` and `api_key` both read `E2E_SECRET_API_KEY`) would both take one
+ * rotated value, so the config load refuses them, whether or not the variable
+ * is set. The message names the entries and the variable, never a value.
+ */
+function checkEnvNameCollisions(prefix, namespace, names) {
+    const byEnvName = new Map();
+    for (const name of names) {
+        const variable = envName(prefix, name);
+        byEnvName.set(variable, [...(byEnvName.get(variable) ?? []), name]);
+    }
+    for (const [variable, group] of byEnvName) {
+        if (group.length < 2)
+            continue;
+        const quoted = group.map((name) => `"${name}"`);
+        const entries = `${quoted.slice(0, -1).join(', ')} and ${quoted.at(-1)}`;
+        const variables = prefix === 'E2E_USER'
+            ? `the override variables ${variable}_USERNAME and ${variable}_PASSWORD`
+            : `the override variable ${variable}`;
+        throw new ConfigurationError('INVALID_CONFIG', `${namespace} ${entries} share ${variables}, so one value set there would replace all of them; rename all but one`);
+    }
+}
 /**
  * Every secret an engine's options hold (a `secrets.get()` the config
  * evaluated before any run existed) names a configured secret, so a typo
@@ -643,9 +674,10 @@ function computeConfigDigest(raw, projectId, targets) {
     // reporter object changes nothing about what a run records, so it never
     // enters the digest either; the built-in ids digest as they always have,
     // so adding a reporter to a config leaves its cache valid.
+    // `failOnSkippedFailure` decides only the exit code, never what runs.
     // `targets` digest by declaration below and never enter the clone: an
     // engine holds `secrets.get()` handles, which refuse to serialize.
-    const { artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
+    const { failOnSkippedFailure: _failOnSkippedFailure, artifacts: _artifacts, output: _output, trace: _trace, video: _video, targets: _targets, credentials: _credentials, secrets: _secrets, agents, cache, reporters, ...plain } = raw;
     const sanitized = {
         ...structuredCloneJsonSafe(plain),
         ...(reporters === undefined

package/dist/config/specifiers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The file a relative or absolute specifier names. `import` takes URLs
+ * (`./x%20y.ts`, `file:///...`), `require()` takes paths in the platform's
+ * own form (`C:\app\helper` and `.\helper` on Windows), so the two read the
+ * same text differently.
+ */
+import path from 'node:path';
+/** A file a specifier names, with the query and hash an import URL carried. */
+export interface Target {
+    readonly file: string;
+    readonly suffix: string;
+}
+/** Whether `specifier` reaches its file by path for an `import` (a URL) or a `require()` (a path on `platform`). */
+export declare function isPathSpecifier(specifier: string, requires: boolean, platform?: typeof path): boolean;
+/**
+ * The file `specifier`, written in `importer`, names by path, or undefined
+ * for a specifier that is not a path.
+ */
+export declare function pathTarget(specifier: string, importer: string, requires: boolean, platform?: typeof path): Target | undefined;

package/dist/config/specifiers.js

@@ -0,0 +1,33 @@
+/**
+ * The file a relative or absolute specifier names. `import` takes URLs
+ * (`./x%20y.ts`, `file:///...`), `require()` takes paths in the platform's
+ * own form (`C:\app\helper` and `.\helper` on Windows), so the two read the
+ * same text differently.
+ */
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+/** A relative or absolute URL an `import` writes. */
+const IMPORT_PATH = /^(?:\.{1,2}\/|\/|file:)/i;
+/** Whether `specifier` reaches its file by path for an `import` (a URL) or a `require()` (a path on `platform`). */
+export function isPathSpecifier(specifier, requires, platform = path) {
+    if (!requires)
+        return IMPORT_PATH.test(specifier);
+    const separators = platform.sep === '\\' ? /^\.{1,2}(?:[\\/]|$)/ : /^\.{1,2}(?:\/|$)/;
+    return platform.isAbsolute(specifier) || separators.test(specifier);
+}
+/**
+ * The file `specifier`, written in `importer`, names by path, or undefined
+ * for a specifier that is not a path.
+ */
+export function pathTarget(specifier, importer, requires, platform = path) {
+    if (!isPathSpecifier(specifier, requires, platform))
+        return undefined;
+    if (requires)
+        return { file: platform.resolve(platform.dirname(importer), specifier), suffix: '' };
+    const windows = platform.sep === '\\';
+    const url = new URL(specifier, pathToFileURL(importer, { windows }));
+    const suffix = `${url.search}${url.hash}`;
+    url.search = '';
+    url.hash = '';
+    return { file: fileURLToPath(url, { windows }), suffix };
+}