@empiricalrun/playwright-utils 0.58.6 → 0.60.0

package/dist/reporter/test-case-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-case-sync.d.ts","sourceRoot":"","sources":["../../src/reporter/test-case-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AACrD,OAAO,KAAK,EACV,UAAU,EAEV,KAAK,EAEN,MAAM,2BAA2B,CAAC;AAUnC,YAAY,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,6CAA6C,CAAC;AA+JrD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,KAAK,GACf,oBAAoB,CAuBtB"}
+{"version":3,"file":"test-case-sync.d.ts","sourceRoot":"","sources":["../../src/reporter/test-case-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AACrD,OAAO,KAAK,EACV,UAAU,EAEV,KAAK,EAEN,MAAM,2BAA2B,CAAC;AAUnC,YAAY,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,6CAA6C,CAAC;AAgUrD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,KAAK,GACf,oBAAoB,CAyBtB"}

package/dist/reporter/test-case-sync.js

@@ -15,6 +15,24 @@ function getSuiteParallelMode(suite) {
         ? mode
         : "none";
 }
+/**
+ * The project's per-project `workers` cap, if it declares one.
+ *
+ * The public `FullProject` deliberately omits `workers`, so this reads the
+ * internal `FullProjectInternal` that Playwright attaches to every project
+ * suite (`buildProjectSuite` in `runner/loadUtils.ts` — the same object
+ * `suite.project()` resolves through, so it is present wherever projects
+ * are). Only explicit per-project caps surface here: the global `workers`
+ * setting resolves per machine (a `'50%'` default is a different number on
+ * the listing container than on a shard) and is not a per-project signal.
+ */
+function getProjectWorkerCap(suite) {
+    const workers = suite
+        ._fullProject?.workers;
+    return typeof workers === "number" && Number.isFinite(workers) && workers >= 1
+        ? workers
+        : undefined;
+}
 function toPosixPath(value) {
     return value.split(path_1.default.sep).join("/");
 }
@@ -41,7 +59,7 @@ function stableGroupId(input) {
         input.column,
     ]))
         .digest("hex");
