playwright 1.56.0-alpha-2025-09-10 → 1.56.0-alpha-2025-09-11

package/lib/index.js

@@ -240,7 +240,8 @@ const playwrightFixtures = {
         if (!testInfo2 || data.apiName.includes("setTestIdAttribute") || data.apiName === "tracing.groupEnd")
           return;
         const zone = (0, import_utils.currentZone)().data("stepZone");
-        if (zone && zone.category === "expect") {
+        const isExpectCall = data.apiName === "locator._expect" || data.apiName === "frame._expect" || data.apiName === "page._expectScreenshot";
+        if (zone && zone.category === "expect" && isExpectCall) {
           if (zone.apiName)
             data.apiName = zone.apiName;
           if (zone.title)

package/lib/matchers/expect.js

@@ -225,9 +225,8 @@ class ExpectMetaInfoProxyHandler {
       const title = customMessage || `Expect ${(0, import_utils.escapeWithQuotes)(defaultTitle, '"')}`;
       const apiName = `expect${this._info.poll ? ".poll " : ""}${this._info.isSoft ? ".soft " : ""}${this._info.isNot ? ".not" : ""}.${matcherName}${argsSuffix}`;
       const stackFrames = (0, import_util.filteredStackTrace)((0, import_utils.captureRawStack)());
-      const category = matcherName === "toPass" || this._info.poll ? "test.step" : "expect";
       const stepInfo = {
-        category,
+        category: "expect",
         apiName,
         title,
         params: args[0] ? { expected: args[0] } : void 0,

package/lib/matchers/matcherHint.js

@@ -19,24 +19,42 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var matcherHint_exports = {};
 __export(matcherHint_exports, {
   ExpectError: () => ExpectError,
-  isJestError: () => isJestError,
-  matcherHint: () => matcherHint
+  callLogText: () => callLogText,
+  formatMatcherMessage: () => formatMatcherMessage,
+  isJestError: () => isJestError
 });
 module.exports = __toCommonJS(matcherHint_exports);
 var import_utils = require("playwright-core/lib/utils");
-function matcherHint(state, locator, matcherName, expression, actual, matcherOptions, timeout, expectedReceivedString, preventExtraStatIndent = false) {
-  let header = state.utils.matcherHint(matcherName, expression, actual, matcherOptions).replace(/ \/\/ deep equality/, "") + " failed\n\n";
-  const extraSpace = preventExtraStatIndent ? "" : " ";
-  if (locator)
-    header += `Locator: ${extraSpace}${String(locator)}
-`;
-  if (expectedReceivedString)
-    header += `${expectedReceivedString}
+var import_expectBundle = require("../common/expectBundle");
+function formatMatcherMessage(state, details) {
+  const receiver = details.receiver ?? (details.locator ? "locator" : "page");
+  let message = (0, import_expectBundle.DIM_COLOR)("expect(") + (0, import_expectBundle.RECEIVED_COLOR)(receiver) + (0, import_expectBundle.DIM_COLOR)(")" + (state.promise ? "." + state.promise : "") + (state.isNot ? ".not" : "") + ".") + details.matcherName + (0, import_expectBundle.DIM_COLOR)("(") + (0, import_expectBundle.EXPECTED_COLOR)(details.expectation) + (0, import_expectBundle.DIM_COLOR)(")") + " failed\n\n";
+  const diffLines = details.printedDiff?.split("\n");
+  if (diffLines?.length === 2) {
+    details.printedExpected = diffLines[0];
+    details.printedReceived = diffLines[1];
+    details.printedDiff = void 0;
+  }
+  const align = !details.errorMessage && details.printedExpected?.startsWith("Expected:") && (!details.printedReceived || details.printedReceived.startsWith("Received:"));
+  if (details.locator)
+    message += `Locator: ${align ? " " : ""}${String(details.locator)}
 `;
-  if (timeout)
-    header += `Timeout: ${extraSpace}${timeout}ms
+  if (details.printedExpected)
+    message += details.printedExpected + "\n";
+  if (details.printedReceived)
+    message += details.printedReceived + "\n";
+  if (details.timedOut && details.timeout)
+    message += `Timeout: ${align ? " " : ""}${details.timeout}ms
 `;
-  return header;
+  if (details.printedDiff)
+    message += details.printedDiff + "\n";
+  if (details.errorMessage) {
+    message += details.errorMessage;
+    if (!details.errorMessage.endsWith("\n"))
+      message += "\n";
+  }
+  message += callLogText(details.log);
+  return message;
 }
 class ExpectError extends Error {
   constructor(jestError, customMessage, stackFrames) {
@@ -52,9 +70,18 @@ class ExpectError extends Error {
 function isJestError(e) {
   return e instanceof Error && "matcherResult" in e;
 }
+const callLogText = (log) => {
+  if (!log || !log.some((l) => !!l))
+    return "";
+  return `
+Call log:
+${(0, import_expectBundle.DIM_COLOR)(log.join("\n"))}
+`;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ExpectError,
-  isJestError,
-  matcherHint
+  callLogText,
+  formatMatcherMessage,
+  isJestError
 });

package/lib/matchers/matchers.js

@@ -59,6 +59,7 @@ var import_toMatchText = require("./toMatchText");
 var import_config = require("../common/config");
 var import_globals = require("../common/globals");
 var import_testInfo = require("../worker/testInfo");
+var import_matcherHint = require("./matcherHint");
 function toBeAttached(locator, options) {
   const attached = !options || options.attached === void 0 || options.attached;
   const expected = attached ? "attached" : "detached";
@@ -146,7 +147,7 @@ function toContainText(locator, expected, options = {}) {
     return import_toMatchText.toMatchText.call(this, "toContainText", locator, "Locator", async (isNot, timeout) => {
       const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
       return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options.useInnerText, timeout });
-    }, expected, options);
+    }, expected, { ...options, matchSubstring: true });
   }
 }
 function toHaveAccessibleDescription(locator, expected, options) {
@@ -189,7 +190,7 @@ function toHaveClass(locator, expected, options) {
     return import_toEqual.toEqual.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
       const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
       return await locator._expect("to.have.class.array", { expectedText, isNot, timeout });
-    }, expected, options, true);
+    }, expected, options);
   } else {
     return import_toMatchText.toMatchText.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
       const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
@@ -204,7 +205,7 @@ function toContainClass(locator, expected, options) {
     return import_toEqual.toEqual.call(this, "toContainClass", locator, "Locator", async (isNot, timeout) => {
       const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
       return await locator._expect("to.contain.class.array", { expectedText, isNot, timeout });
-    }, expected, options, true);
+    }, expected, options);
   } else {
     if ((0, import_utils.isRegExp)(expected))
       throw new Error(`"expected" argument in toContainClass cannot be a RegExp value`);
@@ -273,7 +274,7 @@ function toHaveTitle(page, expected, options = {}) {
   return import_toMatchText.toMatchText.call(this, "toHaveTitle", page, "Page", async (isNot, timeout) => {
     const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { normalizeWhiteSpace: true });
     return await page.mainFrame()._expect("to.have.title", { expectedText, isNot, timeout });
-  }, expected, { receiverLabel: "page", ...options });
+  }, expected, options);
 }
 function toHaveURL(page, expected, options) {
   if (typeof expected === "function")
@@ -283,7 +284,7 @@ function toHaveURL(page, expected, options) {
   return import_toMatchText.toMatchText.call(this, "toHaveURL", page, "Page", async (isNot, timeout) => {
     const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase });
     return await page.mainFrame()._expect("to.have.url", { expectedText, isNot, timeout });
-  }, expected, { receiverLabel: "page", ...options });
+  }, expected, options);
 }
 async function toBeOK(response) {
   const matcherName = "toBeOK";
@@ -294,7 +295,12 @@ async function toBeOK(response) {
     response._fetchLog(),
     isTextEncoding ? response.text() : null
   ]) : [];
