@trackunit/iris-app-playwright 0.1.1

package/src/fixtures/login.fixture.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = exports.test = void 0;
+const test_1 = require("@playwright/test");
+const hydrateStorageState_1 = require("./hydrateStorageState");
+const loginCacheKey_1 = require("./loginCacheKey");
+const resolveCredentials_1 = require("./resolveCredentials");
+/**
+ * Each worker is its own Node process, so a `Map` is sufficient — no
+ * cross-worker sharing concerns, no disk I/O, no cleanup needed. The cache
+ * dies with the worker, which is the desired behaviour: a fresh `nx run`
+ * always starts with empty caches.
+ */
+exports.test = test_1.test.extend({
+    _loginCache: [
+        async ({}, provide) => {
+            await provide(new Map());
+        },
+        { scope: "worker" },
+    ],
+    login: async ({ page, baseURL, _loginCache }, provide) => {
+        const loginFn = async (options) => {
+            const credentials = (0, resolveCredentials_1.resolveCredentials)(options);
+            const cacheKey = (0, loginCacheKey_1.buildLoginCacheKey)(baseURL, credentials);
+            const cached = _loginCache.get(cacheKey);
+            if (cached !== undefined) {
+                try {
+                    await (0, hydrateStorageState_1.hydrateStorageState)(page.context(), cached);
+                    await page.goto("/");
+                    await page.locator("#host-layout-content").waitFor({ state: "visible", timeout: 15000 });
+                    return;
+                }
+                catch {
+                    _loginCache.delete(cacheKey);
+                }
+            }
+            await performOktaLogin({ page, baseURL, credentials });
+            // Capture the fully-authenticated state for reuse by later tests in
+            // this worker. Errors here would mask the actual login success, so we
+            // never let snapshot capture throw — at worst we'll re-hit Okta next
+            // time, which is the pre-cache behaviour.
+            try {
+                const snapshot = await page.context().storageState();
+                _loginCache.set(cacheKey, snapshot);
+            }
+            catch {
+                /* Snapshot capture is best-effort; failing here is non-fatal. */
+            }
+        };
+        await provide(loginFn);
+    },
+});
+/**
+ * Performs the slow path: hit Okta's `/api/v1/authn`, redeem the
+ * `sessionToken` via the manager-classic redirect, and wait for the host
+ * layout to render. Factored out so the cache hit/miss branches read clearly.
+ */
+const performOktaLogin = async ({ page, baseURL, credentials, }) => {
+    const context = await test_1.request.newContext({ baseURL });
+    try {
+        const envResponse = await context.get("/env");
+        const env = await envResponse.json();
+        const domainValue = env.auth?.url;
+        if (typeof domainValue !== "string" || domainValue === "") {
+            throw new Error(`No domain found from servers /env found env: ${JSON.stringify(env)}`);
+        }
+        const domain = domainValue;
+        const authResponse = await context.post(`${domain}/api/v1/authn`, {
+            data: {
+                username: credentials.username,
+                password: credentials.password,
+                options: {
+                    warnBeforePasswordExpired: true,
+                    multiOptionalFactorEnroll: false,
+                },
+            },
+            headers: { "Content-Type": "application/json" },
+            timeout: 20000,
+        });
+        if (!authResponse.ok()) {
+            const body = await authResponse.json().catch(() => ({}));
+            throw new Error(`Could not get a session token for user: ${credentials.username}, ${JSON.stringify(body)}`);
+        }
+        const { sessionToken } = await authResponse.json();
+        await page.goto(`/auth/manager-classic#session_token=${sessionToken}&userProfile=true`);
+        await page.waitForURL(url => !url.href.includes("manager-classic"), { timeout: 20000 });
+        await page.locator("#host-layout-content").waitFor({ state: "visible", timeout: 15000 });
+    }
+    finally {
+        await context.dispose();
+    }
+};
+var test_2 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_2.expect; } });
+//# sourceMappingURL=login.fixture.js.map

package/src/fixtures/loginCacheKey.d.ts

