From 29d44e41c91740c4ee2e93fc3e103dd9c66fa3a7 Mon Sep 17 00:00:00 2001
From: Max Schmitt <max@schmitt.mx>
Date: Wed, 16 Oct 2024 11:36:06 +0200
Subject: [PATCH] chore: fix ToT roll

---
 dotnet/docs/api/class-locator.mdx           | 43 ++++++++++
 dotnet/docs/api/class-locatorassertions.mdx | 24 ++++++
 dotnet/docs/api/class-websocketroute.mdx    | 40 +++++++---
 dotnet/docs/locators.mdx                    |  2 +-
 dotnet/docs/mock.mdx                        | 29 +++++++
 dotnet/docs/network.mdx                     |  6 +-
 java/docs/api/class-locator.mdx             | 43 ++++++++++
 java/docs/api/class-locatorassertions.mdx   | 24 ++++++
 java/docs/api/class-websocketroute.mdx      | 22 ++++--
 java/docs/locators.mdx                      |  2 +-
 java/docs/mock.mdx                          | 29 +++++++
 java/docs/network.mdx                       |  6 +-
 nodejs/docs/api/class-locator.mdx           | 49 ++++++++++++
 nodejs/docs/api/class-locatorassertions.mdx | 28 +++++++
 nodejs/docs/api/class-websocketroute.mdx    | 19 +++--
 nodejs/docs/ci.mdx                          | 20 ++---
 nodejs/docs/docker.mdx                      | 16 ++--
 nodejs/docs/locators.mdx                    |  2 +-
 nodejs/docs/mock.mdx                        | 29 +++++++
 nodejs/docs/network.mdx                     |  6 +-
 python/docs/api/class-locator.mdx           | 63 +++++++++++++++
 python/docs/api/class-locatorassertions.mdx | 48 +++++++++++
 python/docs/api/class-websocketroute.mdx    | 49 ++++++++++--
 python/docs/locators.mdx                    |  2 +-
 python/docs/mock.mdx                        | 88 +++++++++++++++++++++
 python/docs/network.mdx                     |  6 +-
 src/format_csharp.js                        |  4 +-
 27 files changed, 639 insertions(+), 60 deletions(-)

diff --git a/dotnet/docs/api/class-locator.mdx b/dotnet/docs/api/class-locator.mdx
index 8465be00a6..c921401126 100644
--- a/dotnet/docs/api/class-locator.mdx
+++ b/dotnet/docs/api/class-locator.mdx
@@ -111,6 +111,49 @@ var button = page.GetByRole(AriaRole.Button).And(page.GetByTitle("Subscribe"));
 
 ---
 
