playwright 1.55.0-alpha-2025-08-06 → 1.55.0-alpha-2025-08-08

package/lib/common/config.js

@@ -49,6 +49,8 @@ class FullConfigInternal {
     this.projects = [];
     this.cliArgs = [];
     this.cliListOnly = false;
+    this.preOnlyTestFilters = [];
+    this.postShardTestFilters = [];
     this.defineConfigWasUsed = false;
     this.globalSetups = [];
     this.globalTeardowns = [];

package/lib/common/fixtures.js

@@ -90,7 +90,7 @@ class FixturePool {
           continue;
         }
       } else if (previous) {
-        options = { auto: previous.auto, scope: previous.scope, option: previous.option, timeout: previous.timeout, customTitle: previous.customTitle, box: previous.box };
+        options = { auto: previous.auto, scope: previous.scope, option: previous.option, timeout: previous.timeout, customTitle: previous.customTitle };
       } else if (!options) {
         options = { auto: false, scope: "test", option: false, timeout: void 0 };
       }

package/lib/common/suiteUtils.js

@@ -31,10 +31,8 @@ __export(suiteUtils_exports, {
   applyRepeatEachIndex: () => applyRepeatEachIndex,
   bindFileSuiteToProject: () => bindFileSuiteToProject,
   filterByFocusedLine: () => filterByFocusedLine,
-  filterByTestIds: () => filterByTestIds,
   filterOnly: () => filterOnly,
   filterSuite: () => filterSuite,
-  filterSuiteWithOnlySemantics: () => filterSuiteWithOnlySemantics,
   filterTestsRemoveEmptySuites: () => filterTestsRemoveEmptySuites
 });
 module.exports = __toCommonJS(suiteUtils_exports);
@@ -127,11 +125,6 @@ function filterByFocusedLine(suite, focusedTestFileLines) {
   const testFilter = (test) => testFileLineMatches(test.location.file, test.location.line, test.location.column);
   return filterSuite(suite, suiteFilter, testFilter);
 }
-function filterByTestIds(suite, testIdMatcher) {
-  if (!testIdMatcher)
-    return;
-  filterTestsRemoveEmptySuites(suite, (test) => testIdMatcher(test.id));
-}
 function createFileMatcherFromFilter(filter) {
   const fileMatcher = (0, import_util.createFileMatcher)(filter.re || filter.exact || "");
   return (testFileName, testLine, testColumn) => fileMatcher(testFileName) && (filter.line === testLine || filter.line === null) && (filter.column === testColumn || filter.column === null);
@@ -141,9 +134,7 @@ function createFileMatcherFromFilter(filter) {
   applyRepeatEachIndex,
   bindFileSuiteToProject,
   filterByFocusedLine,
-  filterByTestIds,
   filterOnly,
   filterSuite,
-  filterSuiteWithOnlySemantics,
   filterTestsRemoveEmptySuites
 });

package/lib/index.js

@@ -61,20 +61,20 @@ if (process["__pw_initiator__"]) {
   process["__pw_initiator__"] = new Error().stack;
 }
 const playwrightFixtures = {
-  defaultBrowserType: ["chromium", { scope: "worker", option: true }],
-  browserName: [({ defaultBrowserType }, use) => use(defaultBrowserType), { scope: "worker", option: true }],
+  defaultBrowserType: ["chromium", { scope: "worker", option: true, box: true }],
+  browserName: [({ defaultBrowserType }, use) => use(defaultBrowserType), { scope: "worker", option: true, box: true }],
   playwright: [async ({}, use) => {
     await use(require("playwright-core"));
   }, { scope: "worker", box: true }],
-  headless: [({ launchOptions }, use) => use(launchOptions.headless ?? true), { scope: "worker", option: true }],
-  channel: [({ launchOptions }, use) => use(launchOptions.channel), { scope: "worker", option: true }],
-  launchOptions: [{}, { scope: "worker", option: true }],
+  headless: [({ launchOptions }, use) => use(launchOptions.headless ?? true), { scope: "worker", option: true, box: true }],
+  channel: [({ launchOptions }, use) => use(launchOptions.channel), { scope: "worker", option: true, box: true }],
+  launchOptions: [{}, { scope: "worker", option: true, box: true }],
   connectOptions: [async ({ _optionConnectOptions }, use) => {
     await use(connectOptionsFromEnv() || _optionConnectOptions);
-  }, { scope: "worker", option: true }],
-  screenshot: ["off", { scope: "worker", option: true }],
-  video: ["off", { scope: "worker", option: true }],
-  trace: ["off", { scope: "worker", option: true }],
+  }, { scope: "worker", option: true, box: true }],
+  screenshot: ["off", { scope: "worker", option: true, box: true }],
+  video: ["off", { scope: "worker", option: true, box: true }],
+  trace: ["off", { scope: "worker", option: true, box: true }],
   _browserOptions: [async ({ playwright, headless, channel, launchOptions }, use) => {
     const options = {
       handleSIGINT: false,
@@ -103,45 +103,41 @@ const playwrightFixtures = {
         }
       });
       await use(browser2);
-      await browser2._wrapApiCall(async () => {
-        await browser2.close({ reason: "Test ended." });
-      }, { internal: true });
+      await browser2.close({ reason: "Test ended." });
       return;
     }
     const browser = await playwright[browserName].launch();
     await use(browser);