@@ -0,0 +1,25 @@
+import type { AuthCredentials } from "./resolveCredentials";
+/**
+ * Builds the lookup key used by the worker-scoped login cache.
+ *
+ * The cache reuses an authenticated `storageState` snapshot across every test
+ * within a Playwright worker that logs in as the same `(baseURL, username)`
+ * pair. Two principles drive the key shape:
+ *
+ * 1. **Username, not username+password.** Different passwords for the same
+ *    user are almost always a credential rotation, not a deliberate second
+ *    identity — if a test really needs different identities it will use a
+ *    different `username`. Including the password would make a typo silently
+ *    cache-miss instead of failing loudly, and would also serialise it into
+ *    the key string. Kept out for both correctness and minor hygiene.
+ * 2. **`baseURL` is required.** Okta sessions are domain-bound (the auth
+ *    cookies are set on the manager origin), so a snapshot from
+ *    `https://dev.manager.trackunit.com` cannot authenticate a request to
+ *    `https://stage.manager.trackunit.com`. We always partition by baseURL.
+ *
+ * `JSON.stringify` over a fixed-shape object guarantees no collision between
+ * (undefined baseURL, username "X") and (baseURL "X", undefined-equivalent
+ * username) — `null` and `"X"` serialise distinctly, and the field names
+ * anchor each value to its slot.
+ */
+export declare const buildLoginCacheKey: (baseURL: string | undefined, credentials: AuthCredentials) => string;

package/src/fixtures/loginCacheKey.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLoginCacheKey = void 0;
+/**
+ * Builds the lookup key used by the worker-scoped login cache.
+ *
+ * The cache reuses an authenticated `storageState` snapshot across every test
+ * within a Playwright worker that logs in as the same `(baseURL, username)`
+ * pair. Two principles drive the key shape:
+ *
+ * 1. **Username, not username+password.** Different passwords for the same
+ *    user are almost always a credential rotation, not a deliberate second
+ *    identity — if a test really needs different identities it will use a
+ *    different `username`. Including the password would make a typo silently
+ *    cache-miss instead of failing loudly, and would also serialise it into
+ *    the key string. Kept out for both correctness and minor hygiene.
+ * 2. **`baseURL` is required.** Okta sessions are domain-bound (the auth
+ *    cookies are set on the manager origin), so a snapshot from
+ *    `https://dev.manager.trackunit.com` cannot authenticate a request to
+ *    `https://stage.manager.trackunit.com`. We always partition by baseURL.
+ *
+ * `JSON.stringify` over a fixed-shape object guarantees no collision between
+ * (undefined baseURL, username "X") and (baseURL "X", undefined-equivalent
+ * username) — `null` and `"X"` serialise distinctly, and the field names
+ * anchor each value to its slot.
+ */
+const buildLoginCacheKey = (baseURL, credentials) => JSON.stringify({ baseURL: baseURL ?? null, username: credentials.username });
+exports.buildLoginCacheKey = buildLoginCacheKey;
+//# sourceMappingURL=loginCacheKey.js.map

package/src/fixtures/resolveCredentials.d.ts

@@ -0,0 +1,14 @@
+export interface AuthCredentials {
+    username: string;
+    password: string;
+}
+export interface ResolveCredentialsOptions {
+    credentials?: AuthCredentials;
+    /** Path to a JSON file with `{ username, password }`. Defaults to `playwright/fixtures/auth.json` relative to cwd. */
+    fixturePath?: string;
+}
+/**
+ * Resolves auth credentials from (in order): explicit options, JSON fixture file, env vars.
+ * Throws if none yield a complete credential pair.
+ */
+export declare const resolveCredentials: (options?: ResolveCredentialsOptions) => AuthCredentials;