+### AriaSnapshotAsync {#locator-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locator.AriaSnapshotAsync</x-search>
+
+Captures the aria snapshot of the given element. See [Expect(Locator).ToMatchAriaSnapshotAsync()](/api/class-locatorassertions.mdx#locator-assertions-to-match-aria-snapshot) for the corresponding assertion.
+
+**Usage**
+
+```csharp
+await page.GetByRole(AriaRole.Link).AriaSnapshotAsync();
+```
+
+**Returns**
+- [string]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-aria-snapshot-return"/><a href="#locator-aria-snapshot-return" class="list-anchor">#</a>
+
+**Details**
+
+This method captures the aria snapshot of the given element. The snapshot is a string that represents the state of the element and its children. The snapshot can be used to assert the state of the element in the test, or to compare it to state in the future.
+
+The ARIA snapshot is represented using [YAML](https://yaml.org/spec/1.2.2/) markup language:
+* The keys of the objects are the roles and optional accessible names of the elements.
+* The values are either text content or an array of child elements.
+* Generic static text can be represented with the `text` key.
+
+Below is the HTML markup and the respective ARIA snapshot:
+
+```html
+<ul aria-label="Links">
+  <li><a href="/">Home</a></li>
+  <li><a href="/about">About</a></li>
+<ul>
+```
+
+```yml
+- list "Links":
+  - listitem:
+    - link "Home"
+  - listitem:
+    - link "About"
+```
+
+---
+
 ### BlurAsync {#locator-blur}
 
 <font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.28</font><x-search>locator.BlurAsync</x-search>
diff --git a/dotnet/docs/api/class-locatorassertions.mdx b/dotnet/docs/api/class-locatorassertions.mdx
index 543dc619a1..2c92c560d0 100644
--- a/dotnet/docs/api/class-locatorassertions.mdx
+++ b/dotnet/docs/api/class-locatorassertions.mdx
@@ -776,6 +776,30 @@ await Expect(locator).ToHaveValuesAsync(new Regex[] { new Regex("R"), new Regex(
 
 ---
 
+### ToMatchAriaSnapshotAsync {#locator-assertions-to-match-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locatorAssertions.ToMatchAriaSnapshotAsync</x-search>
+
+Asserts that the target element matches the given accessibility snapshot.
+
+**Usage**
+
+```csharp
+await page.GotoAsync("https://demo.playwright.dev/todomvc/");
+await Expect(page.Locator("body")).ToMatchAriaSnapshotAsync(@"
+  - heading ""todos""
+  - textbox ""What needs to be done?""
+");
+```
+
+**Arguments**
+- `expected` [string]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-option-expected"/><a href="#locator-assertions-to-match-aria-snapshot-option-expected" class="list-anchor">#</a>
+
+**Returns**
+- [void]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-return"/><a href="#locator-assertions-to-match-aria-snapshot-return" class="list-anchor">#</a>
+
+---
+
 ## Properties
 
 ### Not {#locator-assertions-not}
diff --git a/dotnet/docs/api/class-websocketroute.mdx b/dotnet/docs/api/class-websocketroute.mdx
index 632be16478..886177b208 100644
--- a/dotnet/docs/api/class-websocketroute.mdx
+++ b/dotnet/docs/api/class-websocketroute.mdx
@@ -14,7 +14,7 @@ Whenever a [`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSoc
 By default, the routed WebSocket will not connect to the server. This way, you can mock entire communcation over the WebSocket. Here is an example that responds to a `"request"` with a `"response"`.
 
 ```csharp
-await page.RouteWebSocketAsync("/ws", ws => {
+await page.RouteWebSocketAsync("wss://example.com/ws", ws => {
   ws.OnMessage(message => {
     if (message == "request")
       ws.Send("response");
@@ -24,6 +24,23 @@ await page.RouteWebSocketAsync("/ws", ws => {
 
 Since we do not call [WebSocketRoute.ConnectToServer](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) inside the WebSocket route handler, Playwright assumes that WebSocket will be mocked, and opens the WebSocket inside the page automatically.
 
+Here is another example that handles JSON messages:
+
+```csharp
+await page.RouteWebSocketAsync("wss://example.com/ws", ws => {
+  ws.OnMessage(message => {
+    using var jsonDoc = JsonDocument.Parse(message);
+    JsonElement root = jsonDoc.RootElement;
+    if (root.TryGetProperty("request", out JsonElement requestElement) && requestElement.GetString() == "question")
+    {
+      var response = new Dictionary<string, string> { ["response"] = "answer" };
+      string jsonResponse = JsonSerializer.Serialize(response);
+      ws.Send(jsonResponse);
+    }
+  });
+});
+```
+
 **Intercepting**
 
 Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Calling [WebSocketRoute.ConnectToServer](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) returns a server-side `WebSocketRoute` instance that you can send messages to, or handle incoming messages.
@@ -44,11 +61,11 @@ await page.RouteWebSocketAsync("/ws", ws => {
 
 After connecting to the server, all **messages are forwarded** between the page and the server by default.
 
-However, if you call [WebSocketRoute.OnMessageAsync()](/api/class-websocketroute.mdx#web-socket-route-on-message) on the original route, messages from the page to the server **will not be forwarded** anymore, but should instead be handled by the [handler](/api/class-websocketroute.mdx#web-socket-route-on-message-option-handler).
+However, if you call [WebSocketRoute.OnMessage()](/api/class-websocketroute.mdx#web-socket-route-on-message) on the original route, messages from the page to the server **will not be forwarded** anymore, but should instead be handled by the [handler](/api/class-websocketroute.mdx#web-socket-route-on-message-option-handler).
 
-Similarly, calling [WebSocketRoute.OnMessageAsync()](/api/class-websocketroute.mdx#web-socket-route-on-message) on the server-side WebSocket will **stop forwarding messages** from the server to the page, and [handler](/api/class-websocketroute.mdx#web-socket-route-on-message-option-handler) should take care of them.
+Similarly, calling [WebSocketRoute.OnMessage()](/api/class-websocketroute.mdx#web-socket-route-on-message) on the server-side WebSocket will **stop forwarding messages** from the server to the page, and [handler](/api/class-websocketroute.mdx#web-socket-route-on-message-option-handler) should take care of them.
 
-The following example blocks some messages in both directions. Since it calls [WebSocketRoute.OnMessageAsync()](/api/class-websocketroute.mdx#web-socket-route-on-message) in both directions, there is no automatic forwarding at all.
+The following example blocks some messages in both directions. Since it calls [WebSocketRoute.OnMessage()](/api/class-websocketroute.mdx#web-socket-route-on-message) in both directions, there is no automatic forwarding at all.
 
 ```csharp
 await page.RouteWebSocketAsync("/ws", ws => {
@@ -102,8 +119,8 @@ await WebSocketRoute.CloseAsync(options);
 By default, routed WebSocket does not connect to the server, so you can mock entire WebSocket communication. This method connects to the actual WebSocket server, and returns the server-side [WebSocketRoute] instance, giving the ability to send and receive messages from the server.
 
 Once connected to the server:
-* Messages received from the server will be **automatically forwarded** to the WebSocket in the page, unless [WebSocketRoute.OnMessageAsync()](/api/class-websocketroute.mdx#web-socket-route-on-message) is called on the server-side `WebSocketRoute`.
-* Messages sent by the [`WebSocket.send()`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send) call in the page will be **automatically forwarded** to the server, unless [WebSocketRoute.OnMessageAsync()](/api/class-websocketroute.mdx#web-socket-route-on-message) is called on the original `WebSocketRoute`.
+* Messages received from the server will be **automatically forwarded** to the WebSocket in the page, unless [WebSocketRoute.OnMessage()](/api/class-websocketroute.mdx#web-socket-route-on-message) is called on the server-side `WebSocketRoute`.
+* Messages sent by the [`WebSocket.send()`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send) call in the page will be **automatically forwarded** to the server, unless [WebSocketRoute.OnMessage()](/api/class-websocketroute.mdx#web-socket-route-on-message) is called on the original `WebSocketRoute`.
 
 See examples at the top for more details.
 
@@ -133,15 +150,15 @@ WebSocketRoute.OnClose(handler);
 ```
 
 **Arguments**
-- `handler` [Action]&lt;[number]?&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
+- `handler` Action&lt;int?, string&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
   
   Function that will handle WebSocket closure. Received an optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code) and an optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
 
 ---
 
-### OnMessageAsync {#web-socket-route-on-message}
+### OnMessage {#web-socket-route-on-message}
 
-<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.48</font><x-search>webSocketRoute.OnMessageAsync</x-search>
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.48</font><x-search>webSocketRoute.OnMessage</x-search>
 
 This method allows to handle messages that are sent by the WebSocket, either from the page or from the server.
 
@@ -154,7 +171,7 @@ Calling this method again will override the handler with a new one.
 **Usage**
 
 ```csharp
-await WebSocketRoute.OnMessageAsync(handler);
+WebSocketRoute.OnMessage(handler);
 ```
 
 **Arguments**
@@ -162,9 +179,6 @@ await WebSocketRoute.OnMessageAsync(handler);
   
   Function that will handle messages.
 
-**Returns**
-- [void]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-message-return"/><a href="#web-socket-route-on-message-return" class="list-anchor">#</a>
-
 ---
 
 ### Send {#web-socket-route-send}
diff --git a/dotnet/docs/locators.mdx b/dotnet/docs/locators.mdx
index eb02d07575..9f02fca4b2 100644
--- a/dotnet/docs/locators.mdx
+++ b/dotnet/docs/locators.mdx
@@ -600,7 +600,7 @@ var button = page.GetByRole(AriaRole.Button).And(page.GetByTitle("Subscribe"));
 
 ### Matching one of the two alternative locators
 
-If you'd like to target one of the two or more elements, and you don't know which one it will be, use [Locator.Or()](/api/class-locator.mdx#locator-or) to create a locator that matches all of the alternatives.
+If you'd like to target one of the two or more elements, and you don't know which one it will be, use [Locator.Or()](/api/class-locator.mdx#locator-or) to create a locator that matches any one or both of the alternatives.
 
 For example, consider a scenario where you'd like to click on a "New email" button, but sometimes a security settings dialog shows up instead. In this case, you can wait for either a "New email" button, or a dialog and act accordingly.
 
diff --git a/dotnet/docs/mock.mdx b/dotnet/docs/mock.mdx
index ac0112feb0..09e577b1ae 100644
--- a/dotnet/docs/mock.mdx
+++ b/dotnet/docs/mock.mdx
@@ -153,6 +153,35 @@ pwsh bin/Debug/netX/playwright.ps1 open --save-har=example.har --save-har-glob="
 
 Read more about [advanced networking](./network.mdx).
 
+## Mock WebSockets
+
+The following code will intercept WebSocket connections and mock entire communcation over the WebSocket, instead of connecting to the server. This example responds to a `"request"` with a `"response"`.
+
+```csharp
+await page.RouteWebSocketAsync("wss://example.com/ws", ws => {
+  ws.OnMessage(message => {
+    if (message == "request")
+      ws.Send("response");
+  });
+});
+```
+
+Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Here is an example that modifies some of the messages sent by the page to the server, and leaves the rest unmodified.
+
+```csharp
+await page.RouteWebSocketAsync("wss://example.com/ws", ws => {
+  var server = ws.ConnectToServer();
+  ws.OnMessage(message => {
+    if (message == "request")
+      server.Send("request2");
+    else
+      server.Send(message);
+  });
+});
+```
+
+For more details, see [WebSocketRoute].
+
 
 [Accessibility]: /api/class-accessibility.mdx "Accessibility"
 [APIRequest]: /api/class-apirequest.mdx "APIRequest"
diff --git a/dotnet/docs/network.mdx b/dotnet/docs/network.mdx
index 37dbc34cbc..1dc3f2b45f 100644
--- a/dotnet/docs/network.mdx
+++ b/dotnet/docs/network.mdx
@@ -12,7 +12,7 @@ Playwright provides APIs to **monitor** and **modify** browser network traffic,
 
 ## Mock APIs
 
-Check out our [API mocking guide](./mock.mdx) to learn more on how to 
+Check out our [API mocking guide](./mock.mdx) to learn more on how to
 - mock API requests and never hit the API
 - perform the API request and modify the response
 - use HAR files to mock network requests.
@@ -201,7 +201,9 @@ Important notes:
 
 ## WebSockets
 
-Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection out of the box. Every time a WebSocket is created, the [Page.WebSocket](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
+Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection, mocking and modifying out of the box. See our [API mocking guide](./mock.mdx#mock-websockets) to learn how to mock WebSockets.
+
+Every time a WebSocket is created, the [Page.WebSocket](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
 
 ```csharp
 page.WebSocket += (_, ws) =>
diff --git a/java/docs/api/class-locator.mdx b/java/docs/api/class-locator.mdx
index 4630b1e65d..d9e0a95514 100644
--- a/java/docs/api/class-locator.mdx
+++ b/java/docs/api/class-locator.mdx
@@ -111,6 +111,49 @@ Locator button = page.getByRole(AriaRole.BUTTON).and(page.getByTitle("Subscribe"
 
 ---
 
+### ariaSnapshot {#locator-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locator.ariaSnapshot</x-search>
+
+Captures the aria snapshot of the given element. See [assertThat(locator).matchesAriaSnapshot()](/api/class-locatorassertions.mdx#locator-assertions-to-match-aria-snapshot) for the corresponding assertion.
+
+**Usage**
+
+```java
+page.getByRole(AriaRole.LINK).ariaSnapshot();
+```
+
+**Returns**
+- [String]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-aria-snapshot-return"/><a href="#locator-aria-snapshot-return" class="list-anchor">#</a>
+
+**Details**
+
+This method captures the aria snapshot of the given element. The snapshot is a string that represents the state of the element and its children. The snapshot can be used to assert the state of the element in the test, or to compare it to state in the future.
+
+The ARIA snapshot is represented using [YAML](https://yaml.org/spec/1.2.2/) markup language:
+* The keys of the objects are the roles and optional accessible names of the elements.
+* The values are either text content or an array of child elements.
+* Generic static text can be represented with the `text` key.
+
+Below is the HTML markup and the respective ARIA snapshot:
+
+```html
+<ul aria-label="Links">
+  <li><a href="/">Home</a></li>
+  <li><a href="/about">About</a></li>
+<ul>
+```
+
+```yml
+- list "Links":
+  - listitem:
+    - link "Home"
+  - listitem:
+    - link "About"
+```
+
+---
+
 ### blur {#locator-blur}
 
 <font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.28</font><x-search>locator.blur</x-search>
diff --git a/java/docs/api/class-locatorassertions.mdx b/java/docs/api/class-locatorassertions.mdx
index 2aa554cb89..41ecbbb27f 100644
--- a/java/docs/api/class-locatorassertions.mdx
+++ b/java/docs/api/class-locatorassertions.mdx
@@ -753,6 +753,30 @@ assertThat(
 
 ---
 
+### matchesAriaSnapshot {#locator-assertions-to-match-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locatorAssertions.matchesAriaSnapshot</x-search>
+
+Asserts that the target element matches the given accessibility snapshot.
+
+**Usage**
+
+```java
+page.navigate("https://demo.playwright.dev/todomvc/");
+assertThat(page.locator("body")).matchesAriaSnapshot("""
+  - heading "todos"
+  - textbox "What needs to be done?"
+""");
+```
+
+**Arguments**
+- `expected` [String]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-option-expected"/><a href="#locator-assertions-to-match-aria-snapshot-option-expected" class="list-anchor">#</a>
+
+**Returns**
+- [void]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-return"/><a href="#locator-assertions-to-match-aria-snapshot-return" class="list-anchor">#</a>
+
+---
+
 ## Properties
 
 ### not() {#locator-assertions-not}
diff --git a/java/docs/api/class-websocketroute.mdx b/java/docs/api/class-websocketroute.mdx
index 682e406858..16a504757c 100644
--- a/java/docs/api/class-websocketroute.mdx
+++ b/java/docs/api/class-websocketroute.mdx
@@ -14,7 +14,7 @@ Whenever a [`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSoc
 By default, the routed WebSocket will not connect to the server. This way, you can mock entire communcation over the WebSocket. Here is an example that responds to a `"request"` with a `"response"`.
 
 ```java
-page.routeWebSocket("/ws", ws -> {
+page.routeWebSocket("wss://example.com/ws", ws -> {
   ws.onMessage(message -> {
     if ("request".equals(message))
       ws.send("response");
@@ -24,6 +24,21 @@ page.routeWebSocket("/ws", ws -> {
 
 Since we do not call [WebSocketRoute.connectToServer()](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) inside the WebSocket route handler, Playwright assumes that WebSocket will be mocked, and opens the WebSocket inside the page automatically.
 
+Here is another example that handles JSON messages:
+
+```java
+page.routeWebSocket("wss://example.com/ws", ws -> {
+  ws.onMessage(message -> {
+    JsonObject json = new JsonParser().parse(message).getAsJsonObject();
+    if ("question".equals(json.get("request").getAsString())) {
+      Map<String, String> result = new HashMap();
+      result.put("response", "answer");
+      ws.send(gson.toJson(result));
+    }
+  });
+});
+```
+
 **Intercepting**
 
 Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Calling [WebSocketRoute.connectToServer()](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) returns a server-side `WebSocketRoute` instance that you can send messages to, or handle incoming messages.
@@ -134,7 +149,7 @@ WebSocketRoute.onClose(handler);
 ```
 
 **Arguments**
-- `handler` [Consumer]&lt;[null] | [number]&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
+- `handler` [Consumer]&lt;[null] | [int]&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
   
   Function that will handle WebSocket closure. Received an optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code) and an optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
 
@@ -163,9 +178,6 @@ WebSocketRoute.onMessage(handler);
   
   Function that will handle messages.
 
-**Returns**
-- [void]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-message-return"/><a href="#web-socket-route-on-message-return" class="list-anchor">#</a>
-
 ---
 
 ### send {#web-socket-route-send}
diff --git a/java/docs/locators.mdx b/java/docs/locators.mdx
index cb87460f7c..bdfeab8bad 100644
--- a/java/docs/locators.mdx
+++ b/java/docs/locators.mdx
@@ -603,7 +603,7 @@ Locator button = page.getByRole(AriaRole.BUTTON).and(page.getByTitle("Subscribe"
 
 ### Matching one of the two alternative locators
 
-If you'd like to target one of the two or more elements, and you don't know which one it will be, use [Locator.or()](/api/class-locator.mdx#locator-or) to create a locator that matches all of the alternatives.
+If you'd like to target one of the two or more elements, and you don't know which one it will be, use [Locator.or()](/api/class-locator.mdx#locator-or) to create a locator that matches any one or both of the alternatives.
 
 For example, consider a scenario where you'd like to click on a "New email" button, but sometimes a security settings dialog shows up instead. In this case, you can wait for either a "New email" button, or a dialog and act accordingly.
 
diff --git a/java/docs/mock.mdx b/java/docs/mock.mdx
index 5821f4a0ba..4d9744c2c5 100644
--- a/java/docs/mock.mdx
+++ b/java/docs/mock.mdx
@@ -150,6 +150,35 @@ mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="op
 
 Read more about [advanced networking](./network.mdx).
 
+## Mock WebSockets
+
+The following code will intercept WebSocket connections and mock entire communcation over the WebSocket, instead of connecting to the server. This example responds to a `"request"` with a `"response"`.
+
+```java
+page.routeWebSocket("wss://example.com/ws", ws -> {
+  ws.onMessage(message -> {
+    if ("request".equals(message))
+      ws.send("response");
+  });
+});
+```
+
+Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Here is an example that modifies some of the messages sent by the page to the server, and leaves the rest unmodified.
+
+```java
+page.routeWebSocket("wss://example.com/ws", ws -> {
+  WebSocketRoute server = ws.connectToServer();
+  ws.onMessage(message -> {
+    if ("request".equals(message))
+      server.send("request2");
+    else
+      server.send(message);
+  });
+});
+```
+
+For more details, see [WebSocketRoute].
+
 
 [APIRequest]: /api/class-apirequest.mdx "APIRequest"
 [APIRequestContext]: /api/class-apirequestcontext.mdx "APIRequestContext"
diff --git a/java/docs/network.mdx b/java/docs/network.mdx
index 65c0e0ee09..233555cd27 100644
--- a/java/docs/network.mdx
+++ b/java/docs/network.mdx
@@ -12,7 +12,7 @@ Playwright provides APIs to **monitor** and **modify** browser network traffic,
 
 ## Mock APIs
 
-Check out our [API mocking guide](./mock.mdx) to learn more on how to 
+Check out our [API mocking guide](./mock.mdx) to learn more on how to
 - mock API requests and never hit the API
 - perform the API request and modify the response
 - use HAR files to mock network requests.
@@ -196,7 +196,9 @@ Important notes:
 
 ## WebSockets
 
-Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection out of the box. Every time a WebSocket is created, the [Page.onWebSocket(handler)](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
+Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection, mocking and modifying out of the box. See our [API mocking guide](./mock.mdx#mock-websockets) to learn how to mock WebSockets.
+
+Every time a WebSocket is created, the [Page.onWebSocket(handler)](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
 
 ```java
 page.onWebSocket(ws -> {
diff --git a/nodejs/docs/api/class-locator.mdx b/nodejs/docs/api/class-locator.mdx
index 303104cd1f..3909d70bd6 100644
--- a/nodejs/docs/api/class-locator.mdx
+++ b/nodejs/docs/api/class-locator.mdx
@@ -111,6 +111,55 @@ const button = page.getByRole('button').and(page.getByTitle('Subscribe'));
 
 ---
 
+### ariaSnapshot {#locator-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locator.ariaSnapshot</x-search>
+
+Captures the aria snapshot of the given element. See [expect(locator).toMatchAriaSnapshot()](/api/class-locatorassertions.mdx#locator-assertions-to-match-aria-snapshot) for the corresponding assertion.
+
+**Usage**
+
+```js
+await page.getByRole('link').ariaSnapshot();
+```
+
+**Arguments**
+- `options` [Object] *(optional)*
+  - `timeout` [number] *(optional)*<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-aria-snapshot-option-timeout"/><a href="#locator-aria-snapshot-option-timeout" class="list-anchor">#</a>
+    
+    Maximum time in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout` option in the config, or by using the [browserContext.setDefaultTimeout()](/api/class-browsercontext.mdx#browser-context-set-default-timeout) or [page.setDefaultTimeout()](/api/class-page.mdx#page-set-default-timeout) methods.
+
+**Returns**
+- [Promise]&lt;[string]&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-aria-snapshot-return"/><a href="#locator-aria-snapshot-return" class="list-anchor">#</a>
+
+**Details**
+
+This method captures the aria snapshot of the given element. The snapshot is a string that represents the state of the element and its children. The snapshot can be used to assert the state of the element in the test, or to compare it to state in the future.
+
+The ARIA snapshot is represented using [YAML](https://yaml.org/spec/1.2.2/) markup language:
+* The keys of the objects are the roles and optional accessible names of the elements.
+* The values are either text content or an array of child elements.
+* Generic static text can be represented with the `text` key.
+
+Below is the HTML markup and the respective ARIA snapshot:
+
+```html
+<ul aria-label="Links">
+  <li><a href="/">Home</a></li>
+  <li><a href="/about">About</a></li>
+<ul>
+```
+
+```yml
+- list "Links":
+  - listitem:
+    - link "Home"
+  - listitem:
+    - link "About"
+```
+
+---
+
 ### blur {#locator-blur}
 
 <font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.28</font><x-search>locator.blur</x-search>
diff --git a/nodejs/docs/api/class-locatorassertions.mdx b/nodejs/docs/api/class-locatorassertions.mdx
index c8e1669448..20d6f39e54 100644
--- a/nodejs/docs/api/class-locatorassertions.mdx
+++ b/nodejs/docs/api/class-locatorassertions.mdx
@@ -928,6 +928,34 @@ await expect(locator).toHaveValues([/R/, /G/]);
 
 ---
 
+### toMatchAriaSnapshot {#locator-assertions-to-match-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locatorAssertions.toMatchAriaSnapshot</x-search>
+
+Asserts that the target element matches the given accessibility snapshot.
+
+**Usage**
+
+```js
+await page.goto('https://demo.playwright.dev/todomvc/');
+await expect(page.locator('body')).toMatchAriaSnapshot(`
+  - heading "todos"
+  - textbox "What needs to be done?"
+`);
+```
+
+**Arguments**
+- `expected` [string]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-option-expected"/><a href="#locator-assertions-to-match-aria-snapshot-option-expected" class="list-anchor">#</a>
+- `options` [Object] *(optional)*
+  - `timeout` [number] *(optional)*<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-option-timeout"/><a href="#locator-assertions-to-match-aria-snapshot-option-timeout" class="list-anchor">#</a>
+    
+    Time to retry the assertion for in milliseconds. Defaults to `timeout` in `TestConfig.expect`.
+
+**Returns**
+- [Promise]&lt;[void]&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-return"/><a href="#locator-assertions-to-match-aria-snapshot-return" class="list-anchor">#</a>
+
+---
+
 ## Properties
 
 ### not {#locator-assertions-not}
diff --git a/nodejs/docs/api/class-websocketroute.mdx b/nodejs/docs/api/class-websocketroute.mdx
index a44d30ac7a..8868e95bf8 100644
--- a/nodejs/docs/api/class-websocketroute.mdx
+++ b/nodejs/docs/api/class-websocketroute.mdx
@@ -14,7 +14,7 @@ Whenever a [`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSoc
 By default, the routed WebSocket will not connect to the server. This way, you can mock entire communcation over the WebSocket. Here is an example that responds to a `"request"` with a `"response"`.
 
 ```js
-await page.routeWebSocket('/ws', ws => {
+await page.routeWebSocket('wss://example.com/ws', ws => {
   ws.onMessage(message => {
     if (message === 'request')
       ws.send('response');
@@ -24,6 +24,18 @@ await page.routeWebSocket('/ws', ws => {
 
 Since we do not call [webSocketRoute.connectToServer()](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) inside the WebSocket route handler, Playwright assumes that WebSocket will be mocked, and opens the WebSocket inside the page automatically.
 
+Here is another example that handles JSON messages:
+
+```js
+await page.routeWebSocket('wss://example.com/ws', ws => {
+  ws.onMessage(message => {
+    const json = JSON.parse(message);
+    if (json.request === 'question')
+      ws.send(JSON.stringify({ response: 'answer' }));
+  });
+});
+```
+
 **Intercepting**
 
 Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Calling [webSocketRoute.connectToServer()](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) returns a server-side `WebSocketRoute` instance that you can send messages to, or handle incoming messages.
@@ -155,7 +167,7 @@ Calling this method again will override the handler with a new one.
 **Usage**
 
 ```js
-await webSocketRoute.onMessage(handler);
+webSocketRoute.onMessage(handler);
 ```
 
 **Arguments**
@@ -163,9 +175,6 @@ await webSocketRoute.onMessage(handler);
   
   Function that will handle messages.
 
-**Returns**
-- [Promise]&lt;[void]&gt;<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-message-return"/><a href="#web-socket-route-on-message-return" class="list-anchor">#</a>
-
 ---
 
 ### send {#web-socket-route-send}
diff --git a/nodejs/docs/ci.mdx b/nodejs/docs/ci.mdx
index 02bb034c0c..d8cc827436 100644
--- a/nodejs/docs/ci.mdx
+++ b/nodejs/docs/ci.mdx
@@ -101,7 +101,7 @@ jobs:
     name: 'Playwright Tests'
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.48.0-noble
+      image: mcr.microsoft.com/playwright:v1.48.1-noble
       options: --user 1001
     steps:
       - uses: actions/checkout@v4
@@ -340,7 +340,7 @@ trigger:
 
 pool:
   vmImage: ubuntu-latest
-container: mcr.microsoft.com/playwright:v1.48.0-noble
+container: mcr.microsoft.com/playwright:v1.48.1-noble
 
 steps:
 - task: NodeTool@0
@@ -364,7 +364,7 @@ Running Playwright on CircleCI is very similar to running on GitHub Actions. In
 executors:
   pw-noble-development:
     docker:
-      - image: mcr.microsoft.com/playwright:v1.48.0-noble
+      - image: mcr.microsoft.com/playwright:v1.48.1-noble
 ```
 
 Note: When using the docker agent definition, you are specifying the resource class of where playwright runs to the 'medium' tier [here](https://circleci.com/docs/configuration-reference?#docker-execution-environment). The default behavior of Playwright is to set the number of workers to the detected core count (2 in the case of the medium tier). Overriding the number of workers to greater than this number will cause unnecessary timeouts and failures.
@@ -387,7 +387,7 @@ Jenkins supports Docker agents for pipelines. Use the [Playwright Docker image](
 
 ```groovy
 pipeline {
-   agent { docker { image 'mcr.microsoft.com/playwright:v1.48.0-noble' } }
+   agent { docker { image 'mcr.microsoft.com/playwright:v1.48.1-noble' } }
    stages {
       stage('e2e-tests') {
          steps {
@@ -404,7 +404,7 @@ pipeline {
 Bitbucket Pipelines can use public [Docker images as build environments](https://confluence.atlassian.com/bitbucket/use-docker-images-as-build-environments-792298897.html). To run Playwright tests on Bitbucket, use our public Docker image ([see Dockerfile](./docker.mdx)).
 
 ```yml
-image: mcr.microsoft.com/playwright:v1.48.0-noble
+image: mcr.microsoft.com/playwright:v1.48.1-noble
 ```
 
 ### GitLab CI
@@ -417,7 +417,7 @@ stages:
 
 tests:
   stage: test
-  image: mcr.microsoft.com/playwright:v1.48.0-noble
+  image: mcr.microsoft.com/playwright:v1.48.1-noble
   script:
   ...
 ```
@@ -432,7 +432,7 @@ stages:
 
 tests:
   stage: test
-  image: mcr.microsoft.com/playwright:v1.48.0-noble
+  image: mcr.microsoft.com/playwright:v1.48.1-noble
   parallel: 7
   script:
     - npm ci
@@ -447,7 +447,7 @@ stages:
 
 tests:
   stage: test
-  image: mcr.microsoft.com/playwright:v1.48.0-noble
+  image: mcr.microsoft.com/playwright:v1.48.1-noble
   parallel:
     matrix:
       - PROJECT: ['chromium', 'webkit']
@@ -463,7 +463,7 @@ To run Playwright tests on Google Cloud Build, use our public Docker image ([see
 
 ```yml
 steps:
-- name: mcr.microsoft.com/playwright:v1.48.0-noble
+- name: mcr.microsoft.com/playwright:v1.48.1-noble
   script: 
   ...
   env:
@@ -481,7 +481,7 @@ type: docker
 
 steps:
   - name: test
-    image: mcr.microsoft.com/playwright:v1.48.0-noble
+    image: mcr.microsoft.com/playwright:v1.48.1-noble
     commands:
       - npx playwright test
 ```
diff --git a/nodejs/docs/docker.mdx b/nodejs/docs/docker.mdx
index b35809ff38..f8ed28e650 100644
--- a/nodejs/docs/docker.mdx
+++ b/nodejs/docs/docker.mdx
@@ -22,7 +22,7 @@ This Docker image is intended to be used for testing and development purposes on
 ### Pull the image
 
 ```bash
-docker pull mcr.microsoft.com/playwright:v1.48.0-noble
+docker pull mcr.microsoft.com/playwright:v1.48.1-noble
 ```
 
 ### Run the image
@@ -34,7 +34,7 @@ By default, the Docker image will use the `root` user to run the browsers. This
 On trusted websites, you can avoid creating a separate user and use root for it since you trust the code which will run on the browsers.
 
 ```bash
-docker run -it --rm --ipc=host mcr.microsoft.com/playwright:v1.48.0-noble /bin/bash
+docker run -it --rm --ipc=host mcr.microsoft.com/playwright:v1.48.1-noble /bin/bash
 ```
 
 #### Crawling and scraping
@@ -42,7 +42,7 @@ docker run -it --rm --ipc=host mcr.microsoft.com/playwright:v1.48.0-noble /bin/b
 On untrusted websites, it's recommended to use a separate user for launching the browsers in combination with the seccomp profile. Inside the container or if you are using the Docker image as a base image you have to use `adduser` for it.
 
 ```bash
-docker run -it --rm --ipc=host --user pwuser --security-opt seccomp=seccomp_profile.json mcr.microsoft.com/playwright:v1.48.0-noble /bin/bash
+docker run -it --rm --ipc=host --user pwuser --security-opt seccomp=seccomp_profile.json mcr.microsoft.com/playwright:v1.48.1-noble /bin/bash
 ```
 
 [`seccomp_profile.json`](https://github.com/microsoft/playwright/blob/main/utils/docker/seccomp_profile.json) is needed to run Chromium with sandbox. This is a [default Docker seccomp profile](https://github.com/docker/engine/blob/d0d99b04cf6e00ed3fc27e81fc3d94e7eda70af3/profiles/seccomp/default.json) with extra user namespace cloning permissions:
@@ -75,10 +75,10 @@ See our [Continuous Integration guides](./ci.mdx) for sample configs.
 See [all available image tags].
 
 We currently publish images with the following tags:
-- `:v1.48.0` - Playwright v1.48.0 release docker image based on Ubuntu 24.04 LTS (Noble Numbat).
-- `:v1.48.0-noble` - Playwright v1.48.0 release docker image based on Ubuntu 24.04 LTS (Noble Numbat).
-- `:v1.48.0-jammy` - Playwright v1.48.0 release docker image based on Ubuntu 22.04 LTS (Jammy Jellyfish).
-- `:v1.48.0-focal` - Playwright v1.48.0 release docker image based on Ubuntu 20.04 LTS (Focal Fossa).
+- `:v1.48.1` - Playwright v1.48.1 release docker image based on Ubuntu 24.04 LTS (Noble Numbat).
+- `:v1.48.1-noble` - Playwright v1.48.1 release docker image based on Ubuntu 24.04 LTS (Noble Numbat).
+- `:v1.48.1-jammy` - Playwright v1.48.1 release docker image based on Ubuntu 22.04 LTS (Jammy Jellyfish).
+- `:v1.48.1-focal` - Playwright v1.48.1 release docker image based on Ubuntu 20.04 LTS (Focal Fossa).
 
 :::note
 
@@ -103,7 +103,7 @@ To run Playwright inside Docker, you need to have Node.js, [Playwright browsers]
 ```Dockerfile
 FROM node:20-bookworm
 
-RUN npx -y playwright@1.48.0 install --with-deps
+RUN npx -y playwright@1.48.1 install --with-deps
 ```
 
 
diff --git a/nodejs/docs/locators.mdx b/nodejs/docs/locators.mdx
index b89750155f..a744e70128 100644
--- a/nodejs/docs/locators.mdx
+++ b/nodejs/docs/locators.mdx
@@ -583,7 +583,7 @@ const button = page.getByRole('button').and(page.getByTitle('Subscribe'));
 
 ### Matching one of the two alternative locators
 
-If you'd like to target one of the two or more elements, and you don't know which one it will be, use [locator.or()](/api/class-locator.mdx#locator-or) to create a locator that matches all of the alternatives.
+If you'd like to target one of the two or more elements, and you don't know which one it will be, use [locator.or()](/api/class-locator.mdx#locator-or) to create a locator that matches any one or both of the alternatives.
 
 For example, consider a scenario where you'd like to click on a "New email" button, but sometimes a security settings dialog shows up instead. In this case, you can wait for either a "New email" button, or a dialog and act accordingly.
 
diff --git a/nodejs/docs/mock.mdx b/nodejs/docs/mock.mdx
index 1f8e02c7e3..8cc9e4562c 100644
--- a/nodejs/docs/mock.mdx
+++ b/nodejs/docs/mock.mdx
@@ -151,6 +151,35 @@ npx playwright open --save-har=example.har --save-har-glob="**/api/**" https://e
 
 Read more about [advanced networking](./network.mdx).
 
+## Mock WebSockets
+
+The following code will intercept WebSocket connections and mock entire communcation over the WebSocket, instead of connecting to the server. This example responds to a `"request"` with a `"response"`.
+
+```js
+await page.routeWebSocket('wss://example.com/ws', ws => {
+  ws.onMessage(message => {
+    if (message === 'request')
+      ws.send('response');
+  });
+});
+```
+
+Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Here is an example that modifies some of the messages sent by the page to the server, and leaves the rest unmodified.
+
+```js
+await page.routeWebSocket('wss://example.com/ws', ws => {
+  const server = ws.connectToServer();
+  ws.onMessage(message => {
+    if (message === 'request')
+      server.send('request2');
+    else
+      server.send(message);
+  });
+});
+```
+
+For more details, see [WebSocketRoute].
+
 
 [Accessibility]: /api/class-accessibility.mdx "Accessibility"
 [Android]: /api/class-android.mdx "Android"
diff --git a/nodejs/docs/network.mdx b/nodejs/docs/network.mdx
index d542fa5e58..7d605bda84 100644
--- a/nodejs/docs/network.mdx
+++ b/nodejs/docs/network.mdx
@@ -12,7 +12,7 @@ Playwright provides APIs to **monitor** and **modify** browser network traffic,
 
 ## Mock APIs
 
-Check out our [API mocking guide](./mock.mdx) to learn more on how to 
+Check out our [API mocking guide](./mock.mdx) to learn more on how to
 - mock API requests and never hit the API
 - perform the API request and modify the response
 - use HAR files to mock network requests.
@@ -315,7 +315,9 @@ Important notes:
 
 ## WebSockets
 
-Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection out of the box. Every time a WebSocket is created, the [page.on('websocket')](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
+Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection, mocking and modifying out of the box. See our [API mocking guide](./mock.mdx#mock-websockets) to learn how to mock WebSockets.
+
+Every time a WebSocket is created, the [page.on('websocket')](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
 
 ```js
 page.on('websocket', ws => {
diff --git a/python/docs/api/class-locator.mdx b/python/docs/api/class-locator.mdx
index 14db00854a..22fd2a4d8b 100644
--- a/python/docs/api/class-locator.mdx
+++ b/python/docs/api/class-locator.mdx
@@ -192,6 +192,69 @@ button = page.get_by_role("button").and_(page.getByTitle("Subscribe"))
 
 ---
 
+### aria_snapshot {#locator-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locator.aria_snapshot</x-search>
+
+Captures the aria snapshot of the given element. See [expect(locator).to_match_aria_snapshot()](/api/class-locatorassertions.mdx#locator-assertions-to-match-aria-snapshot) for the corresponding assertion.
+
+**Usage**
+
+<Tabs
+  groupId="python-flavor"
+  defaultValue="sync"
+  values={[
+    {label: 'Sync', value: 'sync'},
+    {label: 'Async', value: 'async'}
+  ]
+}>
+<TabItem value="sync">
+
+```py
+page.get_by_role("link").aria_snapshot()
+```
+
+</TabItem>
+<TabItem value="async">
+
+```py
+await page.get_by_role("link").aria_snapshot()
+```
+
+</TabItem>
+</Tabs>
+
+**Returns**
+- [str]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-aria-snapshot-return"/><a href="#locator-aria-snapshot-return" class="list-anchor">#</a>
+
+**Details**
+
+This method captures the aria snapshot of the given element. The snapshot is a string that represents the state of the element and its children. The snapshot can be used to assert the state of the element in the test, or to compare it to state in the future.
+
+The ARIA snapshot is represented using [YAML](https://yaml.org/spec/1.2.2/) markup language:
+* The keys of the objects are the roles and optional accessible names of the elements.
+* The values are either text content or an array of child elements.
+* Generic static text can be represented with the `text` key.
+
+Below is the HTML markup and the respective ARIA snapshot:
+
+```html
+<ul aria-label="Links">
+  <li><a href="/">Home</a></li>
+  <li><a href="/about">About</a></li>
+<ul>
+```
+
+```yml
+- list "Links":
+  - listitem:
+    - link "Home"
+  - listitem:
+    - link "About"
+```
+
+---
+
 ### blur {#locator-blur}
 
 <font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.28</font><x-search>locator.blur</x-search>
diff --git a/python/docs/api/class-locatorassertions.mdx b/python/docs/api/class-locatorassertions.mdx
index 3fe0e8257a..5d8dc0fb31 100644
--- a/python/docs/api/class-locatorassertions.mdx
+++ b/python/docs/api/class-locatorassertions.mdx
@@ -2043,6 +2043,54 @@ await expect(locator).to_have_values([re.compile(r"R"), re.compile(r"G")])
 **Returns**
 - [NoneType]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-have-values-return"/><a href="#locator-assertions-to-have-values-return" class="list-anchor">#</a>
 
+---
+
+### to_match_aria_snapshot {#locator-assertions-to-match-aria-snapshot}
+
+<font size="2" style={{position: "relative", top: "-20px"}}>Added in: v1.49</font><x-search>locatorAssertions.to_match_aria_snapshot</x-search>
+
+Asserts that the target element matches the given accessibility snapshot.
+
+**Usage**
+
+<Tabs
+  groupId="python-flavor"
+  defaultValue="sync"
+  values={[
+    {label: 'Sync', value: 'sync'},
+    {label: 'Async', value: 'async'}
+  ]
+}>
+<TabItem value="sync">
+
+```py
+page.goto('https://demo.playwright.dev/todomvc/')
+expect(page.locator('body')).to_match_aria_snapshot('''
+  - heading "todos"
+  - textbox "What needs to be done?"
+''')
+```
+
+</TabItem>
+<TabItem value="async">
+
+```py
+await page.goto('https://demo.playwright.dev/todomvc/')
+await expect(page.locator('body')).to_match_aria_snapshot('''
+  - heading "todos"
+  - textbox "What needs to be done?"
+''')
+```
+
+</TabItem>
+</Tabs>
+
+**Arguments**
+- `expected` [str]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-option-expected"/><a href="#locator-assertions-to-match-aria-snapshot-option-expected" class="list-anchor">#</a>
+
+**Returns**
+- [NoneType]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="locator-assertions-to-match-aria-snapshot-return"/><a href="#locator-assertions-to-match-aria-snapshot-return" class="list-anchor">#</a>
+
 
 [Accessibility]: /api/class-accessibility.mdx "Accessibility"
 [APIRequest]: /api/class-apirequest.mdx "APIRequest"
diff --git a/python/docs/api/class-websocketroute.mdx b/python/docs/api/class-websocketroute.mdx
index 06a705f971..44c9bf23f9 100644
--- a/python/docs/api/class-websocketroute.mdx
+++ b/python/docs/api/class-websocketroute.mdx
@@ -28,7 +28,7 @@ def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
   if message == "request":
     ws.send("response")
 
-page.route_web_socket("/ws", lambda ws: ws.on_message(
+page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
     lambda message: message_handler(ws, message)
 ))
 ```
@@ -41,7 +41,7 @@ def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
   if message == "request":
     ws.send("response")
 
-await page.route_web_socket("/ws", lambda ws: ws.on_message(
+await page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
     lambda message: message_handler(ws, message)
 ))
 ```
@@ -51,6 +51,46 @@ await page.route_web_socket("/ws", lambda ws: ws.on_message(
 
 Since we do not call [web_socket_route.connect_to_server](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) inside the WebSocket route handler, Playwright assumes that WebSocket will be mocked, and opens the WebSocket inside the page automatically.
 
+Here is another example that handles JSON messages:
+
+<Tabs
+  groupId="python-flavor"
+  defaultValue="sync"
+  values={[
+    {label: 'Sync', value: 'sync'},
+    {label: 'Async', value: 'async'}
+  ]
+}>
+<TabItem value="sync">
+
+```py
+def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+  json_message = json.loads(message)
+  if json_message["request"] == "question":
+    ws.send(json.dumps({ "response": "answer" }))
+
+page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
+    lambda message: message_handler(ws, message)
+))
+```
+
+</TabItem>
+<TabItem value="async">
+
+```py
+def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+  json_message = json.loads(message)
+  if json_message["request"] == "question":
+    ws.send(json.dumps({ "response": "answer" }))
+
+await page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
+    lambda message: message_handler(ws, message)
+))
+```
+
+</TabItem>
+</Tabs>
+
 **Intercepting**
 
 Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Calling [web_socket_route.connect_to_server](/api/class-websocketroute.mdx#web-socket-route-connect-to-server) returns a server-side `WebSocketRoute` instance that you can send messages to, or handle incoming messages.
@@ -205,7 +245,7 @@ web_socket_route.on_close(handler)
 ```
 
 **Arguments**
-- `handler` [Callable]\[[number] | [undefined]\]:[Promise]\[[Any]\] | [Any]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
+- `handler` [Callable]\[[int] | [undefined]\]:[Promise]\[[Any]\] | [Any]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-close-option-handler"/><a href="#web-socket-route-on-close-option-handler" class="list-anchor">#</a>
   
   Function that will handle WebSocket closure. Received an optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code) and an optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
 
@@ -234,9 +274,6 @@ web_socket_route.on_message(handler)
   
   Function that will handle messages.
 
-**Returns**
-- [NoneType]<a aria-hidden="true" tabIndex="-1" class="list-anchor-link" id="web-socket-route-on-message-return"/><a href="#web-socket-route-on-message-return" class="list-anchor">#</a>
-
 ---
 
 ### send {#web-socket-route-send}
diff --git a/python/docs/locators.mdx b/python/docs/locators.mdx
index 11a466a395..676dfa49f1 100644
--- a/python/docs/locators.mdx
+++ b/python/docs/locators.mdx
@@ -1224,7 +1224,7 @@ button = page.get_by_role("button").and_(page.getByTitle("Subscribe"))
 
 ### Matching one of the two alternative locators
 
-If you'd like to target one of the two or more elements, and you don't know which one it will be, use [locator.or_()](/api/class-locator.mdx#locator-or) to create a locator that matches all of the alternatives.
+If you'd like to target one of the two or more elements, and you don't know which one it will be, use [locator.or_()](/api/class-locator.mdx#locator-or) to create a locator that matches any one or both of the alternatives.
 
 For example, consider a scenario where you'd like to click on a "New email" button, but sometimes a security settings dialog shows up instead. In this case, you can wait for either a "New email" button, or a dialog and act accordingly.
 
diff --git a/python/docs/mock.mdx b/python/docs/mock.mdx
index b83d7c3442..9f8364a29c 100644
--- a/python/docs/mock.mdx
+++ b/python/docs/mock.mdx
@@ -270,6 +270,94 @@ playwright open --save-har=example.har --save-har-glob="**/api/**" https://examp
 
 Read more about [advanced networking](./network.mdx).
 
+## Mock WebSockets
+
+The following code will intercept WebSocket connections and mock entire communcation over the WebSocket, instead of connecting to the server. This example responds to a `"request"` with a `"response"`.
+
+<Tabs
+  groupId="python-flavor"
+  defaultValue="sync"
+  values={[
+    {label: 'Sync', value: 'sync'},
+    {label: 'Async', value: 'async'}
+  ]
+}>
+<TabItem value="sync">
+
+```py
+def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+  if message == "request":
+    ws.send("response")
+
+page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
+    lambda message: message_handler(ws, message)
+))
+```
+
+</TabItem>
+<TabItem value="async">
+
+```py
+def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+  if message == "request":
+    ws.send("response")
+
+await page.route_web_socket("wss://example.com/ws", lambda ws: ws.on_message(
+    lambda message: message_handler(ws, message)
+))
+```
+
+</TabItem>
+</Tabs>
+
+Alternatively, you may want to connect to the actual server, but intercept messages in-between and modify or block them. Here is an example that modifies some of the messages sent by the page to the server, and leaves the rest unmodified.
+
+<Tabs
+  groupId="python-flavor"
+  defaultValue="sync"
+  values={[
+    {label: 'Sync', value: 'sync'},
+    {label: 'Async', value: 'async'}
+  ]
+}>
+<TabItem value="sync">
+
+```py
+def message_handler(server: WebSocketRoute, message: Union[str, bytes]):
+  if message == "request":
+    server.send("request2")
+  else:
+    server.send(message)
+
+def handler(ws: WebSocketRoute):
+  server = ws.connect_to_server()
+  ws.on_message(lambda message: message_handler(server, message))
+
+page.route_web_socket("wss://example.com/ws", handler)
+```
+
+</TabItem>
+<TabItem value="async">
+
+```py
+def message_handler(server: WebSocketRoute, message: Union[str, bytes]):
+  if message == "request":
+    server.send("request2")
+  else:
+    server.send(message)
+
+def handler(ws: WebSocketRoute):
+  server = ws.connect_to_server()
+  ws.on_message(lambda message: message_handler(server, message))
+
+await page.route_web_socket("wss://example.com/ws", handler)
+```
+
+</TabItem>
+</Tabs>
+
+For more details, see [WebSocketRoute].
+
 
 [Accessibility]: /api/class-accessibility.mdx "Accessibility"
 [APIRequest]: /api/class-apirequest.mdx "APIRequest"
diff --git a/python/docs/network.mdx b/python/docs/network.mdx
index 79a604b28a..2861c63de9 100644
--- a/python/docs/network.mdx
+++ b/python/docs/network.mdx
@@ -12,7 +12,7 @@ Playwright provides APIs to **monitor** and **modify** browser network traffic,
 
 ## Mock APIs
 
-Check out our [API mocking guide](./mock.mdx) to learn more on how to 
+Check out our [API mocking guide](./mock.mdx) to learn more on how to
 - mock API requests and never hit the API
 - perform the API request and modify the response
 - use HAR files to mock network requests.
@@ -479,7 +479,9 @@ Important notes:
 
 ## WebSockets
 
-Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection out of the box. Every time a WebSocket is created, the [page.on("websocket")](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
+Playwright supports [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) inspection, mocking and modifying out of the box. See our [API mocking guide](./mock.mdx#mock-websockets) to learn how to mock WebSockets.
+
+Every time a WebSocket is created, the [page.on("websocket")](/api/class-page.mdx#page-event-web-socket) event is fired. This event contains the [WebSocket] instance for further web socket frames inspection:
 
 ```python
 def on_web_socket(ws):
diff --git a/src/format_csharp.js b/src/format_csharp.js
index e8d3392f8f..9282da217b 100644
--- a/src/format_csharp.js
+++ b/src/format_csharp.js
@@ -100,8 +100,10 @@ class CSharpFormatter {
   formatFunction(args, ret, type) {
     if (type.args.length === 0 && type.returnType.name === 'Promise')
       return `[Func]<[Task]>`;
+    if (type.args.length === 2 && type.args[0].name === 'int?' && type.args[1].name === 'string' && !type.returnType)
+      return 'Action<int?, string>';
     if (type.args.length !== 1)
-      throw new Error('Unsupported number of arguments in function: ' + type);
+      throw new Error('Unsupported number of arguments in function: ' + JSON.stringify(type));
     if (!type.returnType)
       return "[Action]<" + args + ">";
     if (type.returnType.name === 'boolean')