-    return `playwright_serial:${hash}`;
+    return `${input.kind}:${hash}`;
 }
 function collectDirectTestCases(rootDir, suite, state) {
     return suite.tests.map((test) => ({
@@ -53,11 +71,7 @@ function collectDirectTestCases(rootDir, suite, state) {
         tags: normalizeTags(test.tags),
     }));
 }
-function collectOutermostSerialGroup(rootDir, suite, state) {
-    if (state.serialAncestor || getSuiteParallelMode(suite) !== "serial") {
-        return null;
-    }
-    const tests = suite.allTests();
+function buildDependencyGroup(rootDir, suite, state, kind, tests) {
     if (tests.length < 2) {
         return null;
     }
@@ -71,13 +85,14 @@ function collectOutermostSerialGroup(rootDir, suite, state) {
     const location = suite.location ?? firstTest.location;
     return {
         id: stableGroupId({
+            kind,
             projectName,
             filePath,
             titlePath,
             line: location.line,
             column: location.column,
         }),
-        kind: "playwright_serial",
+        kind,
         file_path: filePath,
         title_path: titlePath,
         playwright_project: projectName,
@@ -87,14 +102,95 @@ function collectOutermostSerialGroup(rootDir, suite, state) {
         })),
     };
 }
+function collectOutermostSerialGroup(rootDir, suite, state) {
+    if (state.serialAncestor || getSuiteParallelMode(suite) !== "serial") {
+        return null;
+    }
+    return buildDependencyGroup(rootDir, suite, state, "playwright_serial", suite.allTests());
+}
+/**
+ * Tests under this suite that Playwright would place in its sequential
+ * ("general") group: everything except subtrees that opt back into
+ * parallelism. Order is declaration order, which is the order the group
+ * executes in.
+ */
+function sequentialTests(suite) {
+    const tests = [...suite.tests];
+    for (const child of suite.suites) {
+        if (getSuiteParallelMode(child) !== "parallel") {
+            tests.push(...sequentialTests(child));
+        }
+    }
+    return tests;
+}
+/**
+ * The `playwright_default` counterpart of the serial collector: the outermost
+ * scope whose tests Playwright schedules as one ordered worker group without
+ * serial semantics.
+ *
+ * Two shapes qualify (mirroring `createTestGroups` in Playwright's
+ * `runner/testGroups.ts`):
+ *
+ * - a `test.describe.configure({ mode: "default" })` suite — grouped whole,
+ *   including any nested parallel subtree, because Playwright keys the group
+ *   on the outermost sequential suite;
+ * - a file with no explicit mode in a non-fullyParallel project — Playwright's
+ *   per-file "general" group, which excludes subtrees that opt back into
+ *   `parallel`.
+ */
+function collectOutermostDefaultGroup(rootDir, suite, state) {
+    if (state.sequentialAncestor) {
+        return null;
+    }
+    const mode = getSuiteParallelMode(suite);
+    if (mode === "default") {
+        return buildDependencyGroup(rootDir, suite, state, "playwright_default", suite.allTests());
+    }
+    if (suite.type === "file" && !state.insideParallel && mode === "none") {
+        return buildDependencyGroup(rootDir, suite, state, "playwright_default", sequentialTests(suite));
+    }
+    return null;
+}
 function walkSuite(rootDir, suite, state, testCases, dependencyGroups) {
     const isDescribe = suite.type === "describe";
     const suites = isDescribe ? [...state.suites, suite.title] : state.suites;
     const nextState = { ...state, suites };
+    const mode = getSuiteParallelMode(suite);
+    // A per-project `workers` cap constrains the whole project: the dispatcher
+    // enforces it per process (`_workerLimitPerProjectId`), so the guarantee
+    // only survives sharding if every test of the project lands on one shard.
+    // Emitted alongside any inner groups — it is the outermost scope, so it
+    // wins for scheduling and keeps the inner ones whole for free.
+    if (suite.type === "project") {
+        const workerCap = getProjectWorkerCap(suite);
+        if (workerCap !== undefined) {
+            const capGroup = buildDependencyGroup(rootDir, suite, nextState, "playwright_worker_cap", suite.allTests());
+            if (capGroup) {
+                dependencyGroups.push({ ...capGroup, worker_limit: workerCap });
+            }
+        }
+    }
+    // A serial group is emitted even inside a default scope: the outer default
+    // group wins for scheduling, but serial membership carries extra semantics
+    // (failure cascade, re-expansion) its consumers still need.
     const serialGroup = collectOutermostSerialGroup(rootDir, suite, nextState);
     if (serialGroup) {
         dependencyGroups.push(serialGroup);
         nextState.serialAncestor = suite;
+        if (!nextState.sequentialAncestor) {
+            nextState.sequentialAncestor = suite;
+        }
+    }
+    const defaultGroup = collectOutermostDefaultGroup(rootDir, suite, nextState);
+    if (defaultGroup) {
+        dependencyGroups.push(defaultGroup);
+        nextState.sequentialAncestor = suite;
+    }
+    // fullyParallel (project suite) or an explicit `mode: "parallel"` — every
+    // descendant is independently schedulable unless a sequential suite below
+    // says otherwise.
+    if (mode === "parallel") {
+        nextState.insideParallel = true;
     }
     testCases.push(...collectDirectTestCases(rootDir, suite, nextState));
     for (const child of suite.suites) {
@@ -112,6 +208,15 @@ function walkSuite(rootDir, suite, state, testCases, dependencyGroups) {
                     : "";
             childState.suites = [];
             childState.serialAncestor = null;
+            childState.sequentialAncestor = null;
+        }
+        else if (childState.sequentialAncestor &&
+            getSuiteParallelMode(childState.sequentialAncestor) === "none" &&
+            getSuiteParallelMode(child) === "parallel") {
+            // The scope was a plain file's "general" group, which excludes subtrees
+            // that opt back into parallel — so below this child, sequential suites
+            // start their own groups again.
+            childState.sequentialAncestor = null;
         }
         walkSuite(rootDir, child, childState, testCases, dependencyGroups);
     }
@@ -125,6 +230,8 @@ function collectTestCaseSyncManifest(config, rootSuite) {
         filePath: "",
         suites: [],
         serialAncestor: null,
+        sequentialAncestor: null,
+        insideParallel: false,
     }, testCases, dependencyGroups);
     return {
         version: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empiricalrun/playwright-utils",
-  "version": "0.58.6",
+  "version": "0.60.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -41,7 +41,7 @@
     "openapi-typescript": "7.6.1",
     "playwright-core": "1.62.1",
     "serve-handler": "^6.1.6",
-    "@empiricalrun/shared-types": "0.15.4"
+    "@empiricalrun/shared-types": "0.17.0"
   },
   "dependencies": {
     "@babel/code-frame": "^7.24.7",