package/src/fixtures/resolveCredentials.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCredentials = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const isAuthCredentials = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = { ...value };
+    return typeof record.username === "string" && typeof record.password === "string";
+};
+const readFixtureCredentials = (fixturePath) => {
+    if (!(0, fs_1.existsSync)(fixturePath)) {
+        return undefined;
+    }
+    const parsed = JSON.parse((0, fs_1.readFileSync)(fixturePath, "utf-8"));
+    if (!isAuthCredentials(parsed)) {
+        return undefined;
+    }
+    if (parsed.username === "REPLACE_ME" || parsed.password === "REPLACE_ME") {
+        return undefined;
+    }
+    return parsed;
+};
+/**
+ * Resolves auth credentials from (in order): explicit options, JSON fixture file, env vars.
+ * Throws if none yield a complete credential pair.
+ */
+const resolveCredentials = (options) => {
+    if (options?.credentials !== undefined) {
+        return options.credentials;
+    }
+    const fixturePath = options?.fixturePath ?? path.join(process.cwd(), "playwright", "fixtures", "auth.json");
+    const fromFixture = readFixtureCredentials(fixturePath);
+    if (fromFixture !== undefined) {
+        return fromFixture;
+    }
+    const envUsername = process.env.PLAYWRIGHT_USERNAME;
+    const envPassword = process.env.PLAYWRIGHT_PASSWORD;
+    if (envUsername !== undefined && envUsername !== "" && envPassword !== undefined && envPassword !== "") {
+        return { username: envUsername, password: envPassword };
+    }
+    throw new Error(`No credentials provided to login(). Tried: options.credentials, ${fixturePath}, PLAYWRIGHT_USERNAME/PLAYWRIGHT_PASSWORD env vars. ` +
+        `Fill in playwright/fixtures/auth.json, set the env vars, or pass credentials to login().`);
+};
+exports.resolveCredentials = resolveCredentials;
+//# sourceMappingURL=resolveCredentials.js.map

package/src/generators/playwright-configuration/files/root/playwright/fixtures/auth.json__tmpl__

@@ -0,0 +1,4 @@
+{
+  "username": "REPLACE_ME",
+  "password": "REPLACE_ME"
+}

package/src/generators/playwright-configuration/files/root/playwright/support/fixtures.ts__tmpl__

@@ -0,0 +1 @@
+export { describe, expect, test } from "@trackunit/iris-app-playwright/support";

package/src/generators/playwright-configuration/files/root/playwright/tests/app.spec.ts__tmpl__

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "../support/fixtures";
+
+describe("Sample E2E Test", () => {
+  test("Can log in and navigate to app", async ({ page, login }) => {
+    await login();
+
+    // Example: Test your application here
+    // await expect(page.getByTestId("your-app-element")).toBeVisible();
+
+    // Example: Test Iris app integration
+    // const app = irisApp();
+    // await expect(app.getByTestId("your-test-id")).toBeVisible();
+
+    await expect(page.locator("#host-layout-content")).toBeVisible();
+  });
+});

package/src/generators/playwright-configuration/files/root/playwright/tsconfig.json__tmpl__

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "sourceMap": false
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.js",
+    "../playwright.config.ts",
+    "./**/*.spec.ts",
+    "./**/*.spec.tsx",
+    "./**/*.d.ts"
+  ]
+}

package/src/generators/playwright-configuration/files/root/playwright.config.ts__tmpl__

@@ -0,0 +1,13 @@
+import { createNxPreset, defaultPlaywrightConfig, setupPlugins } from "@trackunit/iris-app-playwright";
+import { format, resolveConfig } from "prettier";
+
+const nxPreset = createNxPreset(__filename);
+const config = defaultPlaywrightConfig({ configDir: __dirname, projectConfig: { testDir: "./playwright/tests" } });
+
+export default setupPlugins(
+  {
+    ...nxPreset,
+    ...config,
+  },
+  { format, resolveConfig }
+);

package/src/generators/playwright-configuration/generator.d.ts

@@ -0,0 +1,18 @@
+import { Tree } from "@nx/devkit";
+import { PlaywrightConfigurationGeneratorSchema } from "./schema";
+/**
+ * Generates Playwright E2E test configuration for an existing project.
+ *
+ * Sets up Playwright end-to-end testing infrastructure within an existing project,
+ * including configuration files, test targets, and template files that use the public
+ * iris-app-playwright library. Does not modify any existing Cypress configuration.
+ *
+ * @param tree - The NX virtual file system tree
+ * @param options - Configuration options for the generator
+ * @returns {Promise<() => void>} A function that logs completion message with the path to the generated test file
+ * @example
+ * ```bash
+ * nx generate @trackunit/iris-app-playwright:playwright-configuration --project my-app
+ * ```
+ */
+export declare function playwrightConfigurationGenerator(tree: Tree, options: PlaywrightConfigurationGeneratorSchema): Promise<() => void>;

