@smoothdeploy/playwright 1.62.1 → 1.63.0

package/lib/matchers/expect.js

@@ -12612,6 +12612,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     isNot: !!this.isNot,
     timeout,
     signal: helper.options.signal,
+    title: this.title,
     type: screenshotType,
     comparator: helper.options.comparator,
     maxDiffPixels: helper.options.maxDiffPixels,
@@ -12725,7 +12726,7 @@ function toBeAttached(locator, options) {
   const expected = attached ? "attached" : "detached";
   const arg = attached ? "" : "{ attached: false }";
   return toBeTruthy.call(this, "toBeAttached", locator, "Locator", expected, arg, async (isNot, timeout, signal) => {
-    return await locator._expect(attached ? "to.be.attached" : "to.be.detached", { isNot, timeout, signal });
+    return await locator._expect(attached ? "to.be.attached" : "to.be.detached", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeChecked(locator, options) {
@@ -12745,12 +12746,12 @@ function toBeChecked(locator, options) {
     arg = options?.checked === false ? `{ checked: false }` : "";
   }
   return toBeTruthy.call(this, "toBeChecked", locator, "Locator", expected, arg, async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.checked", { isNot, timeout, expectedValue, signal });
+    return await locator._expect("to.be.checked", { isNot, timeout, expectedValue, signal, title: this.title });
   }, options);
 }
 function toBeDisabled(locator, options) {
   return toBeTruthy.call(this, "toBeDisabled", locator, "Locator", "disabled", "", async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.disabled", { isNot, timeout, signal });
+    return await locator._expect("to.be.disabled", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeEditable(locator, options) {
@@ -12758,12 +12759,12 @@ function toBeEditable(locator, options) {
   const expected = editable ? "editable" : "readOnly";
   const arg = editable ? "" : "{ editable: false }";
   return toBeTruthy.call(this, "toBeEditable", locator, "Locator", expected, arg, async (isNot, timeout, signal) => {
-    return await locator._expect(editable ? "to.be.editable" : "to.be.readonly", { isNot, timeout, signal });
+    return await locator._expect(editable ? "to.be.editable" : "to.be.readonly", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeEmpty(locator, options) {
   return toBeTruthy.call(this, "toBeEmpty", locator, "Locator", "empty", "", async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.empty", { isNot, timeout, signal });
+    return await locator._expect("to.be.empty", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeEnabled(locator, options) {
@@ -12771,17 +12772,17 @@ function toBeEnabled(locator, options) {
   const expected = enabled ? "enabled" : "disabled";
   const arg = enabled ? "" : "{ enabled: false }";
   return toBeTruthy.call(this, "toBeEnabled", locator, "Locator", expected, arg, async (isNot, timeout, signal) => {
-    return await locator._expect(enabled ? "to.be.enabled" : "to.be.disabled", { isNot, timeout, signal });
+    return await locator._expect(enabled ? "to.be.enabled" : "to.be.disabled", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeFocused(locator, options) {
   return toBeTruthy.call(this, "toBeFocused", locator, "Locator", "focused", "", async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.focused", { isNot, timeout, signal });
+    return await locator._expect("to.be.focused", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeHidden(locator, options) {
   return toBeTruthy.call(this, "toBeHidden", locator, "Locator", "hidden", "", async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.hidden", { isNot, timeout, signal });
+    return await locator._expect("to.be.hidden", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeVisible(locator, options) {
@@ -12789,43 +12790,43 @@ function toBeVisible(locator, options) {
   const expected = visible ? "visible" : "hidden";
   const arg = visible ? "" : "{ visible: false }";
   return toBeTruthy.call(this, "toBeVisible", locator, "Locator", expected, arg, async (isNot, timeout, signal) => {
-    return await locator._expect(visible ? "to.be.visible" : "to.be.hidden", { isNot, timeout, signal });
+    return await locator._expect(visible ? "to.be.visible" : "to.be.hidden", { isNot, timeout, signal, title: this.title });
   }, options);
 }
 function toBeInViewport(locator, options) {
   return toBeTruthy.call(this, "toBeInViewport", locator, "Locator", "in viewport", "", async (isNot, timeout, signal) => {
-    return await locator._expect("to.be.in.viewport", { isNot, expectedNumber: options?.ratio, timeout, signal });
+    return await locator._expect("to.be.in.viewport", { isNot, expectedNumber: options?.ratio, timeout, signal, title: this.title });
   }, options);
 }
 function toContainText(locator, expected, options = {}) {
   if (Array.isArray(expected)) {
     return toEqual.call(this, "toContainText", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues(expected, { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
-      return await locator._expect("to.contain.text.array", { expectedText, isNot, useInnerText: options.useInnerText, timeout, signal });
+      return await locator._expect("to.contain.text.array", { expectedText, isNot, useInnerText: options.useInnerText, timeout, signal, title: this.title });
     }, expected, { ...options, contains: true });
   } else {
     return toMatchText.call(this, "toContainText", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues([expected], { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
-      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options.useInnerText, timeout, signal });
+      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options.useInnerText, timeout, signal, title: this.title });
     }, expected, { ...options, matchSubstring: true });
   }
 }
 function toHaveAccessibleDescription(locator, expected, options) {
   return toMatchText.call(this, "toHaveAccessibleDescription", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
-    return await locator._expect("to.have.accessible.description", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.accessible.description", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveAccessibleName(locator, expected, options) {
   return toMatchText.call(this, "toHaveAccessibleName", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
-    return await locator._expect("to.have.accessible.name", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.accessible.name", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveAccessibleErrorMessage(locator, expected, options) {
   return toMatchText.call(this, "toHaveAccessibleErrorMessage", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
-    return await locator._expect("to.have.accessible.error.message", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.accessible.error.message", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveAttribute(locator, name, expected, options) {
@@ -12837,24 +12838,24 @@ function toHaveAttribute(locator, name, expected, options) {
   }
   if (expected === void 0) {
     return toBeTruthy.call(this, "toHaveAttribute", locator, "Locator", "have attribute", "", async (isNot, timeout, signal) => {
-      return await locator._expect("to.have.attribute", { expressionArg: name, isNot, timeout, signal });
+      return await locator._expect("to.have.attribute", { expressionArg: name, isNot, timeout, signal, title: this.title });
     }, options);
   }
   return toMatchText.call(this, "toHaveAttribute", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase });
-    return await locator._expect("to.have.attribute.value", { expressionArg: name, expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.attribute.value", { expressionArg: name, expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveClass(locator, expected, options) {
   if (Array.isArray(expected)) {
     return toEqual.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues(expected);
-      return await locator._expect("to.have.class.array", { expectedText, isNot, timeout, signal });
+      return await locator._expect("to.have.class.array", { expectedText, isNot, timeout, signal, title: this.title });
     }, expected, options);
   } else {
     return toMatchText.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues([expected]);
-      return await locator._expect("to.have.class", { expectedText, isNot, timeout, signal });
+      return await locator._expect("to.have.class", { expectedText, isNot, timeout, signal, title: this.title });
     }, expected, options);
   }
 }
@@ -12864,37 +12865,37 @@ function toContainClass(locator, expected, options) {
       throw new Error(`"expected" argument in toContainClass cannot contain RegExp values`);
     return toEqual.call(this, "toContainClass", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues(expected);
-      return await locator._expect("to.contain.class.array", { expectedText, isNot, timeout, signal });
+      return await locator._expect("to.contain.class.array", { expectedText, isNot, timeout, signal, title: this.title });
     }, expected, options);
   } else {
     if (isRegExp2(expected))
       throw new Error(`"expected" argument in toContainClass cannot be a RegExp value`);
     return toMatchText.call(this, "toContainClass", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues([expected]);
-      return await locator._expect("to.contain.class", { expectedText, isNot, timeout, signal });
+      return await locator._expect("to.contain.class", { expectedText, isNot, timeout, signal, title: this.title });
     }, expected, options);
   }
 }
 function toHaveCount(locator, expected, options) {
   return toEqual.call(this, "toHaveCount", locator, "Locator", async (isNot, timeout, signal) => {
-    return await locator._expect("to.have.count", { expectedNumber: expected, isNot, timeout, signal });
+    return await locator._expect("to.have.count", { expectedNumber: expected, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveCSS(locator, name, expected, options) {
   return toMatchText.call(this, "toHaveCSS", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected]);
-    return await locator._expect("to.have.css", { expressionArg: name, expectedText, isNot, pseudo: options?.pseudo, timeout, signal });
+    return await locator._expect("to.have.css", { expressionArg: name, expectedText, isNot, pseudo: options?.pseudo, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveId(locator, expected, options) {
   return toMatchText.call(this, "toHaveId", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected]);
-    return await locator._expect("to.have.id", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.id", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveJSProperty(locator, name, expected, options) {
   return toEqual.call(this, "toHaveJSProperty", locator, "Locator", async (isNot, timeout, signal) => {
-    return await locator._expect("to.have.property", { expressionArg: name, expectedValue: expected, isNot, timeout, signal });
+    return await locator._expect("to.have.property", { expressionArg: name, expectedValue: expected, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveRole(locator, expected, options) {
@@ -12902,38 +12903,38 @@ function toHaveRole(locator, expected, options) {
     throw new Error(`"role" argument in toHaveRole must be a string`);
   return toMatchText.call(this, "toHaveRole", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected]);
-    return await locator._expect("to.have.role", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.role", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveText(locator, expected, options = {}) {
   if (Array.isArray(expected)) {
     return toEqual.call(this, "toHaveText", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues(expected, { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
-      return await locator._expect("to.have.text.array", { expectedText, isNot, useInnerText: options?.useInnerText, timeout, signal });
+      return await locator._expect("to.have.text.array", { expectedText, isNot, useInnerText: options?.useInnerText, timeout, signal, title: this.title });
     }, expected, options);
   } else {
     return toMatchText.call(this, "toHaveText", locator, "Locator", async (isNot, timeout, signal) => {
       const expectedText = serializeExpectedTextValues([expected], { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
-      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options?.useInnerText, timeout, signal });
+      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options?.useInnerText, timeout, signal, title: this.title });
     }, expected, options);
   }
 }
 function toHaveValue(locator, expected, options) {
   return toMatchText.call(this, "toHaveValue", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected]);
-    return await locator._expect("to.have.value", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.value", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveValues(locator, expected, options) {
   return toEqual.call(this, "toHaveValues", locator, "Locator", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues(expected);
-    return await locator._expect("to.have.values", { expectedText, isNot, timeout, signal });
+    return await locator._expect("to.have.values", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveTitle(page, expected, options = {}) {
   return toMatchText.call(this, "toHaveTitle", page, "Page", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { normalizeWhiteSpace: true });
-    return await page.mainFrame()._expect("to.have.title", { expectedText, isNot, timeout, signal });
+    return await page.mainFrame()._expect("to.have.title", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 function toHaveURL(page, expected, options) {
@@ -12945,7 +12946,7 @@ function toHaveURL(page, expected, options) {
   expected = typeof expected === "string" ? constructURLBasedOnBaseURL(baseURL, expected) : expected;
   return toMatchText.call(this, "toHaveURL", page, "Page", async (isNot, timeout, signal) => {
     const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase });
-    return await page.mainFrame()._expect("to.have.url", { expectedText, isNot, timeout, signal });
+    return await page.mainFrame()._expect("to.have.url", { expectedText, isNot, timeout, signal, title: this.title });
   }, expected, options);
 }
 async function toBeOK(response) {
@@ -12999,11 +13000,12 @@ async function toPass(callback, options = {}) {
 function computeMatcherTitleSuffix(matcherName, receiver, args) {
   if (matcherName === "toHaveScreenshot") {
     const title = toHaveScreenshotStepTitle(...args);
-    return { short: title ? `(${title})` : "" };
+    return { titleSuffix: title ? `(${title})` : "" };
   }
   if (receiver && typeof receiver === "object" && receiver._apiName === "Locator") {
     try {
-      return { long: " " + asLocatorDescription("javascript", receiver._selector) };
+      const locator = asLocatorDescription("javascript", receiver._selector);
+      return { subtitle: locator, params: { locator } };
     } catch {
     }
   }
@@ -13067,7 +13069,7 @@ async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
   if (globalChildren && !expected.match(/^- \/children:/m))
     expected = `- /children: ${globalChildren}
 ` + expected;
-  const expectParams = { expectedValue: expected, isNot: this.isNot, timeout, signal: options.signal };
+  const expectParams = { expectedValue: expected, isNot: this.isNot, timeout, signal: options.signal, title: this.title };
   const { matches: pass, received, log, timedOut, errorMessage } = locator ? await locator._expect("to.match.aria", expectParams) : await receiver.mainFrame()._expect("to.match.aria", expectParams);
   const typedReceived = received?.value;
   const message = () => {
@@ -13303,17 +13305,20 @@ function callMatcherAsStep(matcherName, info, actual, matcher, args, promise) {
   const testInfo = expectConfig().testInfo;
   const customMessage = info.message || "";
   const suffixes = computeMatcherTitleSuffix(matcherName, actual, args);
-  const defaultTitle = `${info.poll ? "poll " : ""}${info.isSoft ? "soft " : ""}${info.isNot ? "not " : ""}${matcherName}${suffixes.short || ""}`;
-  const shortTitle = customMessage || `Expect ${escapeWithQuotes(defaultTitle, '"')}`;
-  const longTitle = shortTitle + (suffixes.long || "");
-  const apiName = `expect${info.poll ? ".poll " : ""}${info.isSoft ? ".soft " : ""}${info.isNot ? ".not" : ""}.${matcherName}${suffixes.short || ""}`;
+  const defaultTitle = `${info.poll ? "poll " : ""}${info.isSoft ? "soft " : ""}${info.isNot ? "not " : ""}${matcherName}${suffixes.titleSuffix || ""}`;
+  const title = customMessage || `Expect ${escapeWithQuotes(defaultTitle, '"')}`;
   const stackFrames = expectConfig().filteredStackTrace(captureRawStack());
+  const params = { ...suffixes.params };
+  if (args[0])
+    params.expected = args[0];
+  const apiName = `expect${info.poll ? ".poll " : ""}${info.isSoft ? ".soft " : ""}${info.isNot ? ".not" : ""}.${matcherName}${suffixes.titleSuffix || ""}`;
   const stepData = {
     category: "expect",
     apiName,
-    title: longTitle,
-    shortTitle,
-    params: args[0] ? { expected: args[0] } : void 0
+    title,
+    subtitle: suffixes.subtitle,
+    location: stackFrames[0],
+    params: Object.keys(params).length ? params : void 0
   };
   const step = testInfo?._addStep(stepData);
   const handleError = (error, result) => {
@@ -13334,7 +13339,7 @@ function callMatcherAsStep(matcherName, info, actual, matcher, args, promise) {
     }
   };
   try {
-    const invoke = () => info.poll ? invokePollMatcher(matcherName, info, matcher, actual, args, promise) : invokeMatcher(matcherName, info, matcher, actual, args, promise);
+    const invoke = () => info.poll ? invokePollMatcher(matcherName, info, matcher, actual, args, promise) : invokeMatcher(matcherName, info, matcher, actual, args, promise, title);
     const result = step ? currentZone().with("stepZone", step).run(invoke) : invoke();
     if (result instanceof Promise)
       return result.then(finalizer, handleError);
@@ -13343,7 +13348,7 @@ function callMatcherAsStep(matcherName, info, actual, matcher, args, promise) {
     handleError(error);
   }
 }
-function invokeMatcher(matcherName, info, matcher, actual, args, promise) {
+function invokeMatcher(matcherName, info, matcher, actual, args, promise, title) {
   const isNot = !!info.isNot;
   const timeout = info.timeout ?? expectConfig().timeout ?? defaultExpectTimeout;
   const matcherContext = {
@@ -13352,6 +13357,7 @@ function invokeMatcher(matcherName, info, matcher, actual, args, promise) {
     promise: promise ?? "",
     utils,
     timeout,
+    title,
     equals: throwUnsupportedExpectMatcherError
   };
   if (!promise)

package/lib/matchers/expect.js.txt

@@ -1,5 +1,5 @@
 # packages/playwright/lib/matchers/expect.js
-# total: 533.4 KB
+# total: 534.2 KB
 
 ## Inlined (59)
    7.9 KB  node_modules/@babel/code-frame/lib/index.js
@@ -51,10 +51,10 @@
    7.6 KB  node_modules/stack-utils/index.js
    0.4 KB  node_modules/stack-utils/node_modules/escape-string-regexp/index.js
    3.1 KB  node_modules/supports-color/index.js
-  10.3 KB  packages/playwright/src/matchers/expect.ts
+  10.4 KB  packages/playwright/src/matchers/expect.ts
   45.2 KB  packages/playwright/src/matchers/expectLibrary.ts
    3.3 KB  packages/playwright/src/matchers/matcherHint.ts
-  16.8 KB  packages/playwright/src/matchers/matchers.ts
+  17.4 KB  packages/playwright/src/matchers/matchers.ts
    1.3 KB  packages/playwright/src/matchers/toBeTruthy.ts
    2.1 KB  packages/playwright/src/matchers/toEqual.ts
    2.9 KB  packages/playwright/src/matchers/toHaveURL.ts

package/lib/mcp/test/browserBackend.js

@@ -104,11 +104,21 @@ async function generatePausedMessage(tools, testInfo, context) {
     lines.push(`### Task`, `Try recovering from the error prior to continuing`);
   return lines.join("\n");
 }
+const kDaemonSymbol = /* @__PURE__ */ Symbol("daemon");
+const kSessionNameSymbol = /* @__PURE__ */ Symbol("sessionName");
 async function runDaemonForContext(testInfo, context) {
   if (testInfo._configInternal.configCLIOverrides.debug !== "cli")
     return false;
-  const sessionName = `tw-${import_crypto.default.randomBytes(3).toString("hex")}`;
-  await context.browser().bind(sessionName, { workspaceDir: testInfo.project.testDir });
+  const browser = context.browser();
+  let sessionName = browser[kSessionNameSymbol];
+  if (!sessionName) {
+    sessionName = `tw-${import_crypto.default.randomBytes(3).toString("hex")}`;
+    await browser.bind(sessionName, { workspaceDir: testInfo.project.testDir });
+    browser[kSessionNameSymbol] = sessionName;
+  }
+  if (testInfo[kDaemonSymbol])
+    return false;
+  testInfo[kDaemonSymbol] = true;
   console.log([
     `### The test is currently paused at the start`,
     ``,

package/lib/program.js

@@ -138,9 +138,7 @@ function addTestMCPServerCommand(program2) {
       nameInConfig: "playwright-test-runner",
       version: import_package.packageJSON.version,
       toolSchemas: import_testBackend.testServerBackendTools.map((tool) => tool.schema),
-      create: async () => new import_testBackend.TestServerBackend(options.config, { muteConsole: options.port === void 0, headless: options.headless }),
-      disposed: async () => {
-      }
+      create: async () => new import_testBackend.TestServerBackend(options.config, { muteConsole: options.port === void 0, headless: options.headless })
     };
     await import_coreBundle.tools.start(factory, { port: options.port === void 0 ? void 0 : +options.port, host: options.host });
   });
@@ -188,6 +186,7 @@ function addInitSkillsCommand(program2) {
 }
 const kTraceModes = ["on", "off", "on-first-retry", "on-all-retries", "retain-on-failure", "retain-on-first-failure", "retain-on-failure-and-retries"];
 const testOptions = [
+  ["--add-reporter <reporter>", { description: `Reporter to add on top of the configured reporters, comma-separated, can be ${import_common.builtInReporters.map((name) => `"${name}"`).join(", ")} or a path to a reporter module` }],
   /* deprecated */
   ["--browser <browser>", { description: `Browser to use for tests, one of "all", "chromium", "firefox" or "webkit" (default: "chromium")` }],
   ["-c, --config <file>", { description: `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"` }],