-  const message = () => this.utils.matcherHint(matcherName, void 0, "", { isNot: this.isNot }) + (0, import_util.callLogText)(log) + (text === null ? "" : `
+  const message = () => (0, import_matcherHint.formatMatcherMessage)(this, {
+    matcherName,
+    receiver: "response",
+    expectation: "",
+    log
+  }) + (text === null ? "" : `
 Response text:
 ${import_utils2.colors.dim(text?.substring(0, 1e3) || "")}`);
   const pass = response.ok();

package/lib/matchers/toBeTruthy.js

@@ -24,12 +24,8 @@ module.exports = __toCommonJS(toBeTruthy_exports);
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
 var import_browserBackend = require("../mcp/test/browserBackend");
-async function toBeTruthy(matcherName, receiver, receiverType, expected, arg, query, options = {}) {
-  (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
-  const matcherOptions = {
-    isNot: this.isNot,
-    promise: this.promise
-  };
+async function toBeTruthy(matcherName, locator, receiverType, expected, arg, query, options = {}) {
+  (0, import_util.expectTypes)(locator, [receiverType], matcherName);
   const timeout = options.timeout ?? this.timeout;
   const { matches: pass, log, timedOut, received, errorMessage } = await query(!!this.isNot, timeout);
   if (pass === !this.isNot) {
@@ -44,18 +40,25 @@ async function toBeTruthy(matcherName, receiver, receiverType, expected, arg, qu
   let printedExpected;
   if (pass) {
     printedExpected = `Expected: not ${expected}`;
-    printedReceived = errorMessage ?? `Received: ${expected}`;
+    printedReceived = errorMessage ? "" : `Received: ${expected}`;
   } else {
     printedExpected = `Expected: ${expected}`;
-    printedReceived = errorMessage ?? `Received: ${received}`;
+    printedReceived = errorMessage ? "" : `Received: ${received}`;
   }
   const message = () => {
-    const header = (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", arg, matcherOptions, timedOut ? timeout : void 0, `${printedExpected}
-${printedReceived}`);
-    const logText = (0, import_util.callLogText)(log);
-    return `${header}${logText}`;
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: arg,
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      errorMessage,
+      log
+    });
   };
-  await (0, import_browserBackend.runBrowserBackendOnError)(receiver.page(), message);
+  await (0, import_browserBackend.runBrowserBackendOnError)(locator.page(), message);
   return {
     message,
     pass,

package/lib/matchers/toEqual.js

@@ -27,13 +27,8 @@ var import_matcherHint = require("./matcherHint");
 var import_browserBackend = require("../mcp/test/browserBackend");
 const EXPECTED_LABEL = "Expected";
 const RECEIVED_LABEL = "Received";
-async function toEqual(matcherName, receiver, receiverType, query, expected, options = {}, messagePreventExtraStatIndent) {
-  (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
-  const matcherOptions = {
-    comment: options.contains ? "" : "deep equality",
-    isNot: this.isNot,
-    promise: this.promise
-  };
+async function toEqual(matcherName, locator, receiverType, query, expected, options = {}) {
+  (0, import_util.expectTypes)(locator, [receiverType], matcherName);
   const timeout = options.timeout ?? this.timeout;
   const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);
   if (pass === !this.isNot) {
@@ -49,10 +44,9 @@ async function toEqual(matcherName, receiver, receiverType, query, expected, opt
   let printedDiff;
   if (pass) {
     printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
-    printedReceived = errorMessage ?? `Received: ${this.utils.printReceived(received)}`;
+    printedReceived = errorMessage ? "" : `Received: ${this.utils.printReceived(received)}`;
   } else if (errorMessage) {
     printedExpected = `Expected: ${this.utils.printExpected(expected)}`;
-    printedReceived = errorMessage;
   } else if (Array.isArray(expected) && Array.isArray(received)) {
     const normalizedExpected = expected.map((exp, index) => {
       const rec = received[index];
@@ -77,12 +71,20 @@ async function toEqual(matcherName, receiver, receiverType, query, expected, opt
     );
   }
   const message = () => {
-    const details = printedDiff || `${printedExpected}
-${printedReceived}`;
-    const header = (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", void 0, matcherOptions, timedOut ? timeout : void 0, details, messagePreventExtraStatIndent);
-    return `${header}${(0, import_util.callLogText)(log)}`;
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: "expected",
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      printedDiff,
+      errorMessage,
+      log
+    });
   };
-  await (0, import_browserBackend.runBrowserBackendOnError)(receiver.page(), message);
+  await (0, import_browserBackend.runBrowserBackendOnError)(locator.page(), message);
   return {
     actual: received,
     expected,

package/lib/matchers/toHaveURL.js

@@ -22,27 +22,11 @@ __export(toHaveURL_exports, {
 });
 module.exports = __toCommonJS(toHaveURL_exports);
 var import_utils = require("playwright-core/lib/utils");
-var import_utils2 = require("playwright-core/lib/utils");
 var import_expect = require("./expect");
 var import_matcherHint = require("./matcherHint");
 var import_expectBundle = require("../common/expectBundle");
 async function toHaveURLWithPredicate(page, expected, options) {
   const matcherName = "toHaveURL";
-  const expression = "page";
-  const matcherOptions = {
-    isNot: this.isNot,
-    promise: this.promise
-  };
-  if (typeof expected !== "function") {
-    throw new Error(
-      [
-        // Always display `expected` in expectation place
-        (0, import_matcherHint.matcherHint)(this, void 0, matcherName, expression, void 0, matcherOptions, void 0, void 0, true),
-        `${import_utils2.colors.bold("Matcher error")}: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string, regular expression, or predicate`,
-        this.utils.printWithType("Expected", expected, this.utils.printExpected)
-      ].join("\n\n")
-    );
-  }
   const timeout = options?.timeout ?? this.timeout;
   const baseURL = page.context()._options.baseURL;
   let conditionSucceeded = false;
@@ -74,7 +58,6 @@ async function toHaveURLWithPredicate(page, expected, options) {
     message: () => toHaveURLMessage(
       this,
       matcherName,
-      expression,
       expected,
       lastCheckedURLString,
       this.isNot,
@@ -85,19 +68,14 @@ async function toHaveURLWithPredicate(page, expected, options) {
     timeout
   };
 }
-function toHaveURLMessage(state, matcherName, expression, expected, received, pass, didTimeout, timeout) {
-  const matcherOptions = {
-    isNot: state.isNot,
-    promise: state.promise
-  };
+function toHaveURLMessage(state, matcherName, expected, received, pass, timedOut, timeout) {
   const receivedString = received || "";
-  const messagePrefix = (0, import_matcherHint.matcherHint)(state, void 0, matcherName, expression, void 0, matcherOptions, didTimeout ? timeout : void 0, void 0, true);
   let printedReceived;
   let printedExpected;
   let printedDiff;
   if (typeof expected === "function") {
-    printedExpected = `Expected predicate to ${!state.isNot ? "succeed" : "fail"}`;
-    printedReceived = `Received string: ${(0, import_expectBundle.printReceived)(receivedString)}`;
+    printedExpected = `Expected: predicate to ${!state.isNot ? "succeed" : "fail"}`;
+    printedReceived = `Received: ${(0, import_expectBundle.printReceived)(receivedString)}`;
   } else {
     if (pass) {
       printedExpected = `Expected pattern: not ${state.utils.printExpected(expected)}`;
@@ -108,8 +86,15 @@ function toHaveURLMessage(state, matcherName, expression, expected, received, pa
       printedDiff = state.utils.printDiffOrStringify(expected, receivedString, labelExpected, "Received string", false);
     }
   }
-  const resultDetails = printedDiff ? printedDiff : printedExpected + "\n" + printedReceived;
-  return messagePrefix + resultDetails;
+  return (0, import_matcherHint.formatMatcherMessage)(state, {
+    matcherName,
+    expectation: "expected",
+    timeout,
+    timedOut,
+    printedExpected,
+    printedReceived,
+    printedDiff
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/matchers/toMatchAriaSnapshot.js

@@ -38,7 +38,7 @@ var import_matcherHint = require("./matcherHint");
 var import_util = require("../util");
 var import_expect = require("./expect");
 var import_globals = require("../common/globals");
-async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
+async function toMatchAriaSnapshot(locator, expectedParam, options = {}) {
   const matcherName = "toMatchAriaSnapshot";
   const testInfo = (0, import_globals.currentTestInfo)();
   if (!testInfo)
@@ -46,10 +46,6 @@ async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
   if (testInfo._projectInternal.ignoreSnapshots)
     return { pass: !this.isNot, message: () => "", name: "toMatchAriaSnapshot", expected: "" };
   const updateSnapshots = testInfo.config.updateSnapshots;
-  const matcherOptions = {
-    isNot: this.isNot,
-    promise: this.promise
-  };
   let expected;
   let timeout;
   let expectedPath;
@@ -74,33 +70,36 @@ async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
     }
   }
   expected = unshift(expected);
-  const { matches: pass, received, log, timedOut, errorMessage } = await receiver._expect("to.match.aria", { expectedValue: expected, isNot: this.isNot, timeout });
+  const { matches: pass, received, log, timedOut, errorMessage } = await locator._expect("to.match.aria", { expectedValue: expected, isNot: this.isNot, timeout });
   const typedReceived = received;
-  const matcherHintWithExpect = (expectedReceivedString) => {
-    return (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", void 0, matcherOptions, timedOut ? timeout : void 0, expectedReceivedString);
-  };
-  if (errorMessage) {
-    return {
-      pass: this.isNot,
-      message: () => matcherHintWithExpect(`Expected: ${this.utils.printExpected(expected)}
-${errorMessage}`) + (0, import_util.callLogText)(log),
-      name: "toMatchAriaSnapshot",
-      expected
-    };
-  }
-  const receivedText = typedReceived.raw;
   const message = () => {
-    if (pass) {
-      const receivedString = (0, import_expect.printReceivedStringContainExpectedSubstring)(receivedText, receivedText.indexOf(expected), expected.length);
-      const expectedReceivedString = `Expected: not ${this.utils.printExpected(expected)}
-Received: ${receivedString}`;
-      return matcherHintWithExpect(expectedReceivedString) + (0, import_util.callLogText)(log);
+    let printedExpected;
+    let printedReceived;
+    let printedDiff;
+    if (errorMessage) {
+      printedExpected = `Expected: ${this.isNot ? "not " : ""}${this.utils.printExpected(expected)}`;
+    } else if (pass) {
+      const receivedString = (0, import_expect.printReceivedStringContainExpectedSubstring)(typedReceived.raw, typedReceived.raw.indexOf(expected), expected.length);
+      printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
+      printedReceived = `Received: ${receivedString}`;
     } else {
-      const labelExpected = `Expected`;
-      const expectedReceivedString = this.utils.printDiffOrStringify(expected, receivedText, labelExpected, "Received", false);
-      return matcherHintWithExpect(expectedReceivedString) + (0, import_util.callLogText)(log);
+      printedDiff = this.utils.printDiffOrStringify(expected, typedReceived.raw, "Expected", "Received", false);
     }
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: "expected",
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      printedDiff,
+      errorMessage,
+      log
+    });
   };
+  if (errorMessage)
+    return { pass: this.isNot, message, name: "toMatchAriaSnapshot", expected };
   if (!this.isNot) {
     if (updateSnapshots === "all" || updateSnapshots === "changed" && pass === this.isNot || generateMissingBaseline) {
       if (expectedPath) {

package/lib/matchers/toMatchSnapshot.js

@@ -162,7 +162,7 @@ class SnapshotHelper {
       step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-diff"), contentType: this.mimeType, path: this.diffPath });
     }
     if (log?.length)
-      output.push((0, import_util.callLogText)(log));
+      output.push((0, import_matcherHint.callLogText)(log));
     else
       output.push("");
     return this.createMatcherResult(output.join("\n"), false, log);
@@ -216,8 +216,7 @@ function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
   const result = helper.comparator(received, expected, helper.options);
   if (!result)
     return helper.handleMatching();
-  const receiver = (0, import_utils.isString)(received) ? "string" : "Buffer";
-  const header = (0, import_matcherHint.matcherHint)(this, void 0, "toMatchSnapshot", receiver, void 0, void 0, void 0);
+  const header = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toMatchSnapshot", receiver: (0, import_utils.isString)(received) ? "string" : "Buffer", expectation: "expected" });
   return helper.handleDifferent(received, expected, void 0, result.diff, header, result.errorMessage, void 0, this._stepInfo);
 }
 function toHaveScreenshotStepTitle(nameOrOptions = {}, optOptions = {}) {
@@ -271,11 +270,10 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   }
   if (helper.updateSnapshots === "none" && !hasSnapshot)
     return helper.createMatcherResult(`A snapshot doesn't exist at ${helper.expectedPath}.`, false);
-  const receiver = locator ? "locator" : "page";
   if (!hasSnapshot) {
     const { actual: actual2, previous: previous2, diff: diff2, errorMessage: errorMessage2, log: log2, timedOut: timedOut2 } = await page._expectScreenshot(expectScreenshotOptions);
     if (errorMessage2) {
-      const header2 = (0, import_matcherHint.matcherHint)(this, locator, "toHaveScreenshot", receiver, void 0, void 0, timedOut2 ? timeout : void 0);
+      const header2 = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut: timedOut2 });
       return helper.handleDifferent(actual2, void 0, previous2, diff2, header2, errorMessage2, log2, this._stepInfo);
     }
     return helper.handleMissing(actual2, this._stepInfo);
