playwright 1.56.1 → 1.57.0

package/lib/runner/dispatcher.js

@@ -26,6 +26,8 @@ var import_utils2 = require("playwright-core/lib/utils");
 var import_rebase = require("./rebase");
 var import_workerHost = require("./workerHost");
 var import_ipc = require("../common/ipc");
+var import_internalReporter = require("../reporters/internalReporter");
+var import_util = require("../util");
 class Dispatcher {
   constructor(config, reporter, failureTracker) {
     this._workerSlots = [];
@@ -70,7 +72,7 @@ class Dispatcher {
       return;
     }
     this._queue.splice(jobIndex, 1);
-    const jobDispatcher = new JobDispatcher(job, this._reporter, this._failureTracker, () => this.stop().catch(() => {
+    const jobDispatcher = new JobDispatcher(job, this._config, this._reporter, this._failureTracker, () => this.stop().catch(() => {
     }));
     this._workerSlots[workerIndex].busy = true;
     this._workerSlots[workerIndex].jobDispatcher = jobDispatcher;
@@ -209,7 +211,7 @@ class Dispatcher {
   }
 }
 class JobDispatcher {
-  constructor(job, reporter, failureTracker, stopCallback) {
+  constructor(job, config, reporter, failureTracker, stopCallback) {
     this.jobResult = new import_utils.ManualPromise();
     this._listeners = [];
     this._failedTests = /* @__PURE__ */ new Set();
@@ -219,6 +221,7 @@ class JobDispatcher {
     this._parallelIndex = 0;
     this._workerIndex = 0;
     this.job = job;
+    this._config = config;
     this._reporter = reporter;
     this._failureTracker = failureTracker;
     this._stopCallback = stopCallback;
@@ -449,10 +452,30 @@ class JobDispatcher {
       import_utils.eventsHelper.addEventListener(worker, "stepBegin", this._onStepBegin.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "stepEnd", this._onStepEnd.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "attach", this._onAttach.bind(this)),
+      import_utils.eventsHelper.addEventListener(worker, "testPaused", this._onTestPaused.bind(this, worker)),
       import_utils.eventsHelper.addEventListener(worker, "done", this._onDone.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "exit", this.onExit.bind(this))
     ];
   }
+  _onTestPaused(worker, params) {
+    const sendMessage = async (message) => {
+      try {
+        if (this.jobResult.isDone())
+          throw new Error("Test has already stopped");
+        const response = await worker.sendCustomMessage({ testId: params.testId, request: message.request });
+        if (response.error)
+          (0, import_internalReporter.addLocationAndSnippetToError)(this._config.config, response.error);
+        return response;
+      } catch (e) {
+        const error = (0, import_util.serializeError)(e);
+        (0, import_internalReporter.addLocationAndSnippetToError)(this._config.config, error);
+        return { response: void 0, error };
+      }
+    };
+    for (const error of params.errors)
+      (0, import_internalReporter.addLocationAndSnippetToError)(this._config.config, error);
+    this._failureTracker.onTestPaused?.({ ...params, sendMessage });
+  }
   skipWholeJob() {
     const allTestsSkipped = this.job.tests.every((test) => test.expectedStatus === "skipped");
     if (allTestsSkipped && !this._failureTracker.hasReachedMaxFailures()) {
@@ -460,6 +483,7 @@ class JobDispatcher {
         const result = test._appendTestResult();
         this._reporter.onTestBegin?.(test, result);
         result.status = "skipped";
+        result.annotations = [...test.annotations];
         this._reportTestEnd(test, result);
       }
       return true;

package/lib/runner/failureTracker.js

@@ -22,13 +22,13 @@ __export(failureTracker_exports, {
 });
 module.exports = __toCommonJS(failureTracker_exports);
 class FailureTracker {
-  constructor(_config, options) {
-    this._config = _config;
+  constructor(config, options) {
     this._failureCount = 0;
     this._hasWorkerErrors = false;
     this._topLevelProjects = [];
-    this._pauseOnError = options?.pauseOnError ?? false;
-    this._pauseAtEnd = options?.pauseAtEnd ?? false;
+    this._config = config;
+    this._pauseOnError = !!options?.pauseOnError;
+    this._pauseAtEnd = !!options?.pauseAtEnd;
   }
   onRootSuite(rootSuite, topLevelProjects) {
     this._rootSuite = rootSuite;
@@ -45,7 +45,7 @@ class FailureTracker {
     return this._pauseOnError;
   }
   pauseAtEnd(inProject) {
-    return this._pauseAtEnd && this._topLevelProjects.includes(inProject);
+    return this._topLevelProjects.includes(inProject) && this._pauseAtEnd;
   }
   hasReachedMaxFailures() {
     return this.maxFailures() > 0 && this._failureCount >= this.maxFailures();

package/lib/runner/loadUtils.js

@@ -159,7 +159,8 @@ async function createRootSuite(testRun, errors, shouldFilterOnly) {
   if (config.config.shard) {
     const testGroups = [];
     for (const projectSuite of rootSuite.suites) {
-      testGroups.push(...(0, import_testGroups.createTestGroups)(projectSuite, config.config.shard.total));
+      for (const group of (0, import_testGroups.createTestGroups)(projectSuite, config.config.shard.total))
+        testGroups.push(group);
     }
     const testGroupsInThisShard = (0, import_testGroups.filterForShard)(config.config.shard, testGroups);
     const testsInThisShard = /* @__PURE__ */ new Set();

package/lib/runner/loaderHost.js

@@ -48,7 +48,7 @@ class InProcessLoaderHost {
     return true;
   }
   async loadTestFile(file, testErrors) {
-    const result = await (0, import_testLoader.loadTestFile)(file, this._config.config.rootDir, testErrors);
+    const result = await (0, import_testLoader.loadTestFile)(file, this._config, testErrors);
     this._poolBuilder.buildPools(result, testErrors);
     return result;
   }

package/lib/runner/reporters.js

@@ -47,7 +47,7 @@ var import_line = __toESM(require("../reporters/line"));
 var import_list = __toESM(require("../reporters/list"));
 var import_listModeReporter = __toESM(require("../reporters/listModeReporter"));
 var import_reporterV2 = require("../reporters/reporterV2");
-async function createReporters(config, mode, isTestServer, descriptions) {
+async function createReporters(config, mode, descriptions) {
   const defaultReporters = {
     blob: import_blob.BlobReporter,
     dot: mode === "list" ? import_listModeReporter.default : import_dot.default,
@@ -63,7 +63,7 @@ async function createReporters(config, mode, isTestServer, descriptions) {
   descriptions ??= config.config.reporter;
   if (config.configCLIOverrides.additionalReporters)
     descriptions = [...descriptions, ...config.configCLIOverrides.additionalReporters];
-  const runOptions = reporterOptions(config, mode, isTestServer);
+  const runOptions = reporterOptions(config, mode);
   for (const r of descriptions) {
     const [name, arg] = r;
     const options = { ...runOptions, ...arg };
@@ -104,11 +104,10 @@ function createErrorCollectingReporter(screen) {
     errors: () => errors
   };
 }
-function reporterOptions(config, mode, isTestServer) {
+function reporterOptions(config, mode) {
   return {
     configDir: config.configDir,
     _mode: mode,
-    _isTestServer: isTestServer,
     _commandHash: computeCommandHash(config)
   };
 }
@@ -125,6 +124,8 @@ function computeCommandHash(config) {
     command.cliGrepInvert = config.cliGrepInvert;
   if (config.cliOnlyChanged)
     command.cliOnlyChanged = config.cliOnlyChanged;
+  if (config.config.tags.length)
+    command.tags = config.config.tags.join(" ");
   if (Object.keys(command).length)
     parts.push((0, import_utils.calculateSha1)(JSON.stringify(command)).substring(0, 7));
   return parts.join("-");

package/lib/runner/testRunner.js

@@ -51,7 +51,8 @@ var import_reporters = require("./reporters");
 var import_tasks = require("./tasks");
 var import_lastRun = require("./lastRun");
 const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged"
+  TestFilesChanged: "testFilesChanged",
+  TestPaused: "testPaused"
 };
 class TestRunner extends import_events.default {
   constructor(configLocation, configCLIOverrides) {
@@ -93,7 +94,7 @@ class TestRunner extends import_events.default {
   }
   async installBrowsers() {
     const executables = import_server.registry.defaultExecutables();
-    await import_server.registry.install(executables, false);
+    await import_server.registry.install(executables);
   }
   async loadConfig() {
     const { config, error } = await this._loadConfig(this._configCLIOverrides);
@@ -245,16 +246,13 @@ class TestRunner extends import_events.default {
         ...params.video === "on" || params.video === "off" ? { video: params.video } : {},
         ...params.headed !== void 0 ? { headless: !params.headed } : {},
         _optionContextReuseMode: params.reuseContext ? "when-possible" : void 0,
-        _optionConnectOptions: params.connectWsEndpoint ? { wsEndpoint: params.connectWsEndpoint } : void 0
+        _optionConnectOptions: params.connectWsEndpoint ? { wsEndpoint: params.connectWsEndpoint } : void 0,
+        actionTimeout: params.actionTimeout
       },
       ...params.updateSnapshots ? { updateSnapshots: params.updateSnapshots } : {},
       ...params.updateSourceMethod ? { updateSourceMethod: params.updateSourceMethod } : {},
       ...params.workers ? { workers: params.workers } : {}
     };
-    if (params.trace === "on")
-      process.env.PW_LIVE_TRACE_STACKS = "1";
-    else
-      process.env.PW_LIVE_TRACE_STACKS = void 0;
     const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([userReporter]), overrides);
     if (!config)
       return { status: "failed" };
@@ -269,7 +267,7 @@ class TestRunner extends import_events.default {
       const testIdSet = new Set(params.testIds);
       config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
     }
-    const configReporters = params.disableConfigReporters ? [] : await (0, import_reporters.createReporters)(config, "test", true);
+    const configReporters = params.disableConfigReporters ? [] : await (0, import_reporters.createReporters)(config, "test");
     const reporter = new import_internalReporter.InternalReporter([...configReporters, userReporter]);
     const stop = new import_utils.ManualPromise();
     const tasks = [
@@ -278,6 +276,7 @@ class TestRunner extends import_events.default {
       ...(0, import_tasks.createRunTestsTasks)(config)
     ];
     const testRun = new import_tasks.TestRun(config, reporter, { pauseOnError: params.pauseOnError, pauseAtEnd: params.pauseAtEnd });
+    testRun.failureTracker.onTestPaused = (params2) => this.emit(TestRunnerEvent.TestPaused, params2);
     const run = (0, import_tasks.runTasks)(testRun, tasks, 0, stop).then(async (status) => {
       this._testRun = void 0;
       return status;
@@ -363,7 +362,7 @@ async function runAllTestsWithConfig(config) {
   const listOnly = config.cliListOnly;
   (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
   (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));
-  const reporters = await (0, import_reporters.createReporters)(config, listOnly ? "list" : "test", false);
+  const reporters = await (0, import_reporters.createReporters)(config, listOnly ? "list" : "test");
   const lastRun = new import_lastRun.LastRunReporter(config);
   if (config.cliLastFailed)
     await lastRun.filterLastFailed();

package/lib/runner/testServer.js

@@ -45,6 +45,7 @@ var import_testRunner = require("./testRunner");
 const originalDebugLog = import_utilsBundle.debug.log;
 const originalStdoutWrite = process.stdout.write;
 const originalStderrWrite = process.stderr.write;
+const originalStdinIsTTY = process.stdin.isTTY;
 class TestServer {
   constructor(configLocation, configCLIOverrides) {
     this._configLocation = configLocation;
@@ -74,6 +75,7 @@ class TestServerDispatcher {
     };
     this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
     this._testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
+    this._testRunner.on(import_testRunner.TestRunnerEvent.TestPaused, (params) => this._dispatchEvent("testPaused", { errors: params.errors }));
   }
   async _wireReporter(messageSink) {
     return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
@@ -110,7 +112,6 @@ class TestServerDispatcher {
     await this._testRunner.installBrowsers();
   }
   async runGlobalSetup(params) {
-    await this.runGlobalTeardown();
     const { reporter, report } = await this._collectingReporter();
     this._globalSetupReport = report;
     const { status } = await this._testRunner.runGlobalSetup([reporter, new import_list.default()]);
@@ -151,7 +152,9 @@ class TestServerDispatcher {
     const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
     const { status } = await this._testRunner.runTests(wireReporter, {
       ...params,
-      doNotRunDepsOutsideProjectFilter: true
+      doNotRunDepsOutsideProjectFilter: true,
+      pauseAtEnd: params.pauseAtEnd,
+      pauseOnError: params.pauseOnError
     });
     return { status };
   }
@@ -191,17 +194,19 @@ class TestServerDispatcher {
       };
       process.stdout.write = stdoutWrite;
       process.stderr.write = stderrWrite;
+      process.stdin.isTTY = void 0;
     } else {
       import_utilsBundle.debug.log = originalDebugLog;
       process.stdout.write = originalStdoutWrite;
       process.stderr.write = originalStderrWrite;
+      process.stdin.isTTY = originalStdinIsTTY;
     }
   }
 }
 async function runUIMode(configFile, configCLIOverrides, options) {
   const configLocation = (0, import_configLoader.resolveConfigLocation)(configFile);
   return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server, cancelPromise) => {
-    await (0, import_server.installRootRedirect)(server, [], { ...options, webApp: "uiMode.html" });
+    await (0, import_server.installRootRedirect)(server, void 0, { ...options, webApp: "uiMode.html" });
     if (options.host !== void 0 || options.port !== void 0) {
       await (0, import_server.openTraceInBrowser)(server.urlPrefix("human-readable"));
     } else {

package/lib/runner/workerHost.js

@@ -79,6 +79,9 @@ class WorkerHost extends import_processHost.ProcessHost {
   runTestGroup(runPayload) {
     this.sendMessageNoReply({ method: "runTestGroup", params: runPayload });
   }
+  async sendCustomMessage(payload) {
+    return await this.sendMessage({ method: "customMessage", params: payload });
+  }
   hash() {
     return this._hash;
   }

package/lib/worker/testInfo.js

@@ -43,14 +43,13 @@ var import_testTracing = require("./testTracing");
 var import_util2 = require("./util");
 var import_transform = require("../transform/transform");
 class TestInfoImpl {
-  constructor(configInternal, projectInternal, workerParams, test, retry, onStepBegin, onStepEnd, onAttach) {
+  constructor(configInternal, projectInternal, workerParams, test, retry, onStepBegin, onStepEnd, onAttach, onTestPaused) {
     this._snapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
     this._ariaSnapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
-    this._wasInterrupted = false;
+    this._interruptedPromise = new import_utils.ManualPromise();
     this._lastStepId = 0;
     this._steps = [];
     this._stepMap = /* @__PURE__ */ new Map();
-    this._onDidFinishTestFunctions = [];
     this._hasNonRetriableError = false;
     this._hasUnhandledError = false;
     this._allowSkips = false;
@@ -64,6 +63,7 @@ class TestInfoImpl {
     this._onStepBegin = onStepBegin;
     this._onStepEnd = onStepEnd;
     this._onAttach = onAttach;
+    this._onTestPaused = onTestPaused;
     this._startTime = (0, import_utils.monotonicTime)();
     this._startWallTime = Date.now();
     this._requireFile = test?._requireFile ?? "";
@@ -107,11 +107,17 @@ class TestInfoImpl {
       return import_path.default.join(this.project.snapshotDir, relativeTestFilePath + "-snapshots");
     })();
     this._attachmentsPush = this.attachments.push.bind(this.attachments);
-    this.attachments.push = (...attachments) => {
+    const attachmentsPush = (...attachments) => {
       for (const a of attachments)
         this._attach(a, this._parentStep()?.stepId);
       return this.attachments.length;
     };
+    Object.defineProperty(this.attachments, "push", {
+      value: attachmentsPush,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
     this._tracing = new import_testTracing.TestTracing(this, workerParams.artifactsDir);
     this.skip = (0, import_transform.wrapFunctionWithLocation)((location, ...args) => this._modifier("skip", location, args));
     this.fixme = (0, import_transform.wrapFunctionWithLocation)((location, ...args) => this._modifier("fixme", location, args));
@@ -262,7 +268,7 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
       this._tracing.appendBeforeActionForStep({
         stepId,
         parentId: parentStep?.stepId,
-        title: step.title,
+        title: step.shortTitle ?? step.title,
         category: step.category,
         params: step.params,
         stack: step.location ? [step.location] : [],
@@ -272,7 +278,7 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
     return step;
   }
   _interrupt() {
-    this._wasInterrupted = true;
+    this._interruptedPromise.resolve();
     this._timeoutManager.interrupt();
     if (this.status === "passed")
       this.status = "interrupted";
@@ -314,7 +320,7 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
         }
       });
     } catch (error) {
-      if (!this._wasInterrupted && error instanceof import_timeoutManager.TimeoutManagerError)
+      if (!this._interruptedPromise.isDone() && error instanceof import_timeoutManager.TimeoutManagerError)
         this._failWithError(error);
       throw error;
     }
@@ -329,6 +335,14 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
   _setDebugMode() {
     this._timeoutManager.setIgnoreTimeouts();
   }
+  async _didFinishTestFunction() {
+    const shouldPause = this._workerParams.pauseAtEnd && !this._isFailure() || this._workerParams.pauseOnError && this._isFailure();
+    if (shouldPause) {
+      this._onTestPaused({ testId: this.testId, errors: this._isFailure() ? this.errors : [] });
+      await this._interruptedPromise;
+    }
+    await this._onDidFinishTestFunctionCallback?.();
+  }
   // ------------ TestInfo methods ------------
   async attach(name, options = {}) {
     const step = this._addStep({
@@ -337,14 +351,17 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
     });
     this._attach(
       await (0, import_util.normalizeAndSaveAttachment)(this.outputPath(), name, options),
-      step.group ? void 0 : step.stepId
+      step.stepId
     );
     step.complete({});
   }
   _attach(attachment, stepId) {
     const index = this._attachmentsPush(attachment) - 1;
-    if (stepId) {
-      this._stepMap.get(stepId).attachmentIndices.push(index);
+    let step = stepId ? this._stepMap.get(stepId) : void 0;
+    if (!!step?.group)
+      step = void 0;
+    if (step) {
+      step.attachmentIndices.push(index);
     } else {
       const stepId2 = `attach@${(0, import_utils.createGuid)()}`;
       this._tracing.appendBeforeActionForStep({ stepId: stepId2, title: `Attach ${(0, import_utils.escapeWithQuotes)(attachment.name, '"')}`, category: "test.attach", stack: [] });
@@ -356,7 +373,7 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
       contentType: attachment.contentType,
       path: attachment.path,
       body: attachment.body?.toString("base64"),
-      stepId
+      stepId: step?.stepId
     });
   }
   outputPath(...pathSegments) {
@@ -445,12 +462,6 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
   setTimeout(timeout) {
     this._timeoutManager.setTimeout(timeout);
   }
-  _pauseOnError() {
-    return this._workerParams.pauseOnError;
-  }
-  _pauseAtEnd() {
-    return this._workerParams.pauseAtEnd;
-  }
 }
 class TestStepInfoImpl {
   constructor(testInfo, stepId, title, parentStep) {

package/lib/worker/testTracing.js

@@ -53,6 +53,7 @@ class TestTracing {
       type: "context-options",
       origin: "testRunner",
       browserName: "",
+      playwrightVersion: (0, import_utils.getPlaywrightVersion)(),
       options: {},
       platform: process.platform,
       wallTime: Date.now(),

package/lib/worker/workerMain.js

@@ -98,6 +98,7 @@ class WorkerMain extends import_process.ProcessRunner {
       const fakeTestInfo = new import_testInfo.TestInfoImpl(this._config, this._project, this._params, void 0, 0, () => {
       }, () => {
       }, () => {
+      }, () => {
       });
       const runnable = { type: "teardown" };
       await fakeTestInfo._runWithTimeout(runnable, () => this._loadIfNeeded()).catch(() => {
@@ -179,7 +180,7 @@ class WorkerMain extends import_process.ProcessRunner {
     let fatalUnknownTestIds;
     try {
       await this._loadIfNeeded();
-      const fileSuite = await (0, import_testLoader.loadTestFile)(runPayload.file, this._config.config.rootDir);
+      const fileSuite = await (0, import_testLoader.loadTestFile)(runPayload.file, this._config);
       const suite = (0, import_suiteUtils.bindFileSuiteToProject)(this._project, fileSuite);
       if (this._params.repeatEachIndex)
         (0, import_suiteUtils.applyRepeatEachIndex)(this._project, suite, this._params.repeatEachIndex);
@@ -222,6 +223,16 @@ class WorkerMain extends import_process.ProcessRunner {
       this._runFinished.resolve();
     }
   }
+  async customMessage(payload) {
+    try {
+      if (this._currentTest?.testId !== payload.testId)
+        throw new Error("Test has already stopped");
+      const response = await this._currentTest._onCustomMessageCallback?.(payload.request);
+      return { response };
+    } catch (error) {
+      return { response: {}, error: (0, import_util2.testInfoError)(error) };
+    }
+  }
   async _runTest(test, retry, nextTest) {
     const testInfo = new import_testInfo.TestInfoImpl(
       this._config,
@@ -231,7 +242,8 @@ class WorkerMain extends import_process.ProcessRunner {
       retry,
       (stepBeginPayload) => this.dispatchEvent("stepBegin", stepBeginPayload),
       (stepEndPayload) => this.dispatchEvent("stepEnd", stepEndPayload),
-      (attachment) => this.dispatchEvent("attach", attachment)
+      (attachment) => this.dispatchEvent("attach", attachment),
+      (testPausedPayload) => this.dispatchEvent("testPaused", testPausedPayload)
     );
     const processAnnotation = (annotation) => {
       testInfo.annotations.push(annotation);
@@ -318,10 +330,7 @@ class WorkerMain extends import_process.ProcessRunner {
     await testInfo._runAsStep({ title: "After Hooks", category: "hook" }, async () => {
       let firstAfterHooksError;
       try {
-        await testInfo._runWithTimeout({ type: "test", slot: afterHooksSlot }, async () => {
-          for (const fn of testInfo._onDidFinishTestFunctions)
-            await fn();
-        });
+        await testInfo._runWithTimeout({ type: "test", slot: afterHooksSlot }, () => testInfo._didFinishTestFunction());
       } catch (error) {
         firstAfterHooksError = firstAfterHooksError ?? error;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.56.1",
+  "version": "1.57.0",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.56.1"
+    "playwright-core": "1.57.0"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/test.d.ts

@@ -873,7 +873,9 @@ interface TestConfig<TestArgs = {}, WorkerArgs = {}> {
    * - A module name like `'my-awesome-reporter'`.
    * - A relative path to the reporter like `'./reporters/my-awesome-reporter.js'`.
    *
-   * You can pass options to the reporter in a tuple like `['json', { outputFile: './report.json' }]`.
+   * You can pass options to the reporter in a tuple like `['json', { outputFile: './report.json' }]`. If the property
+   * is not specified, Playwright uses the `'dot'` reporter when the CI environment variable is set, and the `'list'`
+   * reporter otherwise.
    *
    * Learn more in the [reporters guide](https://playwright.dev/docs/test-reporters).
    *
@@ -990,6 +992,31 @@ interface TestConfig<TestArgs = {}, WorkerArgs = {}> {
    * });
    * ```
    *
+   * If your webserver runs on varying ports, use `wait` to capture the port:
+   *
+   * ```js
+   * import { defineConfig } from '@playwright/test';
+   *
+   * export default defineConfig({
+   *   webServer: {
+   *     command: 'npm run start',
+   *     wait: {
+   *       stdout: '/Listening on port (?<my_server_port>\\d+)/'
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * ```js
+   * import { test, expect } from '@playwright/test';
+   *
+   * test.use({ baseUrl: `http://localhost:${process.env.MY_SERVER_PORT ?? 3000}` });
+   *
+   * test('homepage', async ({ page }) => {
+   *   await page.goto('/');
+   * });
+   * ```
+   *
    */
   webServer?: TestConfigWebServer | TestConfigWebServer[];
   /**
@@ -1758,6 +1785,26 @@ interface TestConfig<TestArgs = {}, WorkerArgs = {}> {
    */
   snapshotPathTemplate?: string;
 
+  /**
+   * Tag or tags prepended to each test in the report. Useful for tagging your test run to differentiate between
+   * [CI environments](https://playwright.dev/docs/test-sharding#merging-reports-from-multiple-environments).
+   *
+   * Note that each tag must start with `@` symbol. Learn more about [tagging](https://playwright.dev/docs/test-annotations#tag-tests).
+   *
+   * **Usage**
+   *
+   * ```js
+   * // playwright.config.ts
+   * import { defineConfig } from '@playwright/test';
+   *
+   * export default defineConfig({
+   *   tag: process.env.CI_ENVIRONMENT_NAME,  // for example "@APIv2"
+   * });
+   * ```
+   *
+   */
+  tag?: string|Array<string>;
+
   /**
    * Directory that will be recursively scanned for test files. Defaults to the directory of the configuration file.
    *
@@ -2035,6 +2082,11 @@ export interface FullConfig<TestArgs = {}, WorkerArgs = {}> {
     current: number;
   };
 
+  /**
+   * Resolved global tags. See [testConfig.tag](https://playwright.dev/docs/api/class-testconfig#test-config-tag).
+   */
+  tags: Array<string>;
+
   /**
    * See [testConfig.updateSnapshots](https://playwright.dev/docs/api/class-testconfig#test-config-update-snapshots).
    */
@@ -6180,7 +6232,7 @@ export interface TestType<TestArgs extends {}, WorkerArgs extends {}> {
    *     const name = this.constructor.name + '.' + (context.name as string);
    *     return test.step(name, async () => {
    *       return await target.call(this, ...args);
-   *     });
+   *     }, { box: true });
    *   };
    * }
    *
@@ -6339,7 +6391,7 @@ export interface TestType<TestArgs extends {}, WorkerArgs extends {}> {
      *     const name = this.constructor.name + '.' + (context.name as string);
      *     return test.step(name, async () => {
      *       return await target.call(this, ...args);
-     *     });
+     *     }, { box: true });
      *   };
      * }
      *
@@ -7703,6 +7755,27 @@ interface AsymmetricMatchers {
    * @param expected Expected array that is a subset of the received value.
    */
   arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+  /**
+   * `expect.arrayOf()` matches array of objects created from the
+   * [`constructor`](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of-option-constructor)
+   * or a corresponding primitive type. Use it inside
+   * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
+   * to perform pattern matching.
+   *
+   * **Usage**
+   *
+   * ```js
+   * // Match instance of a class.
+   * class Example {}
+   * expect([new Example(), new Example()]).toEqual(expect.arrayOf(Example));
+   *
+   * // Match any string.
+   * expect(['a', 'b', 'c']).toEqual(expect.arrayOf(String));
+   * ```
+   *
+   * @param constructor Constructor of the expected object like `ExampleClass`, or a primitive boxed type like `Number`.
+   */
+  arrayOf(sample: unknown): AsymmetricMatcher;
   /**
    * Compares floating point numbers for approximate equality. Use this method inside
    * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
@@ -8086,6 +8159,7 @@ interface GenericAssertions<R> {
    * - [expect(value).any(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-any)
    * - [expect(value).anything()](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-anything)
    * - [expect(value).arrayContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-containing)
+   * - [expect(value).arrayOf(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of)
    * - [expect(value).closeTo(expected[, numDigits])](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-close-to)
    * - [expect(value).objectContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-object-containing)
    * - [expect(value).stringContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-string-containing)
@@ -10145,6 +10219,25 @@ interface TestConfigWebServer {
    */
   stdout?: "pipe"|"ignore";
 
+  /**
+   * Consider command started only when given output has been produced.
+   */
+  wait?: {
+    /**
+     * Regular expression to wait for in the `stdout` of the command output. Named capture groups are stored in the
+     * environment, for example `/Listening on port (?<my_server_port>\\d+)/` will store the port number in
+     * `process.env['MY_SERVER_PORT']`.
+     */
+    stdout?: RegExp;
+
+    /**
+     * Regular expression to wait for in the `stderr` of the command output. Named capture groups are stored in the
+     * environment, for example `/Listening on port (?<my_server_port>\\d+)/` will store the port number in
+     * `process.env['MY_SERVER_PORT']`.
+     */
+    stderr?: RegExp;
+  };
+
   /**
    * How long to wait for the process to start up and be available in milliseconds. Defaults to 60000.
    */