package/src/generators/playwright-configuration/generator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playwrightConfigurationGenerator = playwrightConfigurationGenerator;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Generates Playwright E2E test configuration for an existing project.
+ *
+ * Sets up Playwright end-to-end testing infrastructure within an existing project,
+ * including configuration files, test targets, and template files that use the public
+ * iris-app-playwright library. Does not modify any existing Cypress configuration.
+ *
+ * @param tree - The NX virtual file system tree
+ * @param options - Configuration options for the generator
+ * @returns {Promise<() => void>} A function that logs completion message with the path to the generated test file
+ * @example
+ * ```bash
+ * nx generate @trackunit/iris-app-playwright:playwright-configuration --project my-app
+ * ```
+ */
+async function playwrightConfigurationGenerator(tree, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const projectRoot = projectConfig.root;
+    const playwrightConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, "playwright.config.ts");
+    if (tree.exists(playwrightConfigPath)) {
+        throw new Error(`playwright.config.ts already exists at ${playwrightConfigPath}. Remove it before running this generator.`);
+    }
+    const existingProjectConfig = projectConfig;
+    // We use `nx:run-commands` (not `@nx/playwright:playwright`) because that executor
+    // does not honour an `env` option in target configurations — it forwards unknown options
+    // as Playwright CLI flags, so `BASE_URL` would never reach `process.env`.
+    // `nx:run-commands` sets the configuration's `env` on the spawned process, which is what
+    // `defaultPlaywrightConfig()` reads.
+    //
+    // `cwd` is pinned to `projectRoot` so `process.cwd()` inside Playwright matches the
+    // project directory. `login()`'s default fixture path is
+    // `path.join(process.cwd(), "playwright", "fixtures", "auth.json")`, and the generator
+    // scaffolds that file under `${projectRoot}/playwright/fixtures/auth.json` — without
+    // this `cwd`, nx:run-commands would spawn from the workspace root and `login()` would
+    // miss the scaffolded fixture (failing unless env vars are set).
+    const configurations = {
+        local: { env: { BASE_URL: "http://localhost:3000" } },
+        dev: { env: { BASE_URL: "https://dev.manager.trackunit.com" } },
+        stage: { env: { BASE_URL: "https://stage.manager.trackunit.com" } },
+        prod: { env: { BASE_URL: "https://new.manager.trackunit.com" } },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, {
+        ...existingProjectConfig,
+        targets: {
+            ...existingProjectConfig.targets,
+            "e2e-pw-ui": {
+                executor: "nx:run-commands",
+                options: {
+                    command: `playwright test --config=playwright.config.ts --headed --ui`,
+                    cwd: projectRoot,
+                },
+                configurations,
+            },
+            "e2e-pw": {
+                executor: "nx:run-commands",
+                options: {
+                    command: `playwright test --config=playwright.config.ts`,
+                    cwd: projectRoot,
+                },
+                configurations,
+            },
+        },
+    });
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, "files/root"), projectRoot, {
+        ...options,
+        tmpl: "",
+    });
+    await (0, devkit_1.formatFiles)(tree);
+    return () => {
+        devkit_1.logger.info(`\n\n\n✅ 🚀 Please open this file to get started\n${(0, devkit_1.joinPathFragments)(projectRoot, "playwright/tests/app.spec.ts")}`);
+    };
+}
+//# sourceMappingURL=generator.js.map

package/src/generators/playwright-configuration/schema.d.ts

@@ -0,0 +1,3 @@
+export interface PlaywrightConfigurationGeneratorSchema {
+  project: string;
+}

package/src/generators/playwright-configuration/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "PlaywrightConfiguration",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "feature name",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Which project would you like to add Playwright E2E tests for?"
+    }
+  },
+  "required": ["project"]
+}