@@ -299,11 +297,11 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   if (helper.updateSnapshots === "changed" || helper.updateSnapshots === "all") {
     if (actual)
       return writeFiles(actual);
-    let header2 = (0, import_matcherHint.matcherHint)(this, void 0, "toHaveScreenshot", receiver, void 0, void 0, timedOut ? timeout : void 0);
+    let header2 = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
     header2 += "  Failed to re-generate expected.\n";
     return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header2, errorMessage, log, this._stepInfo);
   }
-  const header = (0, import_matcherHint.matcherHint)(this, void 0, "toHaveScreenshot", receiver, void 0, void 0, timedOut ? timeout : void 0);
+  const header = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
   return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
 }
 function writeFileSync(aPath, content) {

package/lib/matchers/toMatchText.js

@@ -21,7 +21,6 @@ __export(toMatchText_exports, {
   toMatchText: () => toMatchText
 });
 module.exports = __toCommonJS(toMatchText_exports);
-var import_utils = require("playwright-core/lib/utils");
 var import_util = require("../util");
 var import_expect = require("./expect");
 var import_matcherHint = require("./matcherHint");
@@ -29,16 +28,11 @@ var import_expectBundle = require("../common/expectBundle");
 var import_browserBackend = require("../mcp/test/browserBackend");
 async function toMatchText(matcherName, receiver, receiverType, query, expected, options = {}) {
   (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
-  const matcherOptions = {
-    isNot: this.isNot,
-    promise: this.promise
-  };
+  const locator = receiverType === "Locator" ? receiver : void 0;
   if (!(typeof expected === "string") && !(expected && typeof expected.test === "function")) {
-    throw new Error([
-      (0, import_matcherHint.matcherHint)(this, receiverType === "Locator" ? receiver : void 0, matcherName, options.receiverLabel ?? receiver, expected, matcherOptions, void 0, void 0, true),
-      `${import_utils.colors.bold("Matcher error")}: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string or regular expression`,
-      this.utils.printWithType("Expected", expected, this.utils.printExpected)
-    ].join("\n\n"));
+    const errorMessage2 = `Error: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string or regular expression
+${this.utils.printWithType("Expected", expected, this.utils.printExpected)}`;
+    throw new Error((0, import_matcherHint.formatMatcherMessage)(this, { locator, matcherName, expectation: "expected", errorMessage: errorMessage2 }));
   }
   const timeout = options.timeout ?? this.timeout;
   const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);
@@ -50,45 +44,48 @@ async function toMatchText(matcherName, receiver, receiverType, query, expected,
       expected
     };
   }
-  const stringSubstring = options.matchSubstring ? "substring" : "string";
+  const expectedSuffix = typeof expected === "string" ? options.matchSubstring ? " substring" : "" : " pattern";
+  const receivedSuffix = typeof expected === "string" ? options.matchSubstring ? " string" : "" : " string";
   const receivedString = received || "";
   let printedReceived;
   let printedExpected;
   let printedDiff;
   if (pass) {
     if (typeof expected === "string") {
-      printedExpected = `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}`;
-      if (errorMessage) {
-        printedReceived = errorMessage;
-      } else {
+      printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;
+      if (!errorMessage) {
         const formattedReceived = (0, import_expect.printReceivedStringContainExpectedSubstring)(receivedString, receivedString.indexOf(expected), expected.length);
-        printedReceived = `Received string: ${formattedReceived}`;
+        printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;
       }
     } else {
-      printedExpected = `Expected pattern: not ${this.utils.printExpected(expected)}`;
-      if (errorMessage) {
-        printedReceived = errorMessage;
-      } else {
+      printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;
+      if (!errorMessage) {
         const formattedReceived = (0, import_expect.printReceivedStringContainExpectedResult)(receivedString, typeof expected.exec === "function" ? expected.exec(receivedString) : null);
-        printedReceived = `Received string: ${formattedReceived}`;
+        printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;
       }
     }
   } else {
-    const labelExpected = `Expected ${typeof expected === "string" ? stringSubstring : "pattern"}`;
-    if (errorMessage) {
-      printedExpected = `${labelExpected}: ${this.utils.printExpected(expected)}`;
-      printedReceived = errorMessage;
-    } else {
-      printedDiff = this.utils.printDiffOrStringify(expected, receivedString, labelExpected, "Received string", false);
-    }
+    if (errorMessage)
+      printedExpected = `Expected${expectedSuffix}: ${this.utils.printExpected(expected)}`;
+    else
+      printedDiff = this.utils.printDiffOrStringify(expected, receivedString, `Expected${expectedSuffix}`, `Received${receivedSuffix}`, false);
   }
   const message = () => {
-    const resultDetails = printedDiff ? printedDiff : printedExpected + "\n" + printedReceived;
-    const hints = (0, import_matcherHint.matcherHint)(this, receiverType === "Locator" ? receiver : void 0, matcherName, options.receiverLabel ?? "locator", void 0, matcherOptions, timedOut ? timeout : void 0, resultDetails, true);
-    return hints + (0, import_util.callLogText)(log);
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: "expected",
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      printedDiff,
+      log,
+      errorMessage
+    });
   };
-  if (receiverType === "Locator")
-    await (0, import_browserBackend.runBrowserBackendOnError)(receiver.page(), message);
+  if (locator)
+    await (0, import_browserBackend.runBrowserBackendOnError)(locator.page(), message);
   return {
     name: matcherName,
     expected,

package/lib/mcp/browser/browserServerBackend.js

@@ -43,7 +43,6 @@ class BrowserServerBackend {
     }
     this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, rootPath) : void 0;
     this._context = new import_context.Context({
-      tools: this._tools,
       config: this._config,
       browserContextFactory: this._browserContextFactory,
       sessionLog: this._sessionLog,

package/lib/mcp/browser/config.js

@@ -30,6 +30,7 @@ var config_exports = {};
 __export(config_exports, {
   commaSeparatedList: () => commaSeparatedList,
   configFromCLIOptions: () => configFromCLIOptions,
+  defaultConfig: () => defaultConfig,
   dotenvFileLoader: () => dotenvFileLoader,
   headerParser: () => headerParser,
   numberParser: () => numberParser,
@@ -307,6 +308,7 @@ function sanitizeForFilePath(s) {
 0 && (module.exports = {
   commaSeparatedList,
   configFromCLIOptions,
+  defaultConfig,
   dotenvFileLoader,
   headerParser,
   numberParser,

package/lib/mcp/browser/context.js

@@ -42,7 +42,6 @@ class Context {
   constructor(options) {
     this._tabs = [];
     this._abortController = new AbortController();
-    this.tools = options.tools;
     this.config = options.config;
     this.sessionLog = options.sessionLog;
     this.options = options;

package/lib/mcp/browser/tab.js

@@ -51,7 +51,8 @@ class Tab extends import_events.EventEmitter {
       this.setModalState({
         type: "fileChooser",
         description: "File chooser",
-        fileChooser: chooser
+        fileChooser: chooser,
+        clearedBy: "browser_file_upload"
       });
     });
     page.on("dialog", (dialog) => this._dialogShown(dialog));
@@ -82,7 +83,8 @@ class Tab extends import_events.EventEmitter {
     this.setModalState({
       type: "dialog",
       description: `"${dialog.type()}" dialog with message "${dialog.message()}"`,
-      dialog
+      dialog,
+      clearedBy: "browser_handle_dialog"
     });
   }
   async _downloadStarted(download) {
@@ -241,10 +243,8 @@ function renderModalStates(context, modalStates) {
   const result = ["### Modal state"];
   if (modalStates.length === 0)
     result.push("- There is no modal state present");
-  for (const state of modalStates) {
-    const tool = context.tools.filter((tool2) => "clearsModalState" in tool2).find((tool2) => tool2.clearsModalState === state.type);
-    result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
-  }
+  for (const state of modalStates)
+    result.push(`- [${state.description}]: can be handled by the "${state.clearedBy}" tool`);
   return result;
 }
 const tabSymbol = Symbol("tabSymbol");