@nx/playwright 23.2.0-beta.11 → 23.2.0-beta.12

package/dist/src/plugins/plugin.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = void 0;
+exports._clearWarnedUnparseableCommands = _clearWarnedUnparseableCommands;
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
@@ -8,7 +9,11 @@ const internal_2 = require("@nx/js/internal");
 const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const installed_playwright_1 = require("../utils/installed-playwright");
+const npm_config_proxy_1 = require("../utils/npm-config-proxy");
+const proxied_tls_verification_1 = require("../utils/proxied-tls-verification");
 const reporters_1 = require("../utils/reporters");
+const webserver_readiness_1 = require("./webserver-readiness");
 const playwrightConfigGlob = '**/playwright.config.{js,ts,cjs,cts,mjs,mts}';
 exports.createNodes = [
     playwrightConfigGlob,
@@ -20,13 +25,29 @@ exports.createNodes = [
         const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
         const lockFileName = (0, js_1.getLockFileName)(packageManager);
         const normalizedOptions = normalizeOptions(options);
+        // A config can read process.env, which no file hash covers (and which the
+        // daemon swaps per client). Key the cache on the daemon-allowed env set so
+        // an ambient change re-evaluates instead of serving stale targets.
+        const ambientEnvHash = (0, internal_1.hashDaemonClientEnv)();
+        const ambientEnvGeneration = (0, internal_1.getDaemonClientEnvGeneration)();
+        // The workspace-root dotenv candidates are the same for every config, so
+        // hash each file at most once per pass rather than once per config.
+        const dotEnvFileHashes = new Map();
         try {
             const { entries, preErrors } = await filterPlaywrightConfigs(configFilePaths, context);
-            const projectHashes = await (0, internal_1.calculateHashesForCreateNodes)(entries.map((e) => e.projectRoot), { ...normalizedOptions, CI: process.env.CI }, context, entries.map((e) => [lockFileName, ...e.externalTsconfigInputs]));
+            const projectHashes = await (0, internal_1.calculateHashesForCreateNodes)(entries.map((e) => e.projectRoot), { ...normalizedOptions, ambientEnvHash }, context, entries.map((e) => [lockFileName, ...e.externalTsconfigInputs]));
+            // A TypeScript config is `require`d without clearing the module cache, so
+            // a process that already evaluated it (the daemon, with plugin isolation
+            // off) gets that evaluation back: an edited config would keep its old
+            // targets and the env writes it makes while loading would not run again.
+            // Once per pass, so every config loads fresh.
+            if (entries.some((e) => require.cache[(0, node_path_1.join)(context.workspaceRoot, e.configFile)])) {
+                (0, internal_1.clearRequireCache)();
+            }
             let results = [];
             let nodeErrors = [];
             try {
-                results = await (0, devkit_1.createNodesFromFiles)((configFile, _, ctx, idx) => createNodesInternal(configFile, normalizedOptions, ctx, pluginCache, pmc, entries[idx].externalTsconfigInputs, projectHashes[idx]), entries.map((e) => e.configFile), options, context);
+                results = await (0, devkit_1.createNodesFromFiles)((configFile, _, ctx, idx) => createNodesInternal(configFile, normalizedOptions, ctx, pluginCache, pmc, entries[idx].externalTsconfigInputs, projectHashes[idx], dotEnvFileHashes), entries.map((e) => e.configFile), options, context);
             }
             catch (e) {
                 if (e instanceof devkit_1.AggregateCreateNodesError) {
@@ -44,17 +65,52 @@ exports.createNodes = [
             return results;
         }
         finally {
-            pluginCache.writeToDisk();
+            // The daemon can apply another client's env mid-pass (worker message
+            // dispatch is unserialized); entries built after that are keyed under
+            // the stale pass-start digest, so drop the write and let the next pass
+            // rebuild under a coherent key. The generation catches an env that
+            // changed and changed back mid-pass, which the digest misses.
+            if ((0, internal_1.getDaemonClientEnvGeneration)() === ambientEnvGeneration &&
+                (0, internal_1.hashDaemonClientEnv)() === ambientEnvHash) {
+                pluginCache.writeToDisk();
+            }
         }
     },
 ];
 exports.createNodesV2 = exports.createNodes;
-async function createNodesInternal(configFilePath, normalizedOptions, context, pluginCache, pmc, externalTsconfigInputs, hash) {
+async function createNodesInternal(configFilePath, normalizedOptions, context, pluginCache, pmc, externalTsconfigInputs, hash, dotEnvFileHashes) {
     const projectRoot = (0, node_path_1.dirname)(configFilePath);
-    if (!pluginCache.has(hash)) {
-        pluginCache.set(hash, await buildPlaywrightTargets(configFilePath, projectRoot, normalizedOptions, context, pmc, externalTsconfigInputs));
+    // The createNodes hash covers projectRoot files, the lockfile, and tsconfig,
+    // but a workspace-root dotenv a nested project loads is outside it. Fold the
+    // consumer chains' dotenv fingerprints into the cache key so a dotenv change
+    // rebuilds the inferred targets instead of returning stale ones.
+    const chainDotEnvPairs = getChainDotEnvPairs(context.workspaceRoot, projectRoot, normalizedOptions, dotEnvFileHashes);
+    // The gate follows the installed Playwright's probe semantics. A linked
+    // install can cross the version floor without touching the lockfile, so the
+    // key carries the decision rather than trusting the hash to notice.
+    const playwright = (0, installed_playwright_1.installedPlaywrightVersion)([
+        (0, node_path_1.join)(context.workspaceRoot, projectRoot),
+        context.workspaceRoot,
+    ]);
+    const legacyProxiedTls = (0, proxied_tls_verification_1.installedPlaywrightSkipsProxiedTls)(playwright);
+    const npmConfigProxy = (0, npm_config_proxy_1.installedPlaywrightReadsNpmConfigProxy)(playwright);
+    const cacheKey = `${hash}-${(0, internal_1.hashObject)({
+        chainDotEnvPairs,
+        legacyProxiedTls,
+        npmConfigProxy,
+    })}`;
+    let playwrightTargets = pluginCache.get(cacheKey);
+    if (!playwrightTargets) {
+        const { taskEnvEvalFailed, ...built } = await buildPlaywrightTargets(configFilePath, projectRoot, normalizedOptions, context, pmc, externalTsconfigInputs, chainDotEnvPairs, legacyProxiedTls, npmConfigProxy);
+        // The key encodes nothing about evaluation success, so caching a failed
+        // evaluation's gate-less fallback would make a transient failure (a
+        // timeout, a fork error) permanent; leave it out so the next pass retries.
+        if (!taskEnvEvalFailed) {
+            pluginCache.set(cacheKey, built);
+        }
+        playwrightTargets = built;
     }
-    const { targets, metadata } = pluginCache.get(hash);
+    const { targets, metadata } = playwrightTargets;
     return {
         projects: {
             [projectRoot]: {
@@ -65,12 +121,25 @@ async function createNodesInternal(configFilePath, normalizedOptions, context, p
         },
     };
 }
-async function buildPlaywrightTargets(configFilePath, projectRoot, options, context, pmc, externalTsconfigInputs) {
+async function buildPlaywrightTargets(configFilePath, projectRoot, options, context, pmc, externalTsconfigInputs, chainDotEnvPairs, legacyProxiedTls, npmConfigProxy) {
     // Playwright forbids importing the `@playwright/test` module twice. This would affect running the tests,
     // but we're just reading the config so let's delete the variable they are using to detect this.
     // See: https://github.com/microsoft/playwright/pull/11218/files
     delete process['__pw_initiator__'];
-    const playwrightConfig = await (0, internal_1.loadConfigFile)((0, node_path_1.join)(context.workspaceRoot, configFilePath));
+    // The reads happen inside the consume callback, before the load's env
+    // writes are restored: the config object can expose getters that read env
+    // it set while loading, so it must not escape the protected scope.
+    const { consumed: { testOutput, reporterOutputs, ambientWebServers, testDir: configTestDir, testMatch, testIgnore, }, probeEnv: ambientProbeEnv, ambientEnv, } = await (0, webserver_readiness_1.loadConfigWithProbeEnv)((0, node_path_1.join)(context.workspaceRoot, configFilePath), (config) => ({
+        testOutput: getTestOutput(config),
+        reporterOutputs: (0, reporters_1.getReporterOutputs)(config),
+        ambientWebServers: (0, webserver_readiness_1.normalizeWebServers)(config.webServer),
+        testDir: config.testDir,
+        // Playwright defaults to the following pattern.
+        testMatch: materializeTestPattern(config.testMatch ?? '**/*.@(spec|test).?(c|m)[jt]s?(x)'),
+        testIgnore: config.testIgnore
+            ? materializeTestPattern(config.testIgnore)
+            : undefined,
+    }));
     const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const tsconfigJsonInputs = externalTsconfigInputs.map((file) => ({
         json: `{workspaceRoot}/${file}`,
@@ -78,9 +147,46 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
     }));
     const targets = {};
     let metadata;
-    const testOutput = getTestOutput(playwrightConfig);
-    const reporterOutputs = (0, reporters_1.getReporterOutputs)(playwrightConfig);
-    const webserverCommandTasks = getWebserverCommandTasks(playwrightConfig);
+    // The readiness gate: Playwright's `reuseExistingServer` probe otherwise
+    // races the server boot, misses, and spawns its own nested server command
+    // whose I/O then leaks into the task.
+    //
+    // The command and address can read process.env, and createNodes runs without
+    // the task's dotenv loaded, so each consumer chain's servers resolve under
+    // that chain's task env. Chains whose tasks and gates load the same dotenv
+    // inputs share one resolution; distinct inputs resolve concurrently and can
+    // gate separately.
+    const gatesShareDotEnv = JSON.stringify(chainDotEnvPairs.gate) ===
+        JSON.stringify(chainDotEnvPairs.ciGate);
+    const chainsShareDotEnv = gatesShareDotEnv &&
+        JSON.stringify(chainDotEnvPairs.target) ===
+            JSON.stringify(chainDotEnvPairs.ciTarget);
+    const e2eGateName = `${options.targetName}--wait-for-webserver`;
+    const ciGateName = `${options.ciTargetName}--wait-for-webserver`;
+    let e2eResolved;
+    let ciResolved;
+    if (!options.ciTargetName || chainsShareDotEnv) {
+        e2eResolved = await resolveChainWebserver(configFilePath, projectRoot, context.workspaceRoot, ambientWebServers, ambientProbeEnv, ambientEnv, legacyProxiedTls, npmConfigProxy, options.targetName, undefined, e2eGateName, options.waitForWebServer);
+        ciResolved = e2eResolved;
+    }
+    else {
+        [e2eResolved, ciResolved] = await Promise.all([
+            resolveChainWebserver(configFilePath, projectRoot, context.workspaceRoot, ambientWebServers, ambientProbeEnv, ambientEnv, legacyProxiedTls, npmConfigProxy, options.targetName, undefined, e2eGateName, options.waitForWebServer),
+            resolveChainWebserver(configFilePath, projectRoot, context.workspaceRoot, ambientWebServers, ambientProbeEnv, ambientEnv, legacyProxiedTls, npmConfigProxy, options.ciTargetName, options.targetName, ciGateName, options.waitForWebServer),
+        ]);
+    }
+    const e2eChain = e2eResolved.chain;
+    const ciChain = ciResolved.chain;
+    const taskEnvEvalFailed = e2eResolved.taskEnvEvalFailed || ciResolved.taskEnvEvalFailed;
+    const e2eReadyTargetName = e2eChain.readinessServers.length > 0 ? e2eGateName : undefined;
+    // A shared gate runs under the e2e gate's dotenv, which the ci chain's probe
+    // env was only compared against when both gates load the same files.
+    const chainsShareGate = gatesShareDotEnv && sameChain(e2eChain, ciChain);
+    const ciReadyTargetName = ciChain.readinessServers.length > 0
+        ? chainsShareGate
+            ? e2eReadyTargetName
+            : ciGateName
+        : undefined;
     const baseTargetConfig = {
         command: 'playwright test',
         options: {
@@ -99,12 +205,7 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
             },
         },
     };
-    if (webserverCommandTasks.length) {
-        baseTargetConfig.dependsOn = getDependsOn(webserverCommandTasks);
-    }
-    else {
-        baseTargetConfig.parallelism = false;
-    }
+    applyChainDependsOn(baseTargetConfig, e2eChain, e2eReadyTargetName);
     targets[options.targetName] = {
         ...baseTargetConfig,
         cache: true,
@@ -117,6 +218,12 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
         ],
         outputs: getTargetOutputs(testOutput, reporterOutputs, context.workspaceRoot, projectRoot),
     };
+    if (e2eReadyTargetName) {
+        targets[e2eReadyTargetName] = buildWaitForWebserverTarget(e2eChain, options.webServerTimeout);
+    }
+    if (ciReadyTargetName && ciReadyTargetName !== e2eReadyTargetName) {
+        targets[ciReadyTargetName] = buildWaitForWebserverTarget(ciChain, options.webServerTimeout);
+    }
     if (options.ciTargetName) {
         // ensure the blob reporter output is the directory containing the blob
         // report files
@@ -135,19 +242,22 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
             ],
             outputs: getTargetOutputs(testOutput, ciReporterOutputs, context.workspaceRoot, projectRoot),
         };
+        // Unconditionally: the chains can differ in ways the shared-gate check
+        // deliberately ignores (an extra uncovered server flips parallelism), and
+        // re-deriving is a no-op when they match.
+        applyChainDependsOn(ciBaseTargetConfig, ciChain, ciReadyTargetName);
         const groupName = 'E2E (CI)';
         metadata = { targetGroups: { [groupName]: [] } };
         const ciTargetGroup = metadata.targetGroups[groupName];
-        const testDir = playwrightConfig.testDir
-            ? (0, devkit_1.joinPathFragments)(projectRoot, playwrightConfig.testDir)
+        const testDir = configTestDir
+            ? (0, devkit_1.joinPathFragments)(projectRoot, configTestDir)
             : projectRoot;
-        // Playwright defaults to the following pattern.
-        playwrightConfig.testMatch ??= '**/*.@(spec|test).?(c|m)[jt]s?(x)';
         const dependsOn = [];
         const testFiles = await getAllTestFiles({
             context,
             path: testDir,
-            config: playwrightConfig,
+            testMatch,
+            testIgnore,
         });
         for (const testFile of testFiles) {
             const outputSubfolder = (0, node_path_1.relative)(projectRoot, testFile)
@@ -161,7 +271,9 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
                         testFile,
                         testFiles,
                         context,
-                        config: playwrightConfig,
+                        testDir,
+                        testMatch,
+                        testIgnore,
                     }, null, 2)}`);
             }
             const targetName = `${options.ciTargetName}--${relativeSpecFilePath}`;
@@ -214,9 +326,11 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
                 },
             },
         };
-        if (!webserverCommandTasks.length) {
+        if (chainRequiresSerialization(ciChain)) {
             targets[options.ciTargetName].parallelism = false;
         }
+        // The gate stays out of the group: a group member runs under the atomized
+        // target's dotenv files, and the gate's env was checked against its own.
         ciTargetGroup.push(options.ciTargetName);
         // infer the task to merge the reports from the atomized tasks
         const mergeReportsTargetOutputs = new Set();
@@ -242,16 +356,24 @@ async function buildPlaywrightTargets(configFilePath, projectRoot, options, cont
         };
         ciTargetGroup.push(options.mergeReportsTargetName);
     }
-    return { targets, metadata };
+    return { targets, metadata, taskEnvEvalFailed };
 }
 async function getAllTestFiles(opts) {
     const files = await (0, internal_1.getFilesInDirectoryUsingContext)(opts.context.workspaceRoot, opts.path);
-    const matcher = createMatcher(opts.config.testMatch);
-    const ignoredMatcher = opts.config.testIgnore
-        ? createMatcher(opts.config.testIgnore)
+    const matcher = createMatcher(opts.testMatch);
+    const ignoredMatcher = opts.testIgnore
+        ? createMatcher(opts.testIgnore)
         : () => false;
     return files.filter((file) => matcher(file) && !ignoredMatcher(file));
 }
+// Copies a test file pattern off a just-loaded config: an array element or a
+// property can be a getter reading env the load wrote, so every read has to
+// happen before that env is restored, and a cloned RegExp leaves no
+// config-owned object behind.
+function materializeTestPattern(pattern) {
+    const clone = (p) => typeof p === 'string' ? p : new RegExp(p.source, p.flags);
+    return Array.isArray(pattern) ? Array.from(pattern, clone) : clone(pattern);
+}
 function createMatcher(pattern) {
     if (Array.isArray(pattern)) {
         const matchers = pattern.map((p) => createMatcher(p));
@@ -278,6 +400,7 @@ function normalizeOptions(options) {
         targetName: options?.targetName ?? 'e2e',
         ciTargetName,
         mergeReportsTargetName: `${ciTargetName}--merge-reports`,
+        waitForWebServer: options?.waitForWebServer ?? true,
     };
 }
 function getTestOutput(playwrightConfig) {
@@ -323,40 +446,269 @@ function addSubfolderToOutput(output, subfolder) {
     }
     return (0, devkit_1.joinPathFragments)(output, subfolder);
 }
-function getWebserverCommandTasks(playwrightConfig) {
-    if (!playwrightConfig.webServer) {
-        return [];
-    }
-    const tasks = [];
-    const webServer = Array.isArray(playwrightConfig.webServer)
-        ? playwrightConfig.webServer
-        : [playwrightConfig.webServer];
-    for (const server of webServer) {
+function getChainDotEnvPairs(workspaceRoot, projectRoot, options, fileHashes) {
+    const pairsFor = (target, nonAtomizedTarget) => getDotEnvPairsForTask(workspaceRoot, projectRoot, target, nonAtomizedTarget, fileHashes);
+    const target = pairsFor(options.targetName);
+    const gate = pairsFor(`${options.targetName}--wait-for-webserver`);
+    return {
+        target,
+        ciTarget: options.ciTargetName
+            ? pairsFor(options.ciTargetName, options.targetName)
+            : target,
+        gate,
+        ciGate: options.ciTargetName
+            ? pairsFor(`${options.ciTargetName}--wait-for-webserver`)
+            : gate,
+    };
+}
+function getDotEnvPairsForTask(workspaceRoot, projectRoot, target, nonAtomizedTarget, fileHashes) {
+    const pairs = [];
+    for (const file of (0, internal_1.getEnvPathsForTask)(projectRoot, target, undefined, nonAtomizedTarget)) {
+        let fileHash = fileHashes.get(file);
+        if (fileHash === undefined) {
+            fileHash = (0, internal_1.hashFile)((0, node_path_1.join)(workspaceRoot, file));
+            fileHashes.set(file, fileHash);
+        }
+        if (fileHash !== null) {
+            pairs.push([file, fileHash]);
+        }
+    }
+    return pairs.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+}
+// Resolves the web server command tasks and readiness servers a consumer chain
+// (`e2e` or the atomized `e2e-ci`) would see. A config with no ambient
+// `webServer` yields nothing to depend on or gate, so the task-env resolution
+// is skipped entirely: a `webServer` entry whose existence (not address)
+// depends on task-scoped env is not detected. Otherwise, when the chain's
+// task env differs from the graph-time ambient env, the config is re-evaluated
+// in a child under that env so an env-derived command or address resolves the
+// way the task will; a matching env reuses the ambient config. When
+// `inferReadiness` is false the gate is opted out: the resolved command tasks
+// still become dependencies, but no readiness servers are returned. A failed
+// re-evaluation falls back to the ambient servers and skips the gate for the
+// chain: an unverified address must not become a gate the daemon then caches,
+// but a config bug or timeout should degrade to master's behavior, not kill
+// graph construction for most commands. The returned `taskEnvEvalFailed` flag
+// keeps that degraded result out of the plugin cache so a later pass retries
+// the evaluation.
+async function resolveChainWebserver(configFilePath, projectRoot, workspaceRoot, ambientWebServers, ambientProbeEnv, ambientEnv, legacyProxiedTls, npmConfigProxy, target, nonAtomizedTarget, gateTarget, inferReadiness) {
+    if (ambientWebServers.length === 0) {
+        return {
+            chain: { commandTasks: [], readinessServers: [], uncoveredServers: 0 },
+            taskEnvEvalFailed: false,
+        };
+    }
+    let webServers = ambientWebServers;
+    let probeEnv = ambientProbeEnv;
+    let taskEnvEvalFailed = false;
+    // Base every env reconstruction on the locked ambient snapshot, never on the
+    // live process.env: another config's in-process load can be writing env
+    // concurrently, and a transient write read as ambient would mask the values
+    // this chain's dotenv files set.
+    const taskEnv = (0, internal_1.getGraphTimeDotEnvForTask)(projectRoot, target, undefined, nonAtomizedTarget, ambientEnv);
+    if ((0, webserver_readiness_1.taskEnvDivergesFromAmbient)(taskEnv, ambientEnv)) {
+        try {
+            ({ webServers, probeEnv } = await (0, webserver_readiness_1.resolveWebServersUnderEnv)(configFilePath, workspaceRoot, taskEnv));
+        }
+        catch (e) {
+            taskEnvEvalFailed = true;
+            const detail = e instanceof Error ? e.message : String(e);
+            (0, internal_1.emitPluginWorkerLog)('warn', `@nx/playwright: could not evaluate ${configFilePath} under the ${target} task env to resolve the web server address. Targets are inferred from the ambient config evaluation and no web server readiness task is inferred for ${target}.\n${detail}`);
+        }
+    }
+    const { commandTasks, uncoveredServers } = getWebserverCommandTasks(webServers, configFilePath);
+    let readinessServers = [];
+    if (inferReadiness && !taskEnvEvalFailed) {
+        readinessServers = commandTasks
+            .map(toReadinessServer)
+            .filter(Boolean);
+        // The gate runs as its own target under its own dotenv and never loads the
+        // config, so a change to the probe transport (a proxy exclusion, a CA
+        // bundle) the task's dotenv or its config makes never reaches it and the
+        // gate could fail where Playwright's own probe passes. The dependencies
+        // stay; readiness falls back to Playwright's probe. Node reads
+        // NODE_EXTRA_CA_CERTS once at startup, so the value the task starts with
+        // is the one its probe trusts, whatever the config writes.
+        const divergingProbeVars = (0, webserver_readiness_1.getProbeEnvDivergence)(readinessServers, { ...probeEnv, NODE_EXTRA_CA_CERTS: taskEnv.NODE_EXTRA_CA_CERTS }, (0, internal_1.getGraphTimeDotEnvForTask)(projectRoot, gateTarget, undefined, undefined, ambientEnv), legacyProxiedTls, npmConfigProxy);
+        if (divergingProbeVars.length > 0) {
+            readinessServers = [];
+            (0, internal_1.emitPluginWorkerLog)('warn', `@nx/playwright: under the ${target} task, ${divergingProbeVars.join(', ')} changes how its web server would be probed, which the readiness task cannot reproduce. No web server readiness task is inferred for ${target}.`);
+        }
+    }
+    return {
+        chain: { commandTasks, readinessServers, uncoveredServers },
+        taskEnvEvalFailed,
+    };
+}
+// Two chains share a gate only when both the readiness servers and the serve
+// command tasks (which become the gate's and the tasks' dependsOn) match.
+function sameChain(a, b) {
+    return (JSON.stringify(a.commandTasks) === JSON.stringify(b.commandTasks) &&
+        JSON.stringify(a.readinessServers) === JSON.stringify(b.readinessServers));
+}
+function buildWaitForWebserverTarget(chain, webServerTimeout) {
+    return {
+        executor: '@nx/playwright:wait-for-webserver',
+        cache: false,
+        options: {
+            servers: chain.readinessServers,
+            ...(webServerTimeout != null ? { timeout: webServerTimeout } : {}),
+        },
+        dependsOn: getDependsOn(chain.commandTasks),
+        metadata: {
+            technologies: ['playwright'],
+            description: 'Waits for the E2E web server(s) to be ready before the Playwright test tasks run.',
+        },
+    };
+}
+// One entry per (config, command) for the lifetime of the process: the two
+// chains and every graph recomputation re-derive the same tasks, and the
+// warning is about the config's content, not about any single run.
+const warnedUnparseableCommands = new Set();
+// Test seam: the warn-once set outlives a spec file's cases.
+function _clearWarnedUnparseableCommands() {
+    warnedUnparseableCommands.clear();
+}
+function getWebserverCommandTasks(webServers, configFilePath) {
+    const commandTasks = [];
+    let uncoveredServers = 0;
+    for (const server of webServers) {
         if (!server.reuseExistingServer) {
             continue;
         }
+        // An unchecked config can omit `command` (Playwright's own type requires
+        // it); nothing runs, so there is nothing to depend on or gate.
+        if (typeof server.command !== 'string') {
+            uncoveredServers++;
+            continue;
+        }
+        // Playwright races a `wait.stdout`/`wait.stderr` regex against the address
+        // probe and stores the match's named capture groups in the env, both tied
+        // to the process Playwright starts itself. A task-started server would be
+        // reused without them, or raced by a duplicate launch while it boots, so
+        // such a server gets no inferred dependency and no gate.
+        if (server.waitsForOutput) {
+            uncoveredServers++;
+            continue;
+        }
+        // A `webServer.env` only reaches the process Playwright starts itself. A
+        // task-started server would run without it, listening at a different
+        // address or silently reused missing the env the tests rely on, so only
+        // Playwright can launch such a server: no inferred dependency and no gate.
+        if (server.hasEnv) {
+            uncoveredServers++;
+            continue;
+        }
         const task = parseTaskFromCommand(server.command);
         if (task) {
-            tasks.push(task);
+            commandTasks.push({
+                ...task,
+                port: server.port,
+                url: server.url,
+                ignoreHTTPSErrors: server.ignoreHTTPSErrors,
+                timeout: server.timeout,
+            });
+        }
+        else {
+            uncoveredServers++;
+            // A command that never invokes nx (`npm run start`, `vite`) was never
+            // meant to map to a task, so its skip warrants no warning.
+            if (/(^|\s)nx(@\S+)?\s/.test(server.command)) {
+                const warnedKey = `${configFilePath}|${server.command}`;
+                if (!warnedUnparseableCommands.has(warnedKey)) {
+                    warnedUnparseableCommands.add(warnedKey);
+                    (0, internal_1.emitPluginWorkerLog)('warn', `@nx/playwright: could not infer an Nx task from the webServer command "${server.command}" in ${configFilePath}, so no serve dependency or readiness wait is inferred for it.`);
+                }
+            }
         }
     }
-    return tasks;
+    return { commandTasks, uncoveredServers };
+}
+// Playwright throws when `port` and `url` are both truthy, but a present
+// `port` (even 0) still selects its TCP-only probe, whose target comes from
+// the derived url rather than the option: the url's port for `port: 0` plus
+// `url`, and 0, which can never connect, when that url carries no explicit
+// port. An unchecked `playwright.config.js` can also carry a `port` Playwright
+// coerces but the readiness task can't probe. Gate only on the shapes the task
+// probes the same way; the rest is left to Playwright.
+function toReadinessServer(task) {
+    // The inferred dependency runs the target without the command's trailing
+    // `:configuration` (a task dependency cannot carry one), so the server it
+    // starts can listen at a different address than the configured one. Gating
+    // on that address would wait out the whole budget; leave readiness to
+    // Playwright's own probe instead.
+    if (task.hasConfiguration) {
+        return undefined;
+    }
+    let server;
+    if (typeof task.port === 'number' && task.port) {
+        server = { port: task.port };
+    }
+    else if (typeof task.url === 'string' &&
+        task.url &&
+        task.port === undefined) {
+        server = { url: task.url };
+    }
+    else {
+        return undefined;
+    }
+    if (task.ignoreHTTPSErrors) {
+        server.ignoreHTTPSErrors = true;
+    }
+    // Carry each server's own `webServer.timeout` (the budget Playwright waits
+    // for a server it starts) so a slow server is not cut short and a fast one
+    // is not given another server's budget. Guard the type like `port`/`url`
+    // above: an unchecked `.js` config can carry a non-number the gate task's
+    // schema would then reject at run time.
+    if (typeof task.timeout === 'number' && Number.isFinite(task.timeout)) {
+        server.timeout = task.timeout;
+    }
+    return server;
 }
 function parseTaskFromCommand(command) {
     const nxRunRegex = /^(?:(?:npx|yarn|bun|pnpm|pnpm exec|pnpx) )?nx run (\S+:\S+)$/;
     const infixRegex = /^(?:(?:npx|yarn|bun|pnpm|pnpm exec|pnpx) )?nx (\S+ \S+)$/;
     const nxRunMatch = command.match(nxRunRegex);
     if (nxRunMatch) {
-        const [project, target] = nxRunMatch[1].split(':');
-        return { project, target };
+        // Truthiness rather than `!== undefined`: a trailing colon (`app:serve:`)
+        // splits to an empty configuration, which behaves as none.
+        const [project, target, configuration] = nxRunMatch[1].split(':');
+        return { project, target, hasConfiguration: !!configuration };
     }
     const infixMatch = command.match(infixRegex);
     if (infixMatch) {
         const [target, project] = infixMatch[1].split(' ');
-        return { project, target };
+        return { project, target, hasConfiguration: false };
     }
     return null;
 }
+// Whether tasks consuming the chain's servers must not run in parallel: with
+// no inferred serve task, or with any reused server no task covers, something
+// the graph cannot see starts a server, and concurrent consumers would race
+// it (each launching its own copy, or tearing it down under the others).
+function chainRequiresSerialization(chain) {
+    return !chain.commandTasks.length || chain.uncoveredServers > 0;
+}
+// A chain with inferred serve tasks depends on them (and its gate, when one
+// was inferred). Set together with parallelism so a config that inherits one
+// state (the atomized CI base copies the e2e config) cannot end up carrying
+// both.
+function applyChainDependsOn(targetConfig, chain, readyTargetName) {
+    if (chain.commandTasks.length) {
+        targetConfig.dependsOn = readyTargetName
+            ? [...getDependsOn(chain.commandTasks), { target: readyTargetName }]
+            : getDependsOn(chain.commandTasks);
+    }
+    else {
+        delete targetConfig.dependsOn;
+    }
+    if (chainRequiresSerialization(chain)) {
+        targetConfig.parallelism = false;
+    }
+    else {
+        delete targetConfig.parallelism;
+    }
+}
 function getDependsOn(tasks) {
     const projectsPerTask = new Map();
     for (const { project, target } of tasks) {

package/dist/src/plugins/webserver-config-worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Forked child that evaluates a Playwright config under the env it was spawned
+ * with (see resolveWebServersUnderEnv) and returns the resolved `webServer`
+ * addresses along with the probe env the config left behind. A child is used
+ * rather than an in-process re-evaluation because createNodes evaluates configs
+ * concurrently: a shared `process.env` swap would race across them, and the
+ * module cache would hand back the first evaluation.
+ *
+ * argv: [configFilePath (workspace-relative), workspaceRoot]. The result is
+ * sent over the IPC channel as a tagged `webserver-config-result` message, or
+ * `webserver-config-error` on failure.
+ */
+export declare function evaluateAndSendWebserverConfig(): Promise<void>;

package/dist/src/plugins/webserver-config-worker.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateAndSendWebserverConfig = evaluateAndSendWebserverConfig;
+const internal_1 = require("@nx/devkit/internal");
+const node_path_1 = require("node:path");
+const webserver_readiness_1 = require("./webserver-readiness");
+/**
+ * Forked child that evaluates a Playwright config under the env it was spawned
+ * with (see resolveWebServersUnderEnv) and returns the resolved `webServer`
+ * addresses along with the probe env the config left behind. A child is used
+ * rather than an in-process re-evaluation because createNodes evaluates configs
+ * concurrently: a shared `process.env` swap would race across them, and the
+ * module cache would hand back the first evaluation.
+ *
+ * argv: [configFilePath (workspace-relative), workspaceRoot]. The result is
+ * sent over the IPC channel as a tagged `webserver-config-result` message, or
+ * `webserver-config-error` on failure.
+ */
+async function evaluateAndSendWebserverConfig() {
+    const [configFilePath, workspaceRoot] = process.argv.slice(2);
+    const config = await (0, internal_1.loadConfigFile)((0, node_path_1.join)(workspaceRoot, configFilePath));
+    await send({
+        type: 'webserver-config-result',
+        webServers: (0, webserver_readiness_1.normalizeWebServers)(config.webServer),
+        probeEnv: (0, webserver_readiness_1.pickProbeEnv)(process.env),
+    });
+}
+// process.exit can truncate an IPC message that has not been flushed to the
+// parent, so wait for the send to be acknowledged before exiting. A delivery
+// failure rejects so the caller exits nonzero rather than reporting success.
+function send(message) {
+    return new Promise((resolve, reject) => {
+        if (!process.send) {
+            resolve();
+            return;
+        }
+        process.send(message, (error) => (error ? reject(error) : resolve()));
+    });
+}
+// Only the forked entrypoint runs the evaluation; importing the module (as the
+// tests do) must not.
+if (require.main === module) {
+    evaluateAndSendWebserverConfig().then(() => process.exit(0), async (error) => {
+        // A non-empty message so the failure the parent surfaces stays diagnosable.
+        const detail = (error && (error.stack || error.message)) ||
+            String(error) ||
+            'Unknown error while evaluating the Playwright config.';
+        try {
+            await send({ type: 'webserver-config-error', error: detail });
+        }
+        catch {
+            // The channel is gone; the nonzero exit below still signals the failure.
+        }
+        process.exit(1);
+    });
+}