package/src/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./plugins/createLogFile";
+export * from "./plugins/defaultPlaywrightConfig";
+export * from "./plugins/logsReporter";
+export * from "./plugins/nxPreset";
+export * from "./plugins/redactSensitive";
+export * from "./plugins/setupPlugins";
+export * from "./plugins/writeFileWithPrettier";
+export * from "./utils/Codeowner";
+export * from "./utils/fileNameBuilder";
+export * from "./utils/fileUpdater";
+export type { FeatureFlag, FeatureFlagFixtures } from "./fixtures/featureFlags.fixture";
+export type { CachedStorageState } from "./fixtures/hydrateStorageState";
+export type { IrisAppFixtures, IrisAppOptions, StorybookPreviewOptions } from "./fixtures/irisApp.fixture";
+export type { LocalDevModeFixtures } from "./fixtures/localDevMode.fixture";
+export type { AuthCredentials, LoginOptions, TrackunitBaseFixtures } from "./fixtures/login.fixture";

package/src/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./plugins/createLogFile"), exports);
+tslib_1.__exportStar(require("./plugins/defaultPlaywrightConfig"), exports);
+tslib_1.__exportStar(require("./plugins/logsReporter"), exports);
+tslib_1.__exportStar(require("./plugins/nxPreset"), exports);
+tslib_1.__exportStar(require("./plugins/redactSensitive"), exports);
+tslib_1.__exportStar(require("./plugins/setupPlugins"), exports);
+tslib_1.__exportStar(require("./plugins/writeFileWithPrettier"), exports);
+tslib_1.__exportStar(require("./utils/Codeowner"), exports);
+tslib_1.__exportStar(require("./utils/fileNameBuilder"), exports);
+tslib_1.__exportStar(require("./utils/fileUpdater"), exports);
+//# sourceMappingURL=index.js.map

package/src/plugins/createLogFile.d.ts

@@ -0,0 +1,24 @@
+import { Formatter } from "./writeFileWithPrettier";
+type Log = {
+    type: string;
+    message: string;
+    severity: string;
+};
+/**
+ * Creates structured log files for Playwright test runs.
+ * Generates separate files for all logs, errors, and network errors.
+ *
+ * Returns a promise that resolves once every file has been formatted and
+ * written. Callers (e.g. `LogsReporter.onTestEnd`) must await — or collect
+ * and later await — this promise to avoid fire-and-forget writes that
+ * Playwright may finish before Prettier settles.
+ *
+ * @param nxRoot - Absolute path to the NX workspace root
+ * @param logsPath - Directory where log files will be written
+ * @param fileNameWithoutExtension - Base filename (without extension) for the log files
+ * @param logs - Array of log entries to write
+ * @param logWriter - Prettier formatter instance for formatting JSON output
+ * @returns {Promise<void>} Resolves once all log files have been written
+ */
+export declare function createLogFile(nxRoot: string, logsPath: string, fileNameWithoutExtension: string, logs: Array<Log>, logWriter: Formatter): Promise<void>;
+export {};