-    await browser._wrapApiCall(async () => {
-      await browser.close({ reason: "Test ended." });
-    }, { internal: true });
+    await browser.close({ reason: "Test ended." });
   }, { scope: "worker", timeout: 0 }],
-  acceptDownloads: [({ contextOptions }, use) => use(contextOptions.acceptDownloads ?? true), { option: true }],
-  bypassCSP: [({ contextOptions }, use) => use(contextOptions.bypassCSP ?? false), { option: true }],
-  colorScheme: [({ contextOptions }, use) => use(contextOptions.colorScheme === void 0 ? "light" : contextOptions.colorScheme), { option: true }],
-  deviceScaleFactor: [({ contextOptions }, use) => use(contextOptions.deviceScaleFactor), { option: true }],
-  extraHTTPHeaders: [({ contextOptions }, use) => use(contextOptions.extraHTTPHeaders), { option: true }],
-  geolocation: [({ contextOptions }, use) => use(contextOptions.geolocation), { option: true }],
-  hasTouch: [({ contextOptions }, use) => use(contextOptions.hasTouch ?? false), { option: true }],
-  httpCredentials: [({ contextOptions }, use) => use(contextOptions.httpCredentials), { option: true }],
-  ignoreHTTPSErrors: [({ contextOptions }, use) => use(contextOptions.ignoreHTTPSErrors ?? false), { option: true }],
-  isMobile: [({ contextOptions }, use) => use(contextOptions.isMobile ?? false), { option: true }],
-  javaScriptEnabled: [({ contextOptions }, use) => use(contextOptions.javaScriptEnabled ?? true), { option: true }],
-  locale: [({ contextOptions }, use) => use(contextOptions.locale ?? "en-US"), { option: true }],
-  offline: [({ contextOptions }, use) => use(contextOptions.offline ?? false), { option: true }],
-  permissions: [({ contextOptions }, use) => use(contextOptions.permissions), { option: true }],
-  proxy: [({ contextOptions }, use) => use(contextOptions.proxy), { option: true }],
-  storageState: [({ contextOptions }, use) => use(contextOptions.storageState), { option: true }],
-  clientCertificates: [({ contextOptions }, use) => use(contextOptions.clientCertificates), { option: true }],
-  timezoneId: [({ contextOptions }, use) => use(contextOptions.timezoneId), { option: true }],
-  userAgent: [({ contextOptions }, use) => use(contextOptions.userAgent), { option: true }],
-  viewport: [({ contextOptions }, use) => use(contextOptions.viewport === void 0 ? { width: 1280, height: 720 } : contextOptions.viewport), { option: true }],
-  actionTimeout: [0, { option: true }],
-  testIdAttribute: ["data-testid", { option: true }],
-  navigationTimeout: [0, { option: true }],
+  acceptDownloads: [({ contextOptions }, use) => use(contextOptions.acceptDownloads ?? true), { option: true, box: true }],
+  bypassCSP: [({ contextOptions }, use) => use(contextOptions.bypassCSP ?? false), { option: true, box: true }],
+  colorScheme: [({ contextOptions }, use) => use(contextOptions.colorScheme === void 0 ? "light" : contextOptions.colorScheme), { option: true, box: true }],
+  deviceScaleFactor: [({ contextOptions }, use) => use(contextOptions.deviceScaleFactor), { option: true, box: true }],
+  extraHTTPHeaders: [({ contextOptions }, use) => use(contextOptions.extraHTTPHeaders), { option: true, box: true }],
+  geolocation: [({ contextOptions }, use) => use(contextOptions.geolocation), { option: true, box: true }],
+  hasTouch: [({ contextOptions }, use) => use(contextOptions.hasTouch ?? false), { option: true, box: true }],
+  httpCredentials: [({ contextOptions }, use) => use(contextOptions.httpCredentials), { option: true, box: true }],
+  ignoreHTTPSErrors: [({ contextOptions }, use) => use(contextOptions.ignoreHTTPSErrors ?? false), { option: true, box: true }],
+  isMobile: [({ contextOptions }, use) => use(contextOptions.isMobile ?? false), { option: true, box: true }],
+  javaScriptEnabled: [({ contextOptions }, use) => use(contextOptions.javaScriptEnabled ?? true), { option: true, box: true }],
+  locale: [({ contextOptions }, use) => use(contextOptions.locale ?? "en-US"), { option: true, box: true }],
+  offline: [({ contextOptions }, use) => use(contextOptions.offline ?? false), { option: true, box: true }],
+  permissions: [({ contextOptions }, use) => use(contextOptions.permissions), { option: true, box: true }],
+  proxy: [({ contextOptions }, use) => use(contextOptions.proxy), { option: true, box: true }],
+  storageState: [({ contextOptions }, use) => use(contextOptions.storageState), { option: true, box: true }],
+  clientCertificates: [({ contextOptions }, use) => use(contextOptions.clientCertificates), { option: true, box: true }],
+  timezoneId: [({ contextOptions }, use) => use(contextOptions.timezoneId), { option: true, box: true }],
+  userAgent: [({ contextOptions }, use) => use(contextOptions.userAgent), { option: true, box: true }],
+  viewport: [({ contextOptions }, use) => use(contextOptions.viewport === void 0 ? { width: 1280, height: 720 } : contextOptions.viewport), { option: true, box: true }],
+  actionTimeout: [0, { option: true, box: true }],
+  testIdAttribute: ["data-testid", { option: true, box: true }],
+  navigationTimeout: [0, { option: true, box: true }],
   baseURL: [async ({}, use) => {
     await use(process.env.PLAYWRIGHT_TEST_BASE_URL);
-  }, { option: true }],
-  serviceWorkers: [({ contextOptions }, use) => use(contextOptions.serviceWorkers ?? "allow"), { option: true }],
-  contextOptions: [{}, { option: true }],
+  }, { option: true, box: true }],
+  serviceWorkers: [({ contextOptions }, use) => use(contextOptions.serviceWorkers ?? "allow"), { option: true, box: true }],
+  contextOptions: [{}, { option: true, box: true }],
   _combinedContextOptions: [async ({
     acceptDownloads,
     bypassCSP,
@@ -221,7 +217,7 @@ const playwrightFixtures = {
     if (testIdAttribute)
       playwrightLibrary.selectors.setTestIdAttribute(testIdAttribute);
     testInfo.snapshotSuffix = process.platform;
-    if ((0, import_utils.debugMode)())
+    if ((0, import_utils.debugMode)() === "inspector")
       testInfo._setDebugMode();
     playwright._defaultContextOptions = _combinedContextOptions;
     playwright._defaultContextTimeout = actionTimeout || 0;
@@ -310,6 +306,7 @@ const playwrightFixtures = {
     const videoMode = normalizeVideoMode(video);
     const captureVideo = shouldCaptureVideo(videoMode, testInfo) && !_reuseContext;
     const contexts = /* @__PURE__ */ new Map();
+    let counter = 0;
     await use(async (options) => {
       const hook = testInfoImpl._currentHookType();
       if (hook === "beforeAll" || hook === "afterAll") {
@@ -326,10 +323,6 @@ const playwrightFixtures = {
         }
       } : {};
       const context = await browser.newContext({ ...videoOptions, ...options });
-      const contextData = { pagesWithVideo: [] };
-      contexts.set(context, contextData);
-      if (captureVideo)
-        context.on("page", (page) => contextData.pagesWithVideo.push(page));
       if (process.env.PW_CLOCK === "frozen") {
         await context._wrapApiCall(async () => {
           await context.clock.install({ time: 0 });
@@ -340,33 +333,39 @@ const playwrightFixtures = {
           await context.clock.install({ time: 0 });
         }, { internal: true });
       }
-      return context;
-    });
-    let counter = 0;
-    const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
-    await Promise.all([...contexts.keys()].map(async (context) => {
-      await context._wrapApiCall(async () => {
+      let closed = false;
+      const close = async () => {
+        if (closed)
+          return;
+        closed = true;
+        const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
         await context.close({ reason: closeReason });
-      }, { internal: true });
-      const testFailed = testInfo.status !== testInfo.expectedStatus;
-      const preserveVideo = captureVideo && (videoMode === "on" || testFailed && videoMode === "retain-on-failure" || videoMode === "on-first-retry" && testInfo.retry === 1);
-      if (preserveVideo) {
-        const { pagesWithVideo: pagesForVideo } = contexts.get(context);
-        const videos = pagesForVideo.map((p) => p.video()).filter(Boolean);
-        await Promise.all(videos.map(async (v) => {
-          try {
-            const savedPath = testInfo.outputPath(`video${counter ? "-" + counter : ""}.webm`);
-            ++counter;
-            await v.saveAs(savedPath);
-            testInfo.attachments.push({ name: "video", path: savedPath, contentType: "video/webm" });
-          } catch (e) {
-          }
-        }));
-      }
-    }));
+        const testFailed = testInfo.status !== testInfo.expectedStatus;
+        const preserveVideo = captureVideo && (videoMode === "on" || testFailed && videoMode === "retain-on-failure" || videoMode === "on-first-retry" && testInfo.retry === 1);
+        if (preserveVideo) {
+          const { pagesWithVideo: pagesForVideo } = contexts.get(context);
+          const videos = pagesForVideo.map((p) => p.video()).filter((video2) => !!video2);
+          await Promise.all(videos.map(async (v) => {
+            try {
+              const savedPath = testInfo.outputPath(`video${counter ? "-" + counter : ""}.webm`);
+              ++counter;
+              await v.saveAs(savedPath);
+              testInfo.attachments.push({ name: "video", path: savedPath, contentType: "video/webm" });
+            } catch (e) {
+            }
+          }));
+        }
+      };
+      const contextData = { close, pagesWithVideo: [] };
+      if (captureVideo)
+        context.on("page", (page) => contextData.pagesWithVideo.push(page));
+      contexts.set(context, contextData);
+      return { context, close };
+    });
+    await Promise.all([...contexts.values()].map((data) => data.close()));
   }, { scope: "test", title: "context", box: true }],
-  _optionContextReuseMode: ["none", { scope: "worker", option: true }],
-  _optionConnectOptions: [void 0, { scope: "worker", option: true }],
+  _optionContextReuseMode: ["none", { scope: "worker", option: true, box: true }],
+  _optionConnectOptions: [void 0, { scope: "worker", option: true, box: true }],
   _reuseContext: [async ({ video, _optionContextReuseMode }, use) => {
     let mode = _optionContextReuseMode;
     if (process.env.PW_TEST_REUSE_CONTEXT)
@@ -374,17 +373,19 @@ const playwrightFixtures = {
     const reuse = mode === "when-possible" && normalizeVideoMode(video) === "off";
     await use(reuse);
   }, { scope: "worker", title: "context", box: true }],
-  context: async ({ playwright, browser, _reuseContext, _contextFactory }, use, testInfo) => {
-    attachConnectedHeaderIfNeeded(testInfo, browser);
+  context: async ({ browser, _reuseContext, _contextFactory }, use, testInfo) => {
+    const browserImpl = browser;
+    attachConnectedHeaderIfNeeded(testInfo, browserImpl);
     if (!_reuseContext) {
-      await use(await _contextFactory());
+      const { context: context2, close } = await _contextFactory();
+      await use(context2);
+      await close();
       return;
     }
-    const defaultContextOptions = playwright.chromium._defaultContextOptions;
-    const context = await browser._newContextForReuse(defaultContextOptions);
+    const context = await browserImpl._wrapApiCall(() => browserImpl._newContextForReuse(), { internal: true });
     await use(context);
     const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
-    await browser._disconnectFromReusedContext(closeReason);
+    await browserImpl._wrapApiCall(() => browserImpl._disconnectFromReusedContext(closeReason), { internal: true });
   },
   page: async ({ context, _reuseContext }, use) => {
     if (!_reuseContext) {
@@ -548,7 +549,9 @@ class ArtifactsRecorder {
     const screenshotOptions = typeof screenshot === "string" ? void 0 : screenshot;
     this._startedCollectingArtifacts = Symbol("startedCollectingArtifacts");
     this._screenshotRecorder = new SnapshotRecorder(this, normalizeScreenshotMode(screenshot), "screenshot", "image/png", ".png", async (page, path2) => {
-      await page.screenshot({ ...screenshotOptions, timeout: 5e3, path: path2, caret: "initial" });
+      await page._wrapApiCall(async () => {
+        await page.screenshot({ ...screenshotOptions, timeout: 5e3, path: path2, caret: "initial" });
+      }, { internal: true });
     });
   }
   async willStartTest(testInfo) {
@@ -560,10 +563,10 @@ class ArtifactsRecorder {
     await Promise.all(existingApiRequests.map((c) => this.didCreateRequestContext(c)));
   }
   async didCreateBrowserContext(context) {
-    await this._startTraceChunkOnContextCreation(context.tracing);
+    await this._startTraceChunkOnContextCreation(context, context.tracing);
   }
   async willCloseBrowserContext(context) {
-    await this._stopTracing(context.tracing);
+    await this._stopTracing(context, context.tracing);
     await this._screenshotRecorder.captureTemporary(context);
     await this._takePageSnapshot(context);
   }
@@ -578,17 +581,17 @@ class ArtifactsRecorder {
     if (!page)
       return;
     try {
-      this._pageSnapshot = await page._snapshotForAI({ timeout: 5e3 });
+      await page._wrapApiCall(async () => {
+        this._pageSnapshot = await page._snapshotForAI({ timeout: 5e3 });
+      }, { internal: true });
     } catch {
     }
   }
   async didCreateRequestContext(context) {
-    const tracing2 = context._tracing;
-    await this._startTraceChunkOnContextCreation(tracing2);
+    await this._startTraceChunkOnContextCreation(context, context._tracing);
   }
   async willCloseRequestContext(context) {
-    const tracing2 = context._tracing;
-    await this._stopTracing(tracing2);
+    await this._stopTracing(context, context._tracing);
   }
   async didFinishTestFunction() {
     await this._screenshotRecorder.maybeCapture();
@@ -598,10 +601,9 @@ class ArtifactsRecorder {
     const leftoverContexts = this._playwright._allContexts();
     const leftoverApiRequests = Array.from(this._playwright.request._contexts);
     await Promise.all(leftoverContexts.map(async (context2) => {
-      await this._stopTracing(context2.tracing);
+      await this._stopTracing(context2, context2.tracing);
     }).concat(leftoverApiRequests.map(async (context2) => {
-      const tracing2 = context2._tracing;
-      await this._stopTracing(tracing2);
+      await this._stopTracing(context2, context2._tracing);
     })));
     await this._screenshotRecorder.persistTemporary();
     const context = leftoverContexts[0];
@@ -624,30 +626,34 @@ class ArtifactsRecorder {
       }, void 0);
     }
   }
-  async _startTraceChunkOnContextCreation(tracing2) {
-    const options = this._testInfo._tracing.traceOptions();
-    if (options) {
-      const title = this._testInfo._tracing.traceTitle();
-      const name = this._testInfo._tracing.generateNextTraceRecordingName();
-      if (!tracing2[kTracingStarted]) {
-        await tracing2.start({ ...options, title, name });
-        tracing2[kTracingStarted] = true;
+  async _startTraceChunkOnContextCreation(channelOwner, tracing2) {
+    await channelOwner._wrapApiCall(async () => {
+      const options = this._testInfo._tracing.traceOptions();
+      if (options) {
+        const title = this._testInfo._tracing.traceTitle();
+        const name = this._testInfo._tracing.generateNextTraceRecordingName();
+        if (!tracing2[kTracingStarted]) {
+          await tracing2.start({ ...options, title, name });
+          tracing2[kTracingStarted] = true;
+        } else {
+          await tracing2.startChunk({ title, name });
+        }
       } else {
-        await tracing2.startChunk({ title, name });
-      }
-    } else {
-      if (tracing2[kTracingStarted]) {
-        tracing2[kTracingStarted] = false;
-        await tracing2.stop();
+        if (tracing2[kTracingStarted]) {
+          tracing2[kTracingStarted] = false;
+          await tracing2.stop();
+        }
       }
-    }
+    }, { internal: true });
   }
-  async _stopTracing(tracing2) {
-    if (tracing2[this._startedCollectingArtifacts])
-      return;
-    tracing2[this._startedCollectingArtifacts] = true;
-    if (this._testInfo._tracing.traceOptions() && tracing2[kTracingStarted])
-      await tracing2.stopChunk({ path: this._testInfo._tracing.maybeGenerateNextTraceRecordingPath() });
+  async _stopTracing(channelOwner, tracing2) {
+    await channelOwner._wrapApiCall(async () => {
+      if (tracing2[this._startedCollectingArtifacts])
+        return;
+      tracing2[this._startedCollectingArtifacts] = true;
+      if (this._testInfo._tracing.traceOptions() && tracing2[kTracingStarted])
+        await tracing2.stopChunk({ path: this._testInfo._tracing.maybeGenerateNextTraceRecordingPath() });
+    }, { internal: true });
   }
 }
 function renderTitle(type, method, params, title) {

package/lib/program.js

@@ -172,6 +172,7 @@ async function runTests(args, opts) {
   config.cliProjectFilter = opts.project || void 0;
   config.cliPassWithNoTests = !!opts.passWithNoTests;
   config.cliLastFailed = !!opts.lastFailed;
+  config.cliFilterFile = opts.filter ? import_path.default.resolve(process.cwd(), opts.filter) : void 0;
   (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
   if (opts.ui || opts.uiHost || opts.uiPort) {
     if (opts.onlyChanged)
@@ -346,6 +347,7 @@ const testOptions = [
   ["-c, --config <file>", { description: `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"` }],
   ["--debug", { description: `Run tests with Playwright Inspector. Shortcut for "PWDEBUG=1" environment variable and "--timeout=0 --max-failures=1 --headed --workers=1" options` }],
   ["--fail-on-flaky-tests", { description: `Fail if any test is flagged as flaky (default: false)` }],
+  ["--filter <file>", { description: `Path to a test filter file. See documentation for details.` }],
   ["--forbid-only", { description: `Fail if test.only is called (default: false)` }],
   ["--fully-parallel", { description: `Run all tests in parallel (default: false)` }],
   ["--global-timeout <timeout>", { description: `Maximum time this test suite can run in milliseconds (default: unlimited)` }],

package/lib/runner/lastRun.js

@@ -46,7 +46,8 @@ class LastRunReporter {
       return;
     try {
       const lastRunInfo = JSON.parse(await import_fs.default.promises.readFile(this._lastRunFile, "utf8"));
-      this._config.lastFailedTestIdMatcher = (id) => lastRunInfo.failedTests.includes(id);
+      const failedTestIds = new Set(lastRunInfo.failedTests);
+      this._config.postShardTestFilters.push((test) => failedTestIds.has(test.id));
     } catch {
     }
   }
@@ -62,10 +63,12 @@ class LastRunReporter {
   async onEnd(result) {
     if (!this._lastRunFile || this._config.cliListOnly)
       return;
+    const lastRunInfo = {
+      status: result.status,
+      failedTests: this._suite?.allTests().filter((t) => !t.ok()).map((t) => t.id) || []
+    };
     await import_fs.default.promises.mkdir(import_path.default.dirname(this._lastRunFile), { recursive: true });
-    const failedTests = this._suite?.allTests().filter((t) => !t.ok()).map((t) => t.id);
-    const lastRunReport = JSON.stringify({ status: result.status, failedTests }, void 0, 2);
-    await import_fs.default.promises.writeFile(this._lastRunFile, lastRunReport);
+    await import_fs.default.promises.writeFile(this._lastRunFile, JSON.stringify(lastRunInfo, void 0, 2));
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/runner/loadUtils.js

@@ -112,7 +112,7 @@ async function loadFileSuites(testRun, mode, errors) {
     testRun.projectSuites.set(project, suites);
   }
 }
-async function createRootSuite(testRun, errors, shouldFilterOnly, additionalFileMatcher) {
+async function createRootSuite(testRun, errors, shouldFilterOnly) {
   const config = testRun.config;
   const rootSuite = new import_test.Suite("", "root");
   const projectSuites = /* @__PURE__ */ new Map();
@@ -125,7 +125,7 @@ async function createRootSuite(testRun, errors, shouldFilterOnly, additionalFile
     for (const [project, fileSuites] of testRun.projectSuites) {
       const projectSuite = createProjectSuite(project, fileSuites);
       projectSuites.set(project, projectSuite);
-      const filteredProjectSuite = filterProjectSuite(projectSuite, { cliFileFilters, cliTitleMatcher, testIdMatcher: config.testIdMatcher, additionalFileMatcher });
+      const filteredProjectSuite = filterProjectSuite(projectSuite, { cliFileFilters, cliTitleMatcher, testFilters: config.preOnlyTestFilters });
       filteredProjectSuites.set(project, filteredProjectSuite);
     }
   }
@@ -166,8 +166,8 @@ async function createRootSuite(testRun, errors, shouldFilterOnly, additionalFile
     }
     (0, import_suiteUtils.filterTestsRemoveEmptySuites)(rootSuite, (test) => testsInThisShard.has(test));
   }
-  if (config.lastFailedTestIdMatcher)
-    (0, import_suiteUtils.filterByTestIds)(rootSuite, config.lastFailedTestIdMatcher);
+  if (config.postShardTestFilters.length)
+    (0, import_suiteUtils.filterTestsRemoveEmptySuites)(rootSuite, (test) => config.postShardTestFilters.every((filter) => filter(test)));
   {
     const projectClosure2 = new Map((0, import_projectUtils.buildProjectsClosure)(rootSuite.suites.map((suite) => suite._fullProject)));
     for (const [project, level] of projectClosure2.entries()) {
@@ -192,17 +192,15 @@ function createProjectSuite(project, fileSuites) {
   return projectSuite;
 }
 function filterProjectSuite(projectSuite, options) {
-  if (!options.cliFileFilters.length && !options.cliTitleMatcher && !options.testIdMatcher && !options.additionalFileMatcher)
+  if (!options.cliFileFilters.length && !options.cliTitleMatcher && !options.testFilters.length)
     return projectSuite;
   const result = projectSuite._deepClone();
   if (options.cliFileFilters.length)
     (0, import_suiteUtils.filterByFocusedLine)(result, options.cliFileFilters);
-  if (options.testIdMatcher)
-    (0, import_suiteUtils.filterByTestIds)(result, options.testIdMatcher);
   (0, import_suiteUtils.filterTestsRemoveEmptySuites)(result, (test) => {
-    if (options.cliTitleMatcher && !options.cliTitleMatcher(test._grepTitleWithTags()))
+    if (!options.testFilters.every((filter) => filter(test)))
       return false;
-    if (options.additionalFileMatcher && !options.additionalFileMatcher(test.location.file))
+    if (options.cliTitleMatcher && !options.cliTitleMatcher(test._grepTitleWithTags()))
       return false;
     return true;
   });

package/lib/runner/tasks.js

@@ -243,12 +243,20 @@ function createLoadTask(mode, options) {
         for (const plugin of testRun.config.plugins)
           await plugin.instance?.populateDependencies?.();
       }
-      let cliOnlyChangedMatcher = void 0;
       if (testRun.config.cliOnlyChanged) {
         const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);
-        cliOnlyChangedMatcher = (file) => changedFiles.has(file);
+        testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));
       }
-      testRun.rootSuite = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly, cliOnlyChangedMatcher);
+      if (testRun.config.cliFilterFile) {
+        try {
+          testRun.config.preOnlyTestFilters.push(await (0, import_util2.loadTestFilterFile)(testRun.config.cliFilterFile));
+        } catch (error) {
+          if (options.failOnLoadErrors)
+            throw error;
+          softErrors.push(error);
+        }
+      }
+      testRun.rootSuite = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);
       testRun.failureTracker.onRootSuite(testRun.rootSuite);
       if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged) {
         if (testRun.config.cliArgs.length) {

package/lib/runner/testServer.js

@@ -286,14 +286,17 @@ class TestServerDispatcher {
     const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([wireReporter]), overrides);
     if (!config)
       return { status: "failed" };
-    const testIdSet = params.testIds ? new Set(params.testIds) : null;
     config.cliListOnly = false;
     config.cliPassWithNoTests = true;
     config.cliArgs = params.locations || [];
     config.cliGrep = params.grep;
     config.cliGrepInvert = params.grepInvert;
     config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    config.testIdMatcher = testIdSet ? (id) => testIdSet.has(id) : void 0;
+    config.preOnlyTestFilters = [];
+    if (params.testIds) {
+      const testIdSet = new Set(params.testIds);
+      config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
+    }
     const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
     const reporter = new import_internalReporter.InternalReporter([...configReporters, wireReporter]);
     const stop = new import_utils.ManualPromise();

package/lib/util.js

@@ -47,6 +47,7 @@ __export(util_exports, {
   formatLocation: () => formatLocation,
   getContainedPath: () => getContainedPath,
   getPackageJsonPath: () => getPackageJsonPath,
+  loadTestFilterFile: () => loadTestFilterFile,
   mergeObjects: () => mergeObjects,
   normalizeAndSaveAttachment: () => normalizeAndSaveAttachment,
   relativeFilePath: () => relativeFilePath,
@@ -390,6 +391,22 @@ function stepTitle(category, title) {
       return `[${category}] ${title}`;
   }
 }
+async function loadTestFilterFile(filePath) {
+  try {
+    const data = JSON.parse(await import_fs.default.promises.readFile(filePath, "utf8"));
+    if (!data || typeof data !== "object" || !Array.isArray(data.titlePath) || !data.titlePath.every((path2) => Array.isArray(path2)))
+      throw new Error(`Wrong test filter file format`);
+    const toId = (titlePath) => {
+      const [project, file, ...titles] = titlePath;
+      return `${project}${(0, import_utils.toPosixPath)(file)}${titles.join("")}`;
+    };
+    const ids = new Set(data.titlePath.map((titlePath) => toId(titlePath)));
+    return (test) => ids.has(toId(test.titlePath()));
+  } catch (error) {
+    (0, import_utils.rewriteErrorMessage)(error, `Failed to read test filter file "${filePath}": ${error.message}`);
+    throw error;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addSuffixToFilePath,
@@ -411,6 +428,7 @@ function stepTitle(category, title) {
   formatLocation,
   getContainedPath,
   getPackageJsonPath,
+  loadTestFilterFile,
   mergeObjects,
   normalizeAndSaveAttachment,
   relativeFilePath,

package/lib/worker/fixtureRunner.js

@@ -32,11 +32,12 @@ class Fixture {
     this.runner = runner;
     this.registration = registration;
     this.value = null;
-    const shouldGenerateStep = !this.registration.box && !this.registration.option;
     const isUserFixture = this.registration.location && (0, import_util.filterStackFile)(this.registration.location.file);
     const title = this.registration.customTitle || this.registration.name;
     const location = isUserFixture ? this.registration.location : void 0;
-    this._stepInfo = shouldGenerateStep ? { title, category: "fixture", location } : void 0;
+    this._stepInfo = { title, category: "fixture", location };
+    if (this.registration.box)
+      this._stepInfo.visibility = isUserFixture ? "hidden" : "internal";
     this._setupDescription = {
       title,
       phase: "setup",
@@ -54,11 +55,9 @@ class Fixture {
       this.value = this.registration.fn;
       return;
     }
-    const run = () => testInfo._runWithTimeout({ ...runnable, fixture: this._setupDescription }, () => this._setupInternal(testInfo));
-    if (this._stepInfo)
-      await testInfo._runAsStep(this._stepInfo, run);
-    else
-      await run();
+    await testInfo._runAsStep(this._stepInfo, async () => {
+      await testInfo._runWithTimeout({ ...runnable, fixture: this._setupDescription }, () => this._setupInternal(testInfo));
+    });
   }
   async _setupInternal(testInfo) {
     const params = {};
@@ -107,11 +106,9 @@ class Fixture {
     try {
       const fixtureRunnable = { ...runnable, fixture: this._teardownDescription };
       if (!testInfo._timeoutManager.isTimeExhaustedFor(fixtureRunnable)) {
-        const run = () => testInfo._runWithTimeout(fixtureRunnable, () => this._teardownInternal());
-        if (this._stepInfo)
-          await testInfo._runAsStep(this._stepInfo, run);
-        else
-          await run();
+        await testInfo._runAsStep(this._stepInfo, async () => {
+          await testInfo._runWithTimeout(fixtureRunnable, () => this._teardownInternal());
+        });
       }
     } finally {
       for (const dep of this._deps)

package/lib/worker/testInfo.js

@@ -185,18 +185,22 @@ class TestInfoImpl {
         parentStep = this._parentStep();
     }
     const filteredStack = (0, import_util.filteredStackTrace)((0, import_utils.captureRawStack)());
-    data.boxedStack = parentStep?.boxedStack;
-    if (!data.boxedStack && data.box) {
-      data.boxedStack = filteredStack.slice(1);
-      data.location = data.location || data.boxedStack[0];
+    let boxedStack = parentStep?.boxedStack;
+    let location = data.location;
+    if (!boxedStack && data.box) {
+      boxedStack = filteredStack.slice(1);
+      location = location || boxedStack[0];
     }
-    data.location = data.location || filteredStack[0];
-    const attachmentIndices = [];
+    location = location || filteredStack[0];
+    const visibility = parentStep?.visibility === "internal" || data.visibility === "internal" ? "internal" : parentStep?.visibility === "hidden" || data.visibility === "hidden" ? "hidden" : "default";
     const step = {
-      stepId,
       ...data,
+      stepId,
+      visibility,
+      boxedStack,
+      location,
       steps: [],
-      attachmentIndices,
+      attachmentIndices: [],
       info: new TestStepInfoImpl(this, stepId, data.title, parentStep?.info),
       complete: (result) => {
         if (step.endWallTime)
@@ -206,9 +210,9 @@ class TestInfoImpl {
           if (typeof result.error === "object" && !result.error?.[stepSymbol])
             result.error[stepSymbol] = step;
           const error = (0, import_util2.testInfoError)(result.error);
-          if (data.boxedStack)
+          if (step.boxedStack)
             error.stack = `${error.message}
-${(0, import_utils.stringifyStackFrames)(data.boxedStack).join("\n")}`;
+${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
           step.error = error;
         }
         if (!step.error) {
@@ -220,39 +224,50 @@ ${(0, import_utils.stringifyStackFrames)(data.boxedStack).join("\n")}`;
             }
           }
         }
-        const payload2 = {
-          testId: this.testId,
-          stepId,
-          wallTime: step.endWallTime,
-          error: step.error,
-          suggestedRebaseline: result.suggestedRebaseline,
-          annotations: step.info.annotations
-        };
-        this._onStepEnd(payload2);
-        const errorForTrace = step.error ? { name: "", message: step.error.message || "", stack: step.error.stack } : void 0;
-        const attachments = attachmentIndices.map((i) => this.attachments[i]);
-        this._tracing.appendAfterActionForStep(stepId, errorForTrace, attachments, step.info.annotations);
+        if (visibility === "default") {
+          const payload = {
+            testId: this.testId,
+            stepId,
+            wallTime: step.endWallTime,
+            error: step.error,
+            suggestedRebaseline: result.suggestedRebaseline,
+            annotations: step.info.annotations
+          };
+          this._onStepEnd(payload);
+        }
+        if (visibility !== "internal") {
+          const errorForTrace = step.error ? { name: "", message: step.error.message || "", stack: step.error.stack } : void 0;
+          const attachments = step.attachmentIndices.map((i) => this.attachments[i]);
+          this._tracing.appendAfterActionForStep(stepId, errorForTrace, attachments, step.info.annotations);
+        }
       }
     };
     const parentStepList = parentStep ? parentStep.steps : this._steps;
     parentStepList.push(step);
     this._stepMap.set(stepId, step);
-    const payload = {
-      testId: this.testId,
-      stepId,
-      parentStepId: parentStep ? parentStep.stepId : void 0,
-      title: data.title,
-      category: data.category,
-      wallTime: Date.now(),
-      location: data.location
-    };
-    this._onStepBegin(payload);
-    this._tracing.appendBeforeActionForStep(stepId, parentStep?.stepId, {
-      title: data.title,
-      category: data.category,
-      params: data.params,
-      stack: data.location ? [data.location] : []
-    });
+    if (visibility === "default") {
+      const payload = {
+        testId: this.testId,
+        stepId,
+        parentStepId: parentStep ? parentStep.stepId : void 0,
+        title: step.title,
+        category: step.category,
+        wallTime: Date.now(),
+        location: step.location
+      };
+      this._onStepBegin(payload);
+    }
+    if (visibility !== "internal") {
+      this._tracing.appendBeforeActionForStep({
+        stepId,
+        parentId: parentStep?.stepId,
+        title: step.title,
+        category: step.category,
+        params: step.params,
+        stack: step.location ? [step.location] : [],
+        visibility: visibility === "hidden" ? "hidden" : void 0
+      });
+    }
     return step;
   }
   _interrupt() {
@@ -327,9 +342,9 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
     if (stepId) {
       this._stepMap.get(stepId).attachmentIndices.push(index);
     } else {
-      const callId = `attach@${(0, import_utils.createGuid)()}`;
-      this._tracing.appendBeforeActionForStep(callId, void 0, { title: attachment.name, category: "test.attach", stack: [] });
-      this._tracing.appendAfterActionForStep(callId, void 0, [attachment]);
+      const stepId2 = `attach@${(0, import_utils.createGuid)()}`;
+      this._tracing.appendBeforeActionForStep({ stepId: stepId2, title: attachment.name, category: "test.attach", stack: [] });
+      this._tracing.appendAfterActionForStep(stepId2, void 0, [attachment]);
     }
     this._onAttach({
       testId: this.testId,

package/lib/worker/testTracing.js

@@ -221,18 +221,19 @@ class TestTracing {
       base64: typeof chunk === "string" ? void 0 : chunk.toString("base64")
     });
   }
-  appendBeforeActionForStep(callId, parentId, options) {
+  appendBeforeActionForStep(options) {
     this._appendTraceEvent({
       type: "before",
-      callId,
-      stepId: callId,
-      parentId,
+      callId: options.stepId,
+      stepId: options.stepId,
+      parentId: options.parentId,
       startTime: (0, import_utils.monotonicTime)(),
       class: "Test",
-      method: "step",
+      method: options.category,
       title: (0, import_util.stepTitle)(options.category, options.title),
       params: Object.fromEntries(Object.entries(options.params || {}).map(([name, value]) => [name, generatePreview(value)])),
-      stack: options.stack
+      stack: options.stack,
+      visibility: options.visibility
     });
   }
   appendAfterActionForStep(callId, error, attachments = [], annotations) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.55.0-alpha-2025-08-06",
+  "version": "1.55.0-alpha-2025-08-08",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -56,7 +56,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.55.0-alpha-2025-08-06"
+    "playwright-core": "1.55.0-alpha-2025-08-08"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"