playwright 1.55.1 → 1.56.1

package/lib/index.js

@@ -42,6 +42,7 @@ var playwrightLibrary = __toESM(require("playwright-core"));
 var import_utils = require("playwright-core/lib/utils");
 var import_globals = require("./common/globals");
 var import_testType = require("./common/testType");
+var import_browserBackend = require("./mcp/test/browserBackend");
 var import_expect = require("./matchers/expect");
 var import_configLoader = require("./common/configLoader");
 var import_testType2 = require("./common/testType");
@@ -219,7 +220,7 @@ const playwrightFixtures = {
     if ((0, import_utils.debugMode)() === "inspector")
       testInfo._setDebugMode();
     playwright._defaultContextOptions = _combinedContextOptions;
-    playwright._defaultContextTimeout = actionTimeout || 0;
+    playwright._defaultContextTimeout = testInfo._pauseOnError() ? 5e3 : actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextOptions = void 0;
@@ -237,7 +238,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)
@@ -258,11 +260,6 @@ const playwrightFixtures = {
         if (data.apiName === "tracing.group")
           tracingGroupSteps.push(step);
       },
-      onApiCallRecovery: (data, error, recoveryHandlers) => {
-        const step = data.userData;
-        if (step)
-          recoveryHandlers.push(() => step.recoverFromStepError(error));
-      },
       onApiCallEnd: (data) => {
         if (data.apiName === "tracing.group")
           return;
@@ -383,11 +380,13 @@ const playwrightFixtures = {
     attachConnectedHeaderIfNeeded(testInfo, browserImpl);
     if (!_reuseContext) {
       const { context: context2, close } = await _contextFactory();
+      testInfo._onDidFinishTestFunctions.unshift(() => (0, import_browserBackend.runBrowserBackendAtEnd)(context2, testInfo.errors[0]?.message));
       await use(context2);
       await close();
       return;
     }
     const context = await browserImpl._wrapApiCall(() => browserImpl._newContextForReuse(), { internal: true });
+    testInfo._onDidFinishTestFunctions.unshift(() => (0, import_browserBackend.runBrowserBackendAtEnd)(context, testInfo.errors[0]?.message));
     await use(context);
     const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
     await browserImpl._wrapApiCall(() => browserImpl._disconnectFromReusedContext(closeReason), { internal: true });
@@ -561,7 +560,7 @@ class ArtifactsRecorder {
   }
   async willStartTest(testInfo) {
     this._testInfo = testInfo;
-    testInfo._onDidFinishTestFunction = () => this.didFinishTestFunction();
+    testInfo._onDidFinishTestFunctions.push(() => this.didFinishTestFunction());
     this._screenshotRecorder.fixOrdinal();
     await Promise.all(this._playwright._allContexts().map((context) => this.didCreateBrowserContext(context)));
     const existingApiRequests = Array.from(this._playwright.request._contexts);

package/lib/isomorphic/testServerConnection.js

@@ -63,7 +63,6 @@ class TestServerConnection {
     this._onStdioEmitter = new events.EventEmitter();
     this._onTestFilesChangedEmitter = new events.EventEmitter();
     this._onLoadTraceRequestedEmitter = new events.EventEmitter();
-    this._onRecoverFromStepErrorEmitter = new events.EventEmitter();
     this._lastId = 0;
     this._callbacks = /* @__PURE__ */ new Map();
     this._isClosed = false;
@@ -72,7 +71,6 @@ class TestServerConnection {
     this.onStdio = this._onStdioEmitter.event;
     this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
     this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
-    this.onRecoverFromStepError = this._onRecoverFromStepErrorEmitter.event;
     this._transport = transport;
     this._transport.onmessage((data) => {
       const message = JSON.parse(data);
@@ -129,8 +127,6 @@ class TestServerConnection {
       this._onTestFilesChangedEmitter.fire(params);
     else if (method === "loadTraceRequested")
       this._onLoadTraceRequestedEmitter.fire(params);
-    else if (method === "recoverFromStepError")
-      this._onRecoverFromStepErrorEmitter.fire(params);
   }
   async initialize(params) {
     await this._sendMessage("initialize", params);
@@ -201,9 +197,6 @@ class TestServerConnection {
   async closeGracefully(params) {
     await this._sendMessage("closeGracefully", params);
   }
-  async resumeAfterStepError(params) {
-    await this._sendMessage("resumeAfterStepError", params);
-  }
   close() {
     try {
       this._transport.close();

package/lib/isomorphic/testTree.js

@@ -25,7 +25,7 @@ __export(testTree_exports, {
 });
 module.exports = __toCommonJS(testTree_exports);
 class TestTree {
-  constructor(rootFolder, rootSuite, loadErrors, projectFilters, pathSeparator) {
+  constructor(rootFolder, rootSuite, loadErrors, projectFilters, pathSeparator, hideFiles) {
     this._treeItemById = /* @__PURE__ */ new Map();
     this._treeItemByTestId = /* @__PURE__ */ new Map();
     const filterProjects = projectFilters && [...projectFilters.values()].some(Boolean);
@@ -43,10 +43,10 @@ class TestTree {
       hasLoadErrors: false
     };
     this._treeItemById.set(rootFolder, this.rootItem);
-    const visitSuite = (project, parentSuite, parentGroup) => {
-      for (const suite of parentSuite.suites) {
+    const visitSuite = (project, parentSuite, parentGroup, mode) => {
+      for (const suite of mode === "tests" ? [] : parentSuite.suites) {
         if (!suite.title) {
-          visitSuite(project, suite, parentGroup);
+          visitSuite(project, suite, parentGroup, "all");
           continue;
         }
         let group = parentGroup.children.find((item) => item.kind === "group" && item.title === suite.title);
@@ -66,9 +66,9 @@ class TestTree {
           };
           this._addChild(parentGroup, group);
         }
-        visitSuite(project, suite, group);
+        visitSuite(project, suite, group, "all");
       }
-      for (const test of parentSuite.tests) {
+      for (const test of mode === "suites" ? [] : parentSuite.tests) {
         const title = test.title;
         let testCaseItem = parentGroup.children.find((t) => t.kind !== "group" && t.title === title);
         if (!testCaseItem) {
@@ -124,8 +124,16 @@ class TestTree {
       if (filterProjects && !projectFilters.get(projectSuite.title))
         continue;
       for (const fileSuite of projectSuite.suites) {
-        const fileItem = this._fileItem(fileSuite.location.file.split(pathSeparator), true);
-        visitSuite(projectSuite.project(), fileSuite, fileItem);
+        if (hideFiles) {
+          visitSuite(projectSuite.project(), fileSuite, this.rootItem, "suites");
+          if (fileSuite.tests.length) {
+            const defaultDescribeItem = this._defaultDescribeItem();
+            visitSuite(projectSuite.project(), fileSuite, defaultDescribeItem, "tests");
+          }
+        } else {
+          const fileItem = this._fileItem(fileSuite.location.file.split(pathSeparator), true);
+          visitSuite(projectSuite.project(), fileSuite, fileItem, "all");
+        }
       }
     }
     for (const loadError of loadErrors) {
@@ -192,6 +200,25 @@ class TestTree {
     this._addChild(parentFileItem, fileItem);
     return fileItem;
   }
+  _defaultDescribeItem() {
+    let defaultDescribeItem = this._treeItemById.get("<anonymous>");
+    if (!defaultDescribeItem) {
+      defaultDescribeItem = {
+        kind: "group",
+        subKind: "describe",
+        id: "<anonymous>",
+        title: "<anonymous>",
+        location: { file: "", line: 0, column: 0 },
+        duration: 0,
+        parent: this.rootItem,
+        children: [],
+        status: "none",
+        hasLoadErrors: false
+      };
+      this._addChild(this.rootItem, defaultDescribeItem);
+    }
+    return defaultDescribeItem;
+  }
   sortAndPropagateStatus() {
     sortAndPropagateStatus(this.rootItem);
   }

package/lib/matchers/expect.js

@@ -225,16 +225,15 @@ 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,
         infectParentStepsWithError: this._info.isSoft
       };
       const step = testInfo._addStep(stepInfo);
-      const reportStepError = (isAsync, e) => {
+      const reportStepError = (e) => {
         const jestError = (0, import_matcherHint.isJestError)(e) ? e : null;
         const expectError = jestError ? new import_matcherHint.ExpectError(jestError, customMessage, stackFrames) : void 0;
         if (jestError?.matcherResult.suggestedRebaseline) {
@@ -243,22 +242,10 @@ class ExpectMetaInfoProxyHandler {
         }
         const error = expectError ?? e;
         step.complete({ error });
-        if (!isAsync || !expectError) {
-          if (this._info.isSoft)
-            testInfo._failWithError(error);
-          else
-            throw error;
-          return;
-        }
-        return (async () => {
-          const recoveryResult = await step.recoverFromStepError(expectError);
-          if (recoveryResult.status === "recovered")
-            return recoveryResult.value;
-          if (this._info.isSoft)
-            testInfo._failWithError(expectError);
-          else
-            throw expectError;
-        })();
+        if (this._info.isSoft)
+          testInfo._failWithError(error);
+        else
+          throw error;
       };
       const finalizer = () => {
         step.complete({});
@@ -268,11 +255,11 @@ class ExpectMetaInfoProxyHandler {
         const callback = () => matcher.call(target, ...args);
         const result = (0, import_utils.currentZone)().with("stepZone", step).run(callback);
         if (result instanceof Promise)
-          return result.then(finalizer).catch(reportStepError.bind(null, true));
+          return result.then(finalizer).catch(reportStepError);
         finalizer();
         return result;
       } catch (e) {
-        void reportStepError(false, e);
+        void reportStepError(e);
       }
     };
   }

package/lib/matchers/matcherHint.js

@@ -19,26 +19,42 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var matcherHint_exports = {};
 __export(matcherHint_exports, {
   ExpectError: () => ExpectError,
-  isJestError: () => isJestError,
-  kNoElementsFoundError: () => kNoElementsFoundError,
-  matcherHint: () => matcherHint
+  callLogText: () => callLogText,
+  formatMatcherMessage: () => formatMatcherMessage,
+  isJestError: () => isJestError
 });
 module.exports = __toCommonJS(matcherHint_exports);
 var import_utils = require("playwright-core/lib/utils");
-const kNoElementsFoundError = "<element(s) not found>";
-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) {
@@ -54,10 +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,
-  kNoElementsFoundError,
-  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

@@ -23,14 +23,10 @@ __export(toBeTruthy_exports, {
 module.exports = __toCommonJS(toBeTruthy_exports);
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
-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 } = await query(!!this.isNot, timeout);
+  const { matches: pass, log, timedOut, received, errorMessage } = await query(!!this.isNot, timeout);
   if (pass === !this.isNot) {
     return {
       name: matcherName,
@@ -39,21 +35,27 @@ async function toBeTruthy(matcherName, receiver, receiverType, expected, arg, qu
       expected
     };
   }
-  const notFound = received === import_matcherHint.kNoElementsFoundError ? received : void 0;
   let printedReceived;
   let printedExpected;
   if (pass) {
     printedExpected = `Expected: not ${expected}`;
-    printedReceived = `Received: ${notFound ? import_matcherHint.kNoElementsFoundError : expected}`;
+    printedReceived = errorMessage ? "" : `Received: ${expected}`;
   } else {
     printedExpected = `Expected: ${expected}`;
-    printedReceived = `Received: ${notFound ? import_matcherHint.kNoElementsFoundError : 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
+    });
   };
   return {
     message,

package/lib/matchers/toEqual.js

@@ -26,15 +26,10 @@ var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
 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 } = await query(!!this.isNot, timeout);
+  const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);
   if (pass === !this.isNot) {
     return {
       name: matcherName,
@@ -48,7 +43,9 @@ async function toEqual(matcherName, receiver, receiverType, query, expected, opt
   let printedDiff;
   if (pass) {
     printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
-    printedReceived = `Received: ${this.utils.printReceived(received)}`;
+    printedReceived = errorMessage ? "" : `Received: ${this.utils.printReceived(received)}`;
+  } else if (errorMessage) {
+    printedExpected = `Expected: ${this.utils.printExpected(expected)}`;
   } else if (Array.isArray(expected) && Array.isArray(received)) {
     const normalizedExpected = expected.map((exp, index) => {
       const rec = received[index];
@@ -73,10 +70,18 @@ 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
+    });
   };
   return {
     actual: received,

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

@@ -35,11 +35,10 @@ var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
 var import_matcherHint = require("./matcherHint");
-var import_expectBundle = require("../common/expectBundle");
 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)
@@ -47,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;
@@ -75,35 +70,36 @@ async function toMatchAriaSnapshot(receiver, expectedParam, options = {}) {
     }
   }
   expected = unshift(expected);
-  const { matches: pass, received, log, timedOut } = 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);
-  };
-  const notFound = typedReceived === import_matcherHint.kNoElementsFoundError;
-  if (notFound) {
-    return {
-      pass: this.isNot,
-      message: () => matcherHintWithExpect(`Expected: ${this.utils.printExpected(expected)}
-Received: ${(0, import_expectBundle.EXPECTED_COLOR)("<element not found>")}`) + (0, import_util.callLogText)(log),
-      name: "toMatchAriaSnapshot",
-      expected
-    };
-  }
-  const receivedText = typedReceived.raw;
   const message = () => {
-    if (pass) {
-      const receivedString = notFound ? receivedText : (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 = notFound ? `${labelExpected}: ${this.utils.printExpected(expected)}
-Received: ${receivedText}` : 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) {