package/src/plugins/createLogFile.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogFile = createLogFile;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importStar(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const writeFileWithPrettier_1 = require("./writeFileWithPrettier");
+const isNetworkCall = (log) => {
+    return (log.type === "network:request" ||
+        log.type === "network:response" ||
+        log.type === "network:fetch" ||
+        log.type === "network:websocket");
+};
+/**
+ * Creates structured log files for Playwright test runs.
+ * Generates separate files for all logs, errors, and network errors.
+ *
+ * Returns a promise that resolves once every file has been formatted and
+ * written. Callers (e.g. `LogsReporter.onTestEnd`) must await — or collect
+ * and later await — this promise to avoid fire-and-forget writes that
+ * Playwright may finish before Prettier settles.
+ *
+ * @param nxRoot - Absolute path to the NX workspace root
+ * @param logsPath - Directory where log files will be written
+ * @param fileNameWithoutExtension - Base filename (without extension) for the log files
+ * @param logs - Array of log entries to write
+ * @param logWriter - Prettier formatter instance for formatting JSON output
+ * @returns {Promise<void>} Resolves once all log files have been written
+ */
+async function createLogFile(nxRoot, logsPath, fileNameWithoutExtension, logs, logWriter) {
+    if (!(0, fs_1.existsSync)(logsPath)) {
+        fs_1.default.mkdirSync(logsPath, { recursive: true });
+    }
+    const logFilePath = path_1.default.join(logsPath, fileNameWithoutExtension);
+    const writes = [
+        (0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-all.json", JSON.stringify(logs), logWriter),
+    ];
+    const errorCmds = logs.filter(log => log.severity === "error");
+    if (errorCmds.length > 0) {
+        writes.push((0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-errors.json", JSON.stringify(errorCmds), logWriter));
+    }
+    const networkErrorsCmds = logs.filter(log => isNetworkCall(log) &&
+        !log.message.includes("Status: 200") &&
+        log.severity !== "success" &&
+        !log.message.includes("sentry.io/api/"));
+    if (networkErrorsCmds.length > 0) {
+        writes.push((0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-network-errors.json", JSON.stringify(networkErrorsCmds), logWriter));
+    }
+    await Promise.all(writes);
+}
+//# sourceMappingURL=createLogFile.js.map

package/src/plugins/defaultPlaywrightConfig.d.ts

@@ -0,0 +1,68 @@
+import type { PlaywrightTestConfig } from "@playwright/test";
+/**
+ * Finds the NX workspace root by walking up the directory tree looking for nx.json or workspace.json.
+ *
+ * @param startDir - Starting directory for the search (defaults to current working directory)
+ * @returns {string} Absolute path to the workspace root
+ * @throws Error if workspace root cannot be found
+ */
+export declare function findWorkspaceRoot(startDir?: string): string;
+export interface E2EPluginConfig {
+    outputPath?: string;
+}
+export interface E2EProjectConfig {
+    testDir?: string;
+}
+export interface E2EBehaviorConfig {
+    timeout?: number;
+    retries?: number;
+    navigationTimeout?: number;
+    actionTimeout?: number;
+    /**
+     * Override Playwright's worker count. Useful when the suite hits external,
+     * rate-limited services (Okta `/api/v1/authn` returns `E0000047` once you
+     * fan out past a handful of parallel logins against a shared environment).
+     *
+     * The `login` fixture caches one authenticated `storageState` per worker,
+     * so worker count is effectively the upper bound on parallel Okta calls
+     * per `(baseURL, username)` pair. Capping workers therefore caps Okta load.
+     *
+     * Leave unset to use Playwright's default (`Math.ceil(os.cpus().length / 2)`
+     * locally, `1` on CI).
+     */
+    workers?: number | string;
+    /**
+     * Whether tests within the same file should run in parallel.
+     *
+     * Defaults to Playwright's behaviour (`undefined`, i.e. the project-level
+     * setting wins, which in turn defaults to `false`). Set explicitly when a
+     * project wants file-level parallelism or wants to opt out of it.
+     */
+    fullyParallel?: boolean;
+}
+export interface E2EConfigOptions {
+    /**
+     * Absolute path to the directory of the calling `playwright.config.ts`. Pass `__dirname`.
+     *
+     * Required when running under `@nx/playwright` (or any executor that forks Playwright from
+     * the workspace root) — without it, `process.cwd()` resolves to the workspace root and
+     * codeowner lookup / report paths land outside the intended project directory.
+     *
+     * When omitted, falls back to `process.cwd()` for backwards compatibility with consumers
+     * invoking Playwright directly from their project directory.
+     */
+    configDir?: string;
+    nxRoot?: string;
+    outputDirOverride?: string;
+    projectConfig?: E2EProjectConfig;
+    behaviorConfig?: E2EBehaviorConfig;
+    pluginConfig?: E2EPluginConfig;
+}
+/**
+ * Creates default Playwright configuration for E2E testing.
+ * Returns a partial `PlaywrightTestConfig` that projects can spread and extend.
+ *
+ * @param options - Optional configuration overrides
+ * @returns {Partial<PlaywrightTestConfig>} Playwright test configuration
+ */
+export declare const defaultPlaywrightConfig: (options?: E2EConfigOptions) => Partial<PlaywrightTestConfig>;