diff --git a/.azure-pipelines/publish.yml b/.azure-pipelines/publish.yml
index 52af52ceb..1a2e0e7a4 100644
--- a/.azure-pipelines/publish.yml
+++ b/.azure-pipelines/publish.yml
@@ -29,35 +29,54 @@ extends:
     stages:
     - stage: Stage
       jobs:
-      - job: HostJob
+      - job: Build
+        templateContext:
+          outputs:
+          - output: pipelineArtifact
+            path: $(Build.ArtifactStagingDirectory)/esrp-build
+            artifact: esrp-build
         steps:
         - task: UsePythonVersion@0
           inputs:
-            versionSpec: '3.8'
+            versionSpec: '3.9'
           displayName: 'Use Python'
         - script: |
             python -m pip install --upgrade pip
             pip install -r local-requirements.txt
+            pip install -r requirements.txt
             pip install -e .
-            python setup.py bdist_wheel --all
+            for wheel in $(python setup.py --list-wheels); do
+              PLAYWRIGHT_TARGET_WHEEL=$wheel python -m build --wheel --outdir $(Build.ArtifactStagingDirectory)/esrp-build
+            done
           displayName: 'Install & Build'
-        - task: EsrpRelease@7
+      - job: Publish
+        dependsOn: Build
+        templateContext:
+          type: releaseJob
+          isProduction: true
           inputs:
-            connectedservicename: 'Playwright-ESRP-Azure'
-            keyvaultname: 'pw-publishing-secrets'
-            authcertname: 'ESRP-Release-Auth'
-            signcertname: 'ESRP-Release-Sign'
-            clientid: '13434a40-7de4-4c23-81a3-d843dc81c2c5'
-            intent: 'PackageDistribution'
-            contenttype: 'PyPi'
-            # Keeping it commented out as a workaround for:
-            # https://portal.microsofticm.com/imp/v3/incidents/incident/499972482/summary
-            # contentsource: 'folder'
-            folderlocation: './dist/'
-            waitforreleasecompletion: true
-            owners: 'maxschmitt@microsoft.com'
-            approvers: 'maxschmitt@microsoft.com'
-            serviceendpointurl: 'https://api.esrp.microsoft.com'
-            mainpublisher: 'Playwright'
-            domaintenantid: '72f988bf-86f1-41af-91ab-2d7cd011db47'
-          displayName: 'ESRP Release to PIP'
+          - input: pipelineArtifact
+            artifactName: esrp-build
+            targetPath: $(Build.ArtifactStagingDirectory)/esrp-build
+        steps:
+          - checkout: none
+          - task: EsrpRelease@9
+            inputs:
+              connectedservicename: 'Playwright-ESRP-PME'
+              usemanagedidentity: true
+              keyvaultname: 'playwright-esrp-pme'
+              signcertname: 'ESRP-Release-Sign'
+              clientid: '13434a40-7de4-4c23-81a3-d843dc81c2c5'
+              intent: 'PackageDistribution'
+              contenttype: 'PyPi'
+              # Keeping it commented out as a workaround for:
+              # https://portal.microsofticm.com/imp/v3/incidents/incident/499972482/summary
+              # contentsource: 'folder'
+              folderlocation: '$(Build.ArtifactStagingDirectory)/esrp-build'
+              waitforreleasecompletion: true
+              owners: 'yurys@microsoft.com'
+              approvers: 'yurys@microsoft.com'
+              serviceendpointurl: 'https://api.esrp.microsoft.com'
+              mainpublisher: 'Playwright'
+              domaintenantid: '975f013f-7f24-47e8-a7d3-abc4752bf346'
+            displayName: 'ESRP Release to PIP'
diff --git a/.claude/skills/playwright-roll/SKILL.md b/.claude/skills/playwright-roll/SKILL.md
new file mode 100644
index 000000000..ece920353
--- /dev/null
+++ b/.claude/skills/playwright-roll/SKILL.md
@@ -0,0 +1,23 @@
+---
+name: playwright-roll
+description: Roll Playwright Python to a new version
+---
+
+Help the user roll to a new version of Playwright.
+../../../ROLLING.md contains general instructions and scripts.
+
+Start with updating the version and generating the API to see the state of things.
+
+Afterwards, work through the list of changes that need to be backported.
+You can find a list of pull requests that might need to be taking into account in the issue titled "Backport changes".
+Work through them one-by-one and check off the items that you have handled.
+Not all of them will be relevant, some might have partially been reverted, etc. - so feel free to check with the upstream release branch.
+
+Rolling includes:
+- updating client implementation to match changes in the upstream JS implementation (see ../playwright/packages/playwright-core/src/client)
+- adding a couple of new tests to verify new/changed functionality
+
+## Tips & Tricks
+- Project checkouts are in the parent directory (`../`).
+- when updating checkboxes, store the issue content into /tmp and edit it there, then update the issue based on the file
+- use the "gh" cli to interact with GitHub
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 6a7695c06..33c127127 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,3 +4,11 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns:
+          - "*"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 55f66440c..65ba1f433 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,17 +21,18 @@ jobs:
     name: Lint
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: "3.10"
     - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-        python setup.py bdist_wheel
+        python -m build --wheel
         python -m playwright install --with-deps
     - name: Lint
       run: pre-commit run --show-diff-on-failure --color=always --all-files
@@ -47,18 +48,9 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: [3.8, 3.9]
+        python-version: ['3.9', '3.10']
         browser: [chromium, firefox, webkit]
         include:
-        - os: ubuntu-latest
-          python-version: '3.10'
-          browser: chromium
-        - os: windows-latest
-          python-version: '3.10'
-          browser: chromium
-        - os: macos-latest
-          python-version: '3.10'
-          browser: chromium
         - os: windows-latest
           python-version: '3.11'
           browser: chromium
@@ -77,19 +69,29 @@ jobs:
         - os: ubuntu-latest
           python-version: '3.12'
           browser: chromium
+        - os: windows-latest
+          python-version: '3.13'
+          browser: chromium
+        - os: macos-latest
+          python-version: '3.13'
+          browser: chromium
+        - os: ubuntu-latest
+          python-version: '3.13'
+          browser: chromium
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-        python setup.py bdist_wheel
+        python -m build --wheel
         python -m playwright install --with-deps ${{ matrix.browser }}
     - name: Common Tests
       run: pytest tests/common --browser=${{ matrix.browser }} --timeout 90
@@ -125,17 +127,18 @@ jobs:
           browser-channel: msedge
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: "3.10"
     - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-        python setup.py bdist_wheel
+        python -m build --wheel
         python -m playwright install ${{ matrix.browser-channel }} --with-deps
     - name: Common Tests
       run: pytest tests/common --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
@@ -157,10 +160,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-13, windows-2019]
+        os: [ubuntu-22.04, macos-13, windows-2022]
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Get conda
@@ -168,6 +171,7 @@ jobs:
         with:
           python-version: 3.9
           channels: conda-forge
+          miniconda-version: latest
       - name: Prepare
         run: conda install conda-build conda-verify
       - name: Build
@@ -180,9 +184,9 @@ jobs:
       run:
         working-directory: examples/todomvc/
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: '3.10'
     - name: Install dependencies & browsers
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index cae28da1a..c6e71028a 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -2,9 +2,11 @@ name: Upload Python Package
 on:
   release:
     types: [published]
+  workflow_dispatch:
 jobs:
   deploy-conda:
     strategy:
+      fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
@@ -23,18 +25,17 @@ jobs:
         # Required for conda-incubator/setup-miniconda@v3
         shell: bash -el {0}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Get conda
         uses: conda-incubator/setup-miniconda@v3
         with:
-          python-version: 3.12
+          python-version: 3.9
           channels: conda-forge
           miniconda-version: latest
       - name: Prepare
-        # Pinned because of https://github.com/conda/conda-build/issues/5267
-        run: conda install anaconda-client conda-build=24.1.2 conda-verify py-lief=0.12.3
+        run: conda install anaconda-client conda-build conda-verify
       - name: Build and Upload
         env:
           ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_API_TOKEN }}
@@ -43,7 +44,6 @@ jobs:
           if [ "${{ matrix.target-platform }}" == "osx-arm64" ]; then
             conda build --user microsoft . -m conda_build_config_osx_arm64.yaml
           elif [ "${{ matrix.target-platform }}" == "linux-aarch64" ]; then
-            conda install cross-python_linux-aarch64
             conda build --user microsoft . -m conda_build_config_linux_aarch64.yaml
           else
             conda build --user microsoft .
diff --git a/.github/workflows/publish_docker.yml b/.github/workflows/publish_docker.yml
index d0db5543d..7494f1abc 100644
--- a/.github/workflows/publish_docker.yml
+++ b/.github/workflows/publish_docker.yml
@@ -15,7 +15,7 @@ jobs:
       contents: read    # This is required for actions/checkout to succeed
     environment: Docker
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Azure login
       uses: azure/login@v2
       with:
@@ -25,16 +25,17 @@ jobs:
     - name: Login to ACR via OIDC
       run: az acr login --name playwright
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: "3.10"
     - name: Set up Docker QEMU for arm64 docker builds
-      uses: docker/setup-qemu-action@v2
+      uses: docker/setup-qemu-action@v3
       with:
         platforms: arm64
     - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
     - run: ./utils/docker/publish_docker.sh stable
diff --git a/.github/workflows/test_docker.yml b/.github/workflows/test_docker.yml
index 178200f75..464eb3b46 100644
--- a/.github/workflows/test_docker.yml
+++ b/.github/workflows/test_docker.yml
@@ -19,34 +19,40 @@ on:
 jobs:
   build:
     timeout-minutes: 120
-    runs-on: ubuntu-24.04
+    runs-on: ${{ matrix.runs-on }}
     strategy:
       fail-fast: false
       matrix:
         docker-image-variant:
-          - focal
           - jammy
           - noble
+        runs-on:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: "3.10"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
     - name: Build Docker image
-      run: bash utils/docker/build.sh --amd64 ${{ matrix.docker-image-variant }} playwright-python:localbuild-${{ matrix.docker-image-variant }}
+      run: |
+        ARCH="${{ matrix.runs-on == 'ubuntu-24.04-arm' && 'arm64' || 'amd64' }}"
+        bash utils/docker/build.sh --$ARCH ${{ matrix.docker-image-variant }} playwright-python:localbuild-${{ matrix.docker-image-variant }}
     - name: Test
       run: |
-        CONTAINER_ID="$(docker run --rm -v $(pwd):/root/playwright --name playwright-docker-test --workdir /root/playwright/ -d -t playwright-python:localbuild-${{ matrix.docker-image-variant }} /bin/bash)"
+        CONTAINER_ID="$(docker run --rm -e CI -v $(pwd):/root/playwright --name playwright-docker-test --workdir /root/playwright/ -d -t playwright-python:localbuild-${{ matrix.docker-image-variant }} /bin/bash)"
         # Fix permissions for Git inside the container
         docker exec "${CONTAINER_ID}" chown -R root:root /root/playwright
         docker exec "${CONTAINER_ID}" pip install -r local-requirements.txt
+        docker exec "${CONTAINER_ID}" pip install -r requirements.txt
         docker exec "${CONTAINER_ID}" pip install -e .
-        docker exec "${CONTAINER_ID}" python setup.py bdist_wheel
-        docker exec "${CONTAINER_ID}" xvfb-run pytest -vv tests/sync/
-        docker exec "${CONTAINER_ID}" xvfb-run pytest -vv tests/async/
+        docker exec "${CONTAINER_ID}" python -m build --wheel
+        docker exec "${CONTAINER_ID}" xvfb-run pytest tests/sync/
+        docker exec "${CONTAINER_ID}" xvfb-run pytest tests/async/
diff --git a/.github/workflows/trigger_internal_tests.yml b/.github/workflows/trigger_internal_tests.yml
deleted file mode 100644
index b4e6c21db..000000000
--- a/.github/workflows/trigger_internal_tests.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-name: "Internal Tests"
-
-on:
-  push:
-    branches:
-      - main
-      - release-*
-
-jobs:
-  trigger:
-    name: "trigger"
-    runs-on: ubuntu-20.04
-    steps:
-    - run: |
-        curl -X POST \
-          -H "Accept: application/vnd.github.v3+json" \
-          -H "Authorization: token ${GH_TOKEN}" \
-          --data "{\"event_type\": \"playwright_tests_python\", \"client_payload\": {\"ref\": \"${GITHUB_SHA}\"}}" \
-          https://api.github.com/repos/microsoft/playwright-browsers/dispatches
-      env:
-        GH_TOKEN: ${{ secrets.REPOSITORY_DISPATCH_PERSONAL_ACCESS_TOKEN }}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5198070e1..57fdca816 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v5.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -15,20 +15,20 @@ repos:
       - id: check-executables-have-shebangs
       - id: check-merge-conflict
   - repo: https://github.com/psf/black
-    rev: 23.9.1
+    rev: 25.1.0
     hooks:
       - id: black
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.8.0
+    rev: v1.17.0
     hooks:
       - id: mypy
-        additional_dependencies: [types-pyOpenSSL==23.2.0.2, types-requests==2.31.0.10]
+        additional_dependencies: [types-pyOpenSSL==24.1.0.20240722, types-requests==2.32.4.20250611]
   - repo: https://github.com/pycqa/flake8
-    rev: 6.1.0
+    rev: 7.3.0
     hooks:
       - id: flake8
   - repo: https://github.com/pycqa/isort
-    rev: 5.13.2
+    rev: 6.0.1
     hooks:
       - id: isort
   - repo: local
@@ -39,7 +39,7 @@ repos:
         language: node
         pass_filenames: false
         types: [python]
-        additional_dependencies: ["pyright@1.1.278"]
+        additional_dependencies: ["pyright@1.1.403"]
   - repo: local
     hooks:
       - id: check-license-header
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a5ab7d4bd..b59e281c8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -23,9 +23,7 @@ Build and install drivers:
 
 ```sh
 pip install -e .
-python setup.py bdist_wheel
-# For all platforms
-python setup.py bdist_wheel --all
+python -m build --wheel
 ```
 
 Run tests:
@@ -47,7 +45,7 @@ pre-commit install
 pre-commit run --all-files
 ```
 
-For more details look at the [CI configuration](./blob/main/.github/workflows/ci.yml).
+For more details look at the [CI configuration](./.github/workflows/ci.yml).
 
 Collect coverage
 
diff --git a/README.md b/README.md
index d94692919..c5e2d70b0 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,9 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->129.0.6668.29<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->18.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->130.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->145.0.7632.6<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->146.0.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 
diff --git a/ROLLING.md b/ROLLING.md
index 2d35ee1e7..811d7fcb3 100644
--- a/ROLLING.md
+++ b/ROLLING.md
@@ -5,12 +5,14 @@
     * create virtual environment, if don't have one: `python -m venv env`
 * activate venv: `source env/bin/activate`
 * install all deps:
-     - `python -m pip install --upgrade pip`
-     - `pip install -r local-requirements.txt`
-     - `pre-commit install`
-     - `pip install -e .`
+```
+python -m pip install --upgrade pip
+pip install -r local-requirements.txt
+pre-commit install
+pip install -e .
+```
 * change driver version in `setup.py`
-* download new driver: `python setup.py bdist_wheel`
+* download new driver: `python -m build --wheel`
 * generate API: `./scripts/update_api.sh`
 * commit changes & send PR
 * wait for bots to pass & merge the PR
diff --git a/examples/todomvc/requirements.txt b/examples/todomvc/requirements.txt
index eb6fcbbd0..801cd515b 100644
--- a/examples/todomvc/requirements.txt
+++ b/examples/todomvc/requirements.txt
@@ -1 +1 @@
-pytest-playwright==0.3.0
+pytest-playwright
diff --git a/local-requirements.txt b/local-requirements.txt
index 6e5fd056f..8a72b5745 100644
--- a/local-requirements.txt
+++ b/local-requirements.txt
@@ -1,24 +1,22 @@
-auditwheel==6.1.0
 autobahn==23.1.2
-black==24.8.0
-flake8==7.1.1
-flaky==3.8.1
-mypy==1.11.2
-objgraph==3.6.1
-Pillow==10.4.0
+black==25.1.0
+build==1.3.0
+flake8==7.2.0
+mypy==1.17.1
+objgraph==3.6.2
+Pillow==11.3.0
 pixelmatch==0.3.0
-pre-commit==3.4.0
-pyOpenSSL==24.2.1
-pytest==8.3.2
-pytest-asyncio==0.21.2
-pytest-cov==5.0.0
-pytest-repeat==0.9.3
-pytest-timeout==2.3.1
-pytest-xdist==3.6.1
-requests==2.32.3
-service_identity==24.1.0
-setuptools==74.0.0
-twisted==24.7.0
+pre-commit==3.5.0
+pyOpenSSL==25.1.0
+pytest==8.4.1
+pytest-asyncio==1.1.0
+pytest-cov==6.3.0
+pytest-repeat==0.9.4
+pytest-rerunfailures==15.1
+pytest-timeout==2.4.0
+pytest-xdist==3.8.0
+requests==2.32.5
+service_identity==24.2.0
+twisted==25.5.0
 types-pyOpenSSL==24.1.0.20240722
-types-requests==2.32.0.20240712
-wheel==0.42.0
+types-requests==2.32.4.20250809
diff --git a/meta.yaml b/meta.yaml
index 4b416db9c..343f9b568 100644
--- a/meta.yaml
+++ b/meta.yaml
@@ -15,21 +15,25 @@ build:
 
 requirements:
   build:
-    - python >=3.8                        # [build_platform != target_platform]
+    - python >=3.9                        # [build_platform != target_platform]
     - pip                                 # [build_platform != target_platform]
     - cross-python_{{ target_platform }}  # [build_platform != target_platform]
   host:
-    - python >=3.8
+    - python >=3.9
     - wheel
     - pip
     - curl
     - setuptools_scm
   run:
-    - python >=3.8
-    - greenlet ==3.0.3
-    - pyee ==12.0.0
+    - python >=3.9
+    # This should be the same as the dependencies in pyproject.toml
+    - greenlet>=3.1.1,<4.0.0
+    - pyee>=13,<14
 
 test: # [build_platform == target_platform]
+  files:
+    - scripts/example_sync.py
+    - scripts/example_async.py
   requires:
     - pip
   imports:
@@ -38,6 +42,9 @@ test: # [build_platform == target_platform]
     - playwright.async_api
   commands:
     - playwright --help
+    - playwright install --with-deps
+    - python scripts/example_sync.py
+    - python scripts/example_async.py
 
 about:
   home: https://github.com/microsoft/playwright-python
diff --git a/playwright/_impl/_accessibility.py b/playwright/_impl/_accessibility.py
deleted file mode 100644
index 010b4e8c5..000000000
--- a/playwright/_impl/_accessibility.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Dict, Optional
-
-from playwright._impl._connection import Channel
-from playwright._impl._element_handle import ElementHandle
-from playwright._impl._helper import locals_to_params
-
-
-def _ax_node_from_protocol(axNode: Dict) -> Dict:
-    result = {**axNode}
-    if "valueNumber" in axNode:
-        result["value"] = axNode["valueNumber"]
-    elif "valueString" in axNode:
-        result["value"] = axNode["valueString"]
-
-    if "checked" in axNode:
-        result["checked"] = (
-            True
-            if axNode.get("checked") == "checked"
-            else (
-                False if axNode.get("checked") == "unchecked" else axNode.get("checked")
-            )
-        )
-
-    if "pressed" in axNode:
-        result["pressed"] = (
-            True
-            if axNode.get("pressed") == "pressed"
-            else (
-                False if axNode.get("pressed") == "released" else axNode.get("pressed")
-            )
-        )
-
-    if axNode.get("children"):
-        result["children"] = list(map(_ax_node_from_protocol, axNode["children"]))
-    if "valueNumber" in result:
-        del result["valueNumber"]
-    if "valueString" in result:
-        del result["valueString"]
-    return result
-
-
-class Accessibility:
-    def __init__(self, channel: Channel) -> None:
-        self._channel = channel
-        self._loop = channel._connection._loop
-        self._dispatcher_fiber = channel._connection._dispatcher_fiber
-
-    async def snapshot(
-        self, interestingOnly: bool = None, root: ElementHandle = None
-    ) -> Optional[Dict]:
-        params = locals_to_params(locals())
-        if root:
-            params["root"] = root._channel
-        result = await self._channel.send("accessibilitySnapshot", params)
-        return _ax_node_from_protocol(result) if result else None
diff --git a/playwright/_impl/_api_structures.py b/playwright/_impl/_api_structures.py
index 904a590a9..c0d0ee442 100644
--- a/playwright/_impl/_api_structures.py
+++ b/playwright/_impl/_api_structures.py
@@ -32,6 +32,18 @@ class Cookie(TypedDict, total=False):
     httpOnly: bool
     secure: bool
     sameSite: Literal["Lax", "None", "Strict"]
+    partitionKey: Optional[str]
+
+
+class StorageStateCookie(TypedDict, total=False):
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    httpOnly: bool
+    secure: bool
+    sameSite: Literal["Lax", "None", "Strict"]
 
 
 # TODO: We are waiting for PEP705 so SetCookieParam can be readonly and matches Cookie.
@@ -45,6 +57,7 @@ class SetCookieParam(TypedDict, total=False):
     httpOnly: Optional[bool]
     secure: Optional[bool]
     sameSite: Optional[Literal["Lax", "None", "Strict"]]
+    partitionKey: Optional[str]
 
 
 class FloatRect(TypedDict):
@@ -97,7 +110,7 @@ class ProxySettings(TypedDict, total=False):
 
 
 class StorageState(TypedDict, total=False):
-    cookies: List[Cookie]
+    cookies: List[StorageStateCookie]
     origins: List[OriginState]
 
 
@@ -205,6 +218,7 @@ class FrameExpectResult(TypedDict):
     matches: bool
     received: Any
     log: List[str]
+    errorMessage: Optional[str]
 
 
 AriaRole = Literal[
@@ -291,3 +305,9 @@ class FrameExpectResult(TypedDict):
     "treegrid",
     "treeitem",
 ]
+
+
+class TracingGroupLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
diff --git a/playwright/_impl/_artifact.py b/playwright/_impl/_artifact.py
index d619c35e2..a08294cbe 100644
--- a/playwright/_impl/_artifact.py
+++ b/playwright/_impl/_artifact.py
@@ -33,27 +33,55 @@ async def path_after_finished(self) -> pathlib.Path:
             raise Error(
                 "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
             )
-        path = await self._channel.send("pathAfterFinished")
+        path = await self._channel.send(
+            "pathAfterFinished",
+            None,
+        )
         return pathlib.Path(path)
 
     async def save_as(self, path: Union[str, Path]) -> None:
-        stream = cast(Stream, from_channel(await self._channel.send("saveAsStream")))
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "saveAsStream",
+                    None,
+                )
+            ),
+        )
         make_dirs_for_file(path)
         await stream.save_as(path)
 
     async def failure(self) -> Optional[str]:
-        reason = await self._channel.send("failure")
+        reason = await self._channel.send(
+            "failure",
+            None,
+        )
         if reason is None:
             return None
         return patch_error_message(reason)
 
     async def delete(self) -> None:
-        await self._channel.send("delete")
+        await self._channel.send(
+            "delete",
+            None,
+        )
 
     async def read_info_buffer(self) -> bytes:
-        stream = cast(Stream, from_channel(await self._channel.send("stream")))
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "stream",
+                    None,
+                )
+            ),
+        )
         buffer = await stream.read_all()
         return buffer
 
-    async def cancel(self) -> None:
-        await self._channel.send("cancel")
+    async def cancel(self) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
+        await self._channel.send(
+            "cancel",
+            None,
+        )
diff --git a/playwright/_impl/_assertions.py b/playwright/_impl/_assertions.py
index 5841eca5a..aea37d35c 100644
--- a/playwright/_impl/_assertions.py
+++ b/playwright/_impl/_assertions.py
@@ -20,6 +20,7 @@
     AriaRole,
     ExpectedTextValue,
     FrameExpectOptions,
+    FrameExpectResult,
 )
 from playwright._impl._connection import format_call_log
 from playwright._impl._errors import Error
@@ -45,12 +46,20 @@ def __init__(
         self._is_not = is_not
         self._custom_message = message
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        raise NotImplementedError(
+            "_call_expect must be implemented in a derived class."
+        )
+
     async def _expect_impl(
         self,
         expression: str,
         expect_options: FrameExpectOptions,
         expected: Any,
         message: str,
+        title: str = None,
     ) -> None:
         __tracebackhide__ = True
         expect_options["isNot"] = self._is_not
@@ -60,7 +69,7 @@ async def _expect_impl(
             message = message.replace("expected to", "expected not to")
         if "useInnerText" in expect_options and expect_options["useInnerText"] is None:
             del expect_options["useInnerText"]
-        result = await self._actual_locator._expect(expression, expect_options)
+        result = await self._call_expect(expression, expect_options, title)
         if result["matches"] == self._is_not:
             actual = result.get("received")
             if self._custom_message:
@@ -71,8 +80,10 @@ async def _expect_impl(
                 out_message = (
                     f"{message} '{expected}'" if expected is not None else f"{message}"
                 )
+            error_message = result.get("errorMessage")
+            error_message = f"\n{error_message}" if error_message else ""
             raise AssertionError(
-                f"{out_message}\nActual value: {actual} {format_call_log(result.get('log'))}"
+                f"{out_message}\nActual value: {actual}{error_message} {format_call_log(result.get('log'))}"
             )
 
 
@@ -87,6 +98,14 @@ def __init__(
         super().__init__(page.locator(":root"), timeout, is_not, message)
         self._actual_page = page
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_page.main_frame._expect(
+            None, expression, expect_options, title
+        )
+
     @property
     def _not(self) -> "PageAssertions":
         return PageAssertions(
@@ -105,6 +124,7 @@ async def to_have_title(
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
             titleOrRegExp,
             "Page title expected to be",
+            'Expect "to_have_title"',
         )
 
     async def not_to_have_title(
@@ -120,7 +140,7 @@ async def to_have_url(
         ignoreCase: bool = None,
     ) -> None:
         __tracebackhide__ = True
-        base_url = self._actual_page.context._options.get("baseURL")
+        base_url = self._actual_page.context._base_url
         if isinstance(urlOrRegExp, str) and base_url:
             urlOrRegExp = urljoin(base_url, urlOrRegExp)
         expected_text = to_expected_text_values([urlOrRegExp], ignoreCase=ignoreCase)
@@ -129,6 +149,7 @@ async def to_have_url(
             FrameExpectOptions(expectedText=expected_text, timeout=timeout),
             urlOrRegExp,
             "Page URL expected to be",
+            'Expect "to_have_url"',
         )
 
     async def not_to_have_url(
@@ -152,6 +173,12 @@ def __init__(
         super().__init__(locator, timeout, is_not, message)
         self._actual_locator = locator
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_locator._expect(expression, expect_options, title)
+
     @property
     def _not(self) -> "LocatorAssertions":
         return LocatorAssertions(
@@ -190,6 +217,7 @@ async def to_contain_text(
                 ),
                 expected,
                 "Locator expected to contain text",
+                'Expect "to_contain_text"',
             )
         else:
             expected_text = to_expected_text_values(
@@ -207,6 +235,7 @@ async def to_contain_text(
                 ),
                 expected,
                 "Locator expected to contain text",
+                'Expect "to_contain_text"',
             )
 
     async def not_to_contain_text(
@@ -241,6 +270,7 @@ async def to_have_attribute(
             ),
             value,
             "Locator expected to have attribute",
+            'Expect "to_have_attribute"',
         )
 
     async def not_to_have_attribute(
@@ -276,6 +306,7 @@ async def to_have_class(
                 FrameExpectOptions(expectedText=expected_text, timeout=timeout),
                 expected,
                 "Locator expected to have class",
+                'Expect "to_have_class"',
             )
         else:
             expected_text = to_expected_text_values([expected])
@@ -284,6 +315,7 @@ async def to_have_class(
                 FrameExpectOptions(expectedText=expected_text, timeout=timeout),
                 expected,
                 "Locator expected to have class",
+                'Expect "to_have_class"',
             )
 
     async def not_to_have_class(
@@ -300,6 +332,47 @@ async def not_to_have_class(
         __tracebackhide__ = True
         await self._not.to_have_class(expected, timeout)
 
+    async def to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(expected)
+            await self._expect_impl(
+                "to.contain.class.array",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class names",
+                'Expect "to_contain_class"',
+            )
+        else:
+            expected_text = to_expected_text_values([expected])
+            await self._expect_impl(
+                "to.contain.class",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class",
+                'Expect "to_contain_class"',
+            )
+
+    async def not_to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_contain_class(expected, timeout)
+
     async def to_have_count(
         self,
         count: int,
@@ -311,6 +384,7 @@ async def to_have_count(
             FrameExpectOptions(expectedNumber=count, timeout=timeout),
             count,
             "Locator expected to have count",
+            'Expect "to_have_count"',
         )
 
     async def not_to_have_count(
@@ -336,6 +410,7 @@ async def to_have_css(
             ),
             value,
             "Locator expected to have CSS",
+            'Expect "to_have_css"',
         )
 
     async def not_to_have_css(
@@ -359,6 +434,7 @@ async def to_have_id(
             FrameExpectOptions(expectedText=expected_text, timeout=timeout),
             id,
             "Locator expected to have ID",
+            'Expect "to_have_id"',
         )
 
     async def not_to_have_id(
@@ -383,6 +459,7 @@ async def to_have_js_property(
             ),
             value,
             "Locator expected to have JS Property",
+            'Expect "to_have_property"',
         )
 
     async def not_to_have_js_property(
@@ -406,6 +483,7 @@ async def to_have_value(
             FrameExpectOptions(expectedText=expected_text, timeout=timeout),
             value,
             "Locator expected to have Value",
+            'Expect "to_have_value"',
         )
 
     async def not_to_have_value(
@@ -430,6 +508,7 @@ async def to_have_values(
             FrameExpectOptions(expectedText=expected_text, timeout=timeout),
             values,
             "Locator expected to have Values",
+            'Expect "to_have_values"',
         )
 
     async def not_to_have_values(
@@ -473,6 +552,7 @@ async def to_have_text(
                 ),
                 expected,
                 "Locator expected to have text",
+                'Expect "to_have_text"',
             )
         else:
             expected_text = to_expected_text_values(
@@ -487,6 +567,7 @@ async def to_have_text(
                 ),
                 expected,
                 "Locator expected to have text",
+                'Expect "to_have_text"',
             )
 
     async def not_to_have_text(
@@ -511,28 +592,40 @@ async def to_be_attached(
         timeout: float = None,
     ) -> None:
         __tracebackhide__ = True
+        if attached is None:
+            attached = True
+        attached_string = "attached" if attached else "detached"
         await self._expect_impl(
-            "to.be.attached"
-            if (attached is None or attached is True)
-            else "to.be.detached",
+            ("to.be.attached" if attached else "to.be.detached"),
             FrameExpectOptions(timeout=timeout),
             None,
-            "Locator expected to be attached",
+            f"Locator expected to be {attached_string}",
+            'Expect "to_be_attached"',
         )
 
     async def to_be_checked(
         self,
         timeout: float = None,
         checked: bool = None,
+        indeterminate: bool = None,
     ) -> None:
         __tracebackhide__ = True
+        expected_value = {}
+        if indeterminate is not None:
+            expected_value["indeterminate"] = indeterminate
+        if checked is not None:
+            expected_value["checked"] = checked
+        checked_string: str
+        if indeterminate:
+            checked_string = "indeterminate"
+        else:
+            checked_string = "unchecked" if checked is False else "checked"
         await self._expect_impl(
-            "to.be.checked"
-            if checked is None or checked is True
-            else "to.be.unchecked",
-            FrameExpectOptions(timeout=timeout),
+            "to.be.checked",
+            FrameExpectOptions(timeout=timeout, expectedValue=expected_value),
             None,
-            "Locator expected to be checked",
+            f"Locator expected to be {checked_string}",
+            'Expect "to_be_checked"',
         )
 
     async def not_to_be_attached(
@@ -560,6 +653,7 @@ async def to_be_disabled(
             FrameExpectOptions(timeout=timeout),
             None,
             "Locator expected to be disabled",
+            'Expect "to_be_disabled"',
         )
 
     async def not_to_be_disabled(
@@ -577,11 +671,13 @@ async def to_be_editable(
         __tracebackhide__ = True
         if editable is None:
             editable = True
+        editable_string = "editable" if editable else "readonly"
         await self._expect_impl(
             "to.be.editable" if editable else "to.be.readonly",
             FrameExpectOptions(timeout=timeout),
             None,
-            "Locator expected to be editable",
+            f"Locator expected to be {editable_string}",
+            'Expect "to_be_editable"',
         )
 
     async def not_to_be_editable(
@@ -602,6 +698,7 @@ async def to_be_empty(
             FrameExpectOptions(timeout=timeout),
             None,
             "Locator expected to be empty",
+            'Expect "to_be_empty"',
         )
 
     async def not_to_be_empty(
@@ -619,11 +716,13 @@ async def to_be_enabled(
         __tracebackhide__ = True
         if enabled is None:
             enabled = True
+        enabled_string = "enabled" if enabled else "disabled"
         await self._expect_impl(
             "to.be.enabled" if enabled else "to.be.disabled",
             FrameExpectOptions(timeout=timeout),
             None,
-            "Locator expected to be enabled",
+            f"Locator expected to be {enabled_string}",
+            'Expect "to_be_enabled"',
         )
 
     async def not_to_be_enabled(
@@ -644,6 +743,7 @@ async def to_be_hidden(
             FrameExpectOptions(timeout=timeout),
             None,
             "Locator expected to be hidden",
+            'Expect "to_be_hidden"',
         )
 
     async def not_to_be_hidden(
@@ -661,11 +761,13 @@ async def to_be_visible(
         __tracebackhide__ = True
         if visible is None:
             visible = True
+        visible_string = "visible" if visible else "hidden"
         await self._expect_impl(
             "to.be.visible" if visible else "to.be.hidden",
             FrameExpectOptions(timeout=timeout),
             None,
-            "Locator expected to be visible",
+            f"Locator expected to be {visible_string}",
+            'Expect "to_be_visible"',
         )
 
     async def not_to_be_visible(
@@ -686,6 +788,7 @@ async def to_be_focused(
             FrameExpectOptions(timeout=timeout),
             None,
             "Locator expected to be focused",
+            'Expect "to_be_focused"',
         )
 
     async def not_to_be_focused(
@@ -706,6 +809,7 @@ async def to_be_in_viewport(
             FrameExpectOptions(timeout=timeout, expectedNumber=ratio),
             None,
             "Locator expected to be in viewport",
+            'Expect "to_be_in_viewport"',
         )
 
     async def not_to_be_in_viewport(
@@ -721,12 +825,15 @@ async def to_have_accessible_description(
         timeout: float = None,
     ) -> None:
         __tracebackhide__ = True
-        expected_values = to_expected_text_values([description], ignoreCase=ignoreCase)
+        expected_values = to_expected_text_values(
+            [description], ignoreCase=ignoreCase, normalize_white_space=True
+        )
         await self._expect_impl(
             "to.have.accessible.description",
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
             None,
             "Locator expected to have accessible description",
+            'Expect "to_have_accessible_description"',
         )
 
     async def not_to_have_accessible_description(
@@ -745,12 +852,15 @@ async def to_have_accessible_name(
         timeout: float = None,
     ) -> None:
         __tracebackhide__ = True
-        expected_values = to_expected_text_values([name], ignoreCase=ignoreCase)
+        expected_values = to_expected_text_values(
+            [name], ignoreCase=ignoreCase, normalize_white_space=True
+        )
         await self._expect_impl(
             "to.have.accessible.name",
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
             None,
             "Locator expected to have accessible name",
+            'Expect "to_have_accessible_name"',
         )
 
     async def not_to_have_accessible_name(
@@ -772,12 +882,60 @@ async def to_have_role(self, role: AriaRole, timeout: float = None) -> None:
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
             None,
             "Locator expected to have accessible role",
+            'Expect "to_have_role"',
+        )
+
+    async def to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [errorMessage], ignoreCase=ignoreCase, normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.accessible.error.message",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible error message",
+            'Expect "to_have_accessible_error_message"',
+        )
+
+    async def not_to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_error_message(
+            errorMessage=errorMessage, ignoreCase=ignoreCase, timeout=timeout
         )
 
     async def not_to_have_role(self, role: AriaRole, timeout: float = None) -> None:
         __tracebackhide__ = True
         await self._not.to_have_role(role, timeout)
 
+    async def to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.match.aria",
+            FrameExpectOptions(expectedValue=expected, timeout=timeout),
+            expected,
+            "Locator expected to match Aria snapshot",
+            'Expect "to_match_aria_snapshot"',
+        )
+
+    async def not_to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_match_aria_snapshot(expected, timeout)
+
 
 class APIResponseAssertions:
     def __init__(
@@ -852,7 +1010,7 @@ def to_expected_text_values(
     ignoreCase: Optional[bool] = None,
 ) -> Sequence[ExpectedTextValue]:
     out: List[ExpectedTextValue] = []
-    assert isinstance(items, list)
+    assert isinstance(items, (list, tuple))
     for item in items:
         if isinstance(item, str):
             o = ExpectedTextValue(
diff --git a/playwright/_impl/_async_base.py b/playwright/_impl/_async_base.py
index e9544b733..db7e5d005 100644
--- a/playwright/_impl/_async_base.py
+++ b/playwright/_impl/_async_base.py
@@ -15,7 +15,7 @@
 import asyncio
 from contextlib import AbstractAsyncContextManager
 from types import TracebackType
-from typing import Any, Callable, Generic, Optional, Type, TypeVar
+from typing import Any, Callable, Generic, Optional, Type, TypeVar, Union
 
 from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
 
@@ -68,7 +68,9 @@ def __init__(self, impl_obj: Any) -> None:
     def __str__(self) -> str:
         return self._impl_obj.__str__()
 
-    def _wrap_handler(self, handler: Any) -> Callable[..., None]:
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
         if callable(handler):
             return mapping.wrap_handler(handler)
         return handler
@@ -94,11 +96,10 @@ async def __aenter__(self: Self) -> Self:
 
     async def __aexit__(
         self,
-        exc_type: Type[BaseException],
-        exc_val: BaseException,
-        traceback: TracebackType,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        traceback: Optional[TracebackType],
     ) -> None:
         await self.close()
 
-    async def close(self) -> None:
-        ...
+    async def close(self) -> None: ...
diff --git a/playwright/_impl/_browser.py b/playwright/_impl/_browser.py
index c5a9022a3..5a9a87450 100644
--- a/playwright/_impl/_browser.py
+++ b/playwright/_impl/_browser.py
@@ -12,10 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
 from pathlib import Path
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
 
 from playwright._impl._api_structures import (
     ClientCertificate,
@@ -32,17 +41,15 @@
 from playwright._impl._errors import is_target_closed_error
 from playwright._impl._helper import (
     ColorScheme,
+    Contrast,
     ForcedColors,
     HarContentPolicy,
     HarMode,
     ReducedMotion,
     ServiceWorkersPolicy,
-    async_readfile,
     locals_to_params,
     make_dirs_for_file,
-    prepare_record_har_options,
 )
-from playwright._impl._network import serialize_headers, to_client_certificates_protocol
 from playwright._impl._page import Page
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -58,28 +65,61 @@ def __init__(
         self, parent: "BrowserType", type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
-        self._browser_type = parent
+        self._browser_type: Optional["BrowserType"] = None
         self._is_connected = True
         self._should_close_connection_on_close = False
         self._cr_tracing_path: Optional[str] = None
 
-        self._contexts: List[BrowserContext] = []
+        self._contexts: Set[BrowserContext] = set()
+        self._traces_dir: Optional[str] = None
+        self._channel.on(
+            "context",
+            lambda params: self._did_create_context(
+                cast(BrowserContext, from_channel(params["context"]))
+            ),
+        )
         self._channel.on("close", lambda _: self._on_close())
         self._close_reason: Optional[str] = None
 
     def __repr__(self) -> str:
         return f"<Browser type={self._browser_type} version={self.version}>"
 
+    def _connect_to_browser_type(
+        self,
+        browser_type: "BrowserType",
+        traces_dir: Optional[str] = None,
+    ) -> None:
+        # Note: when using connect(), `browserType` is different from `this.parent`.
+        # This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
+        self._browser_type = browser_type
+        self._traces_dir = traces_dir
+        for context in self._contexts:
+            self._setup_browser_context(context)
+
+    def _did_create_context(self, context: BrowserContext) -> None:
+        context._browser = self
+        self._contexts.add(context)
+        # Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
+        # and will be configured later in `ConnectToBrowserType`.
+        if self._browser_type:
+            self._setup_browser_context(context)
+
+    def _setup_browser_context(self, context: BrowserContext) -> None:
+        context._tracing._traces_dir = self._traces_dir
+        assert self._browser_type is not None
+        self._browser_type._playwright.selectors._contexts_for_selectors.add(context)
+
     def _on_close(self) -> None:
         self._is_connected = False
         self.emit(Browser.Events.Disconnected, self)
 
     @property
     def contexts(self) -> List[BrowserContext]:
-        return self._contexts.copy()
+        return list(self._contexts)
 
     @property
     def browser_type(self) -> "BrowserType":
+        assert self._browser_type is not None
         return self._browser_type
 
     def is_connected(self) -> bool:
@@ -107,6 +147,7 @@ async def new_context(
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
         forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,
         proxy: ProxySettings = None,
@@ -124,11 +165,18 @@ async def new_context(
         clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
         params = locals_to_params(locals())
-        await prepare_browser_context_params(params)
+        assert self._browser_type is not None
+        await self._browser_type._prepare_browser_context_params(params)
 
-        channel = await self._channel.send("newContext", params)
+        channel = await self._channel.send("newContext", None, params)
         context = cast(BrowserContext, from_channel(channel))
-        self._browser_type._did_create_context(context, params, {})
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
+        )
         return context
 
     async def new_page(
@@ -152,6 +200,7 @@ async def new_page(
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
         forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
         reducedMotion: ReducedMotion = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,
@@ -178,7 +227,7 @@ async def inner() -> Page:
             context._owner_page = page
             return page
 
-        return await self._connection.wrap_api_call(inner)
+        return await self._connection.wrap_api_call(inner, title="Create page")
 
     async def close(self, reason: str = None) -> None:
         self._close_reason = reason
@@ -186,7 +235,7 @@ async def close(self, reason: str = None) -> None:
             if self._should_close_connection_on_close:
                 await self._connection.stop_async()
             else:
-                await self._channel.send("close", {"reason": reason})
+                await self._channel.send("close", None, {"reason": reason})
         except Exception as e:
             if not is_target_closed_error(e):
                 raise e
@@ -196,7 +245,7 @@ def version(self) -> str:
         return self._initializer["version"]
 
     async def new_browser_cdp_session(self) -> CDPSession:
-        return from_channel(await self._channel.send("newBrowserCDPSession"))
+        return from_channel(await self._channel.send("newBrowserCDPSession", None))
 
     async def start_tracing(
         self,
@@ -211,10 +260,12 @@ async def start_tracing(
         if path:
             self._cr_tracing_path = str(path)
             params["path"] = str(path)
-        await self._channel.send("startTracing", params)
+        await self._channel.send("startTracing", None, params)
 
     async def stop_tracing(self) -> bytes:
-        artifact = cast(Artifact, from_channel(await self._channel.send("stopTracing")))
+        artifact = cast(
+            Artifact, from_channel(await self._channel.send("stopTracing", None))
+        )
         buffer = await artifact.read_info_buffer()
         await artifact.delete()
         if self._cr_tracing_path:
@@ -223,41 +274,3 @@ async def stop_tracing(self) -> bytes:
                 f.write(buffer)
             self._cr_tracing_path = None
         return buffer
-
-
-async def prepare_browser_context_params(params: Dict) -> None:
-    if params.get("noViewport"):
-        del params["noViewport"]
-        params["noDefaultViewport"] = True
-    if "defaultBrowserType" in params:
-        del params["defaultBrowserType"]
-    if "extraHTTPHeaders" in params:
-        params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
-    if "recordHarPath" in params:
-        params["recordHar"] = prepare_record_har_options(params)
-        del params["recordHarPath"]
-    if "recordVideoDir" in params:
-        params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
-        if "recordVideoSize" in params:
-            params["recordVideo"]["size"] = params["recordVideoSize"]
-            del params["recordVideoSize"]
-        del params["recordVideoDir"]
-    if "storageState" in params:
-        storageState = params["storageState"]
-        if not isinstance(storageState, dict):
-            params["storageState"] = json.loads(
-                (await async_readfile(storageState)).decode()
-            )
-    if params.get("colorScheme", None) == "null":
-        params["colorScheme"] = "no-override"
-    if params.get("reducedMotion", None) == "null":
-        params["reducedMotion"] = "no-override"
-    if params.get("forcedColors", None) == "null":
-        params["forcedColors"] = "no-override"
-    if "acceptDownloads" in params:
-        params["acceptDownloads"] = "accept" if params["acceptDownloads"] else "deny"
-
-    if "clientCertificates" in params:
-        params["clientCertificates"] = await to_client_certificates_protocol(
-            params["clientCertificates"]
-        )
diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
index 455bf3410..e27a9437a 100644
--- a/playwright/_impl/_browser_context.py
+++ b/playwright/_impl/_browser_context.py
@@ -61,15 +61,21 @@
     RouteHandlerCallback,
     TimeoutSettings,
     URLMatch,
-    URLMatcher,
+    WebSocketRouteHandlerCallback,
     async_readfile,
     async_writefile,
     locals_to_params,
     parse_error,
-    prepare_record_har_options,
     to_impl,
 )
-from playwright._impl._network import Request, Response, Route, serialize_headers
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocketRoute,
+    WebSocketRouteHandler,
+    serialize_headers,
+)
 from playwright._impl._page import BindingCall, Page, Worker
 from playwright._impl._str_utils import escape_regex_flags
 from playwright._impl._tracing import Tracing
@@ -82,6 +88,7 @@
 
 class BrowserContext(ChannelOwner):
     Events = SimpleNamespace(
+        # Deprecated in v1.56, never emitted anymore.
         BackgroundPage="backgroundpage",
         Close="close",
         Console="console",
@@ -99,22 +106,25 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        # Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
         # circular import workaround:
         self._browser: Optional["Browser"] = None
         if parent.__class__.__name__ == "Browser":
             self._browser = cast("Browser", parent)
-            self._browser._contexts.append(self)
         self._pages: List[Page] = []
         self._routes: List[RouteHandler] = []
+        self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._bindings: Dict[str, Any] = {}
         self._timeout_settings = TimeoutSettings(None)
         self._owner_page: Optional[Page] = None
-        self._options: Dict[str, Any] = {}
-        self._background_pages: Set[Page] = set()
+        self._options: Dict[str, Any] = initializer["options"]
         self._service_workers: Set[Worker] = set()
+        self._base_url: Optional[str] = self._options.get("baseURL")
+        self._videos_dir: Optional[str] = self._options.get("recordVideo")
         self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
         self._har_recorders: Dict[str, HarRecordingMetadata] = {}
         self._request: APIRequestContext = from_channel(initializer["requestContext"])
+        self._request._timeout_settings = self._timeout_settings
         self._clock = Clock(self)
         self._channel.on(
             "bindingCall",
@@ -132,10 +142,13 @@ def __init__(
                 )
             ),
         )
-
         self._channel.on(
-            "backgroundPage",
-            lambda params: self._on_background_page(from_channel(params["page"])),
+            "webSocketRoute",
+            lambda params: self._loop.create_task(
+                self._on_web_socket_route(
+                    from_channel(params["webSocketRoute"]),
+                )
+            ),
         )
 
         self._channel.on(
@@ -205,7 +218,7 @@ def __init__(
                 BrowserContext.Events.RequestFailed: "requestFailed",
             }
         )
-        self._close_was_called = False
+        self._closing_or_closed = False
 
     def __repr__(self) -> str:
         return f"<BrowserContext browser={self.browser}>"
@@ -222,7 +235,7 @@ async def _on_route(self, route: Route) -> None:
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
             # If the page or the context was closed we stall all requests right away.
-            if (page and page._close_was_called) or self._close_was_called:
+            if (page and page._close_was_called) or self._closing_or_closed:
                 return
             if not route_handler.matches(route.request.url):
                 continue
@@ -244,10 +257,24 @@ async def _on_route(self, route: Route) -> None:
         try:
             # If the page is closed or unrouteAll() was called without waiting and interception disabled,
             # the method will throw an error - silence it.
-            await route._internal_continue(is_internal=True)
+            await route._inner_continue(True)
         except Exception:
             pass
 
+    async def _on_web_socket_route(self, web_socket_route: WebSocketRoute) -> None:
+        route_handler = next(
+            (
+                route_handler
+                for route_handler in self._web_socket_routes
+                if route_handler.matches(web_socket_route.url)
+            ),
+            None,
+        )
+        if route_handler:
+            await route_handler.handle(web_socket_route)
+        else:
+            web_socket_route.connect_to_server()
+
     def _on_binding(self, binding_call: BindingCall) -> None:
         func = self._bindings.get(binding_call._initializer["name"])
         if func is None:
@@ -259,19 +286,12 @@ def set_default_navigation_timeout(self, timeout: float) -> None:
 
     def _set_default_navigation_timeout_impl(self, timeout: Optional[float]) -> None:
         self._timeout_settings.set_default_navigation_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultNavigationTimeoutNoReply",
-            {} if timeout is None else {"timeout": timeout},
-        )
 
     def set_default_timeout(self, timeout: float) -> None:
         return self._set_default_timeout_impl(timeout)
 
     def _set_default_timeout_impl(self, timeout: Optional[float]) -> None:
         self._timeout_settings.set_default_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultTimeoutNoReply", {} if timeout is None else {"timeout": timeout}
-        )
 
     @property
     def pages(self) -> List[Page]:
@@ -281,29 +301,45 @@ def pages(self) -> List[Page]:
     def browser(self) -> Optional["Browser"]:
         return self._browser
 
-    def _set_options(self, context_options: Dict, browser_options: Dict) -> None:
-        self._options = context_options
-        if self._options.get("recordHar"):
-            self._har_recorders[""] = {
-                "path": self._options["recordHar"]["path"],
-                "content": self._options["recordHar"].get("content"),
-            }
-        self._tracing._traces_dir = browser_options.get("tracesDir")
+    async def _initialize_har_from_options(
+        self,
+        record_har_path: Optional[Union[Path, str]],
+        record_har_content: Optional[HarContentPolicy],
+        record_har_omit_content: Optional[bool],
+        record_har_url_filter: Optional[Union[Pattern[str], str]],
+        record_har_mode: Optional[HarMode],
+    ) -> None:
+        if not record_har_path:
+            return
+        record_har_path = str(record_har_path)
+        default_policy: HarContentPolicy = (
+            "attach" if record_har_path.endswith(".zip") else "embed"
+        )
+        content_policy: HarContentPolicy = record_har_content or (
+            "omit" if record_har_omit_content is True else default_policy
+        )
+        await self._record_into_har(
+            har=record_har_path,
+            page=None,
+            url=record_har_url_filter,
+            update_content=content_policy,
+            update_mode=(record_har_mode or "full"),
+        )
 
     async def new_page(self) -> Page:
         if self._owner_page:
             raise Error("Please use browser.new_context()")
-        return from_channel(await self._channel.send("newPage"))
+        return from_channel(await self._channel.send("newPage", None))
 
     async def cookies(self, urls: Union[str, Sequence[str]] = None) -> List[Cookie]:
         if urls is None:
             urls = []
         if isinstance(urls, str):
             urls = [urls]
-        return await self._channel.send("cookies", dict(urls=urls))
+        return await self._channel.send("cookies", None, dict(urls=urls))
 
     async def add_cookies(self, cookies: Sequence[SetCookieParam]) -> None:
-        await self._channel.send("addCookies", dict(cookies=cookies))
+        await self._channel.send("addCookies", None, dict(cookies=cookies))
 
     async def clear_cookies(
         self,
@@ -313,45 +349,46 @@ async def clear_cookies(
     ) -> None:
         await self._channel.send(
             "clearCookies",
+            None,
             {
                 "name": name if isinstance(name, str) else None,
                 "nameRegexSource": name.pattern if isinstance(name, Pattern) else None,
-                "nameRegexFlags": escape_regex_flags(name)
-                if isinstance(name, Pattern)
-                else None,
+                "nameRegexFlags": (
+                    escape_regex_flags(name) if isinstance(name, Pattern) else None
+                ),
                 "domain": domain if isinstance(domain, str) else None,
-                "domainRegexSource": domain.pattern
-                if isinstance(domain, Pattern)
-                else None,
-                "domainRegexFlags": escape_regex_flags(domain)
-                if isinstance(domain, Pattern)
-                else None,
+                "domainRegexSource": (
+                    domain.pattern if isinstance(domain, Pattern) else None
+                ),
+                "domainRegexFlags": (
+                    escape_regex_flags(domain) if isinstance(domain, Pattern) else None
+                ),
                 "path": path if isinstance(path, str) else None,
                 "pathRegexSource": path.pattern if isinstance(path, Pattern) else None,
-                "pathRegexFlags": escape_regex_flags(path)
-                if isinstance(path, Pattern)
-                else None,
+                "pathRegexFlags": (
+                    escape_regex_flags(path) if isinstance(path, Pattern) else None
+                ),
             },
         )
 
     async def grant_permissions(
         self, permissions: Sequence[str], origin: str = None
     ) -> None:
-        await self._channel.send("grantPermissions", locals_to_params(locals()))
+        await self._channel.send("grantPermissions", None, locals_to_params(locals()))
 
     async def clear_permissions(self) -> None:
-        await self._channel.send("clearPermissions")
+        await self._channel.send("clearPermissions", None)
 
     async def set_geolocation(self, geolocation: Geolocation = None) -> None:
-        await self._channel.send("setGeolocation", locals_to_params(locals()))
+        await self._channel.send("setGeolocation", None, locals_to_params(locals()))
 
     async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
         await self._channel.send(
-            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+            "setExtraHTTPHeaders", None, dict(headers=serialize_headers(headers))
         )
 
     async def set_offline(self, offline: bool) -> None:
-        await self._channel.send("setOffline", dict(offline=offline))
+        await self._channel.send("setOffline", None, dict(offline=offline))
 
     async def add_init_script(
         self, script: str = None, path: Union[str, Path] = None
@@ -360,7 +397,7 @@ async def add_init_script(
             script = (await async_readfile(path)).decode()
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=script))
+        await self._channel.send("addInitScript", None, dict(source=script))
 
     async def expose_binding(
         self, name: str, callback: Callable, handle: bool = None
@@ -374,7 +411,7 @@ async def expose_binding(
             raise Error(f'Function "{name}" has been already registered')
         self._bindings[name] = callback
         await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+            "exposeBinding", None, dict(name=name, needsHandle=handle or False)
         )
 
     async def expose_function(self, name: str, callback: Callable) -> None:
@@ -386,7 +423,8 @@ async def route(
         self._routes.insert(
             0,
             RouteHandler(
-                URLMatcher(self._options.get("baseURL"), url),
+                self._base_url,
+                url,
                 handler,
                 True if self._dispatcher_fiber else False,
                 times,
@@ -400,7 +438,7 @@ async def unroute(
         removed = []
         remaining = []
         for route in self._routes:
-            if route.matcher.match != url or (handler and route.handler != handler):
+            if route.url != url or (handler and route.handler != handler):
                 remaining.append(route)
             else:
                 removed.append(route)
@@ -413,10 +451,18 @@ async def _unroute_internal(
         behavior: Literal["default", "ignoreErrors", "wait"] = None,
     ) -> None:
         self._routes = remaining
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
         await self._update_interception_patterns()
-        if behavior is None or behavior == "default":
-            return
-        await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
+
+    async def route_web_socket(
+        self, url: URLMatch, handler: WebSocketRouteHandlerCallback
+    ) -> None:
+        self._web_socket_routes.insert(
+            0,
+            WebSocketRouteHandler(self._base_url, url, handler),
+        )
+        await self._update_web_socket_interception_patterns()
 
     def _dispose_har_routers(self) -> None:
         for router in self._har_routers:
@@ -437,22 +483,25 @@ async def _record_into_har(
         update_content: HarContentPolicy = None,
         update_mode: HarMode = None,
     ) -> None:
+        update_content = update_content or "attach"
         params: Dict[str, Any] = {
-            "options": prepare_record_har_options(
-                {
-                    "recordHarPath": har,
-                    "recordHarContent": update_content or "attach",
-                    "recordHarMode": update_mode or "minimal",
-                    "recordHarUrlFilter": url,
-                }
-            )
+            "options": {
+                "zip": str(har).endswith(".zip"),
+                "content": update_content,
+                "urlGlob": url if isinstance(url, str) else None,
+                "urlRegexSource": url.pattern if isinstance(url, Pattern) else None,
+                "urlRegexFlags": (
+                    escape_regex_flags(url) if isinstance(url, Pattern) else None
+                ),
+                "mode": update_mode or "minimal",
+            }
         }
         if page:
             params["page"] = page._channel
-        har_id = await self._channel.send("harStart", params)
+        har_id = await self._channel.send("harStart", None, params)
         self._har_recorders[har_id] = {
             "path": str(har),
-            "content": update_content or "attach",
+            "content": update_content,
         }
 
     async def route_from_har(
@@ -485,7 +534,15 @@ async def route_from_har(
     async def _update_interception_patterns(self) -> None:
         patterns = RouteHandler.prepare_interception_patterns(self._routes)
         await self._channel.send(
-            "setNetworkInterceptionPatterns", {"patterns": patterns}
+            "setNetworkInterceptionPatterns", None, {"patterns": patterns}
+        )
+
+    async def _update_web_socket_interception_patterns(self) -> None:
+        patterns = WebSocketRouteHandler.prepare_interception_patterns(
+            self._web_socket_routes
+        )
+        await self._channel.send(
+            "setWebSocketInterceptionPatterns", None, {"patterns": patterns}
         )
 
     def expect_event(
@@ -508,29 +565,37 @@ def expect_event(
         return EventContextManagerImpl(waiter.result())
 
     def _on_close(self) -> None:
+        self._closing_or_closed = True
         if self._browser:
-            self._browser._contexts.remove(self)
+            if self in self._browser._contexts:
+                self._browser._contexts.remove(self)
+            assert self._browser._browser_type is not None
+            if (
+                self
+                in self._browser._browser_type._playwright.selectors._contexts_for_selectors
+            ):
+                self._browser._browser_type._playwright.selectors._contexts_for_selectors.remove(
+                    self
+                )
 
         self._dispose_har_routers()
         self._tracing._reset_stack_counter()
         self.emit(BrowserContext.Events.Close, self)
 
     async def close(self, reason: str = None) -> None:
-        if self._close_was_called:
+        if self._closing_or_closed:
             return
         self._close_reason = reason
-        self._close_was_called = True
+        self._closing_or_closed = True
 
-        await self._channel._connection.wrap_api_call(
-            lambda: self.request.dispose(reason=reason), True
-        )
+        await self.request.dispose(reason=reason)
 
         async def _inner_close() -> None:
             for har_id, params in self._har_recorders.items():
                 har = cast(
                     Artifact,
                     from_channel(
-                        await self._channel.send("harExport", {"harId": har_id})
+                        await self._channel.send("harExport", None, {"harId": har_id})
                     ),
                 )
                 # Server side will compress artifact if content is attach or if file is .zip.
@@ -549,11 +614,15 @@ async def _inner_close() -> None:
                 await har.delete()
 
         await self._channel._connection.wrap_api_call(_inner_close, True)
-        await self._channel.send("close", {"reason": reason})
+        await self._channel.send("close", None, {"reason": reason})
         await self._closed_future
 
-    async def storage_state(self, path: Union[str, Path] = None) -> StorageState:
-        result = await self._channel.send_return_as_dict("storageState")
+    async def storage_state(
+        self, path: Union[str, Path] = None, indexedDB: bool = None
+    ) -> StorageState:
+        result = await self._channel.send_return_as_dict(
+            "storageState", None, {"indexedDB": indexedDB}
+        )
         if path:
             await async_writefile(path, json.dumps(result))
         return result
@@ -586,10 +655,6 @@ def expect_page(
     ) -> EventContextManagerImpl[Page]:
         return self.expect_event(BrowserContext.Events.Page, predicate, timeout)
 
-    def _on_background_page(self, page: Page) -> None:
-        self._background_pages.add(page)
-        self.emit(BrowserContext.Events.BackgroundPage, page)
-
     def _on_service_worker(self, worker: Worker) -> None:
         worker._context = self
         self._service_workers.add(worker)
@@ -624,10 +689,13 @@ def _on_request_finished(
 
     def _on_console_message(self, event: Dict) -> None:
         message = ConsoleMessage(event, self._loop, self._dispatcher_fiber)
-        self.emit(BrowserContext.Events.Console, message)
+        worker = message.worker
+        if worker:
+            worker.emit(Worker.Events.Console, message)
         page = message.page
         if page:
             page.emit(Page.Events.Console, message)
+        self.emit(BrowserContext.Events.Console, message)
 
     def _on_dialog(self, dialog: Dialog) -> None:
         has_listeners = self.emit(BrowserContext.Events.Dialog, dialog)
@@ -645,7 +713,10 @@ def _on_dialog(self, dialog: Dialog) -> None:
                 asyncio.create_task(dialog.dismiss())
 
     def _on_page_error(self, error: Error, page: Optional[Page]) -> None:
-        self.emit(BrowserContext.Events.WebError, WebError(self._loop, page, error))
+        self.emit(
+            BrowserContext.Events.WebError,
+            WebError(self._loop, self._dispatcher_fiber, page, error),
+        )
         if page:
             page.emit(Page.Events.PageError, error)
 
@@ -661,7 +732,7 @@ def _on_response(self, response: Response, page: Optional[Page]) -> None:
 
     @property
     def background_pages(self) -> List[Page]:
-        return list(self._background_pages)
+        return []
 
     @property
     def service_workers(self) -> List[Worker]:
@@ -676,7 +747,7 @@ async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
             params["frame"] = page._channel
         else:
             raise Error("page: expected Page or Frame")
-        return from_channel(await self._channel.send("newCDPSession", params))
+        return from_channel(await self._channel.send("newCDPSession", None, params))
 
     @property
     def tracing(self) -> Tracing:
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
index 1c9303c7f..3aef7dd6d 100644
--- a/playwright/_impl/_browser_type.py
+++ b/playwright/_impl/_browser_type.py
@@ -13,7 +13,9 @@
 # limitations under the License.
 
 import asyncio
+import json
 import pathlib
+import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
 
@@ -24,27 +26,26 @@
     ProxySettings,
     ViewportSize,
 )
-from playwright._impl._browser import Browser, prepare_browser_context_params
+from playwright._impl._browser import Browser
 from playwright._impl._browser_context import BrowserContext
-from playwright._impl._connection import (
-    ChannelOwner,
-    Connection,
-    from_channel,
-    from_nullable_channel,
-)
+from playwright._impl._connection import ChannelOwner, Connection, from_channel
 from playwright._impl._errors import Error
 from playwright._impl._helper import (
+    PLAYWRIGHT_MAX_DEADLINE,
     ColorScheme,
+    Contrast,
     Env,
     ForcedColors,
     HarContentPolicy,
     HarMode,
     ReducedMotion,
     ServiceWorkersPolicy,
+    TimeoutSettings,
+    async_readfile,
     locals_to_params,
 )
 from playwright._impl._json_pipe import JsonPipeTransport
-from playwright._impl._network import serialize_headers
+from playwright._impl._network import serialize_headers, to_client_certificates_protocol
 from playwright._impl._waiter import throw_on_timeout
 
 if TYPE_CHECKING:
@@ -81,7 +82,6 @@ async def launch(
         timeout: float = None,
         env: Env = None,
         headless: bool = None,
-        devtools: bool = None,
         proxy: ProxySettings = None,
         downloadsPath: Union[str, Path] = None,
         slowMo: float = None,
@@ -92,9 +92,16 @@ async def launch(
         params = locals_to_params(locals())
         normalize_launch_params(params)
         browser = cast(
-            Browser, from_channel(await self._channel.send("launch", params))
+            Browser,
+            from_channel(
+                await self._channel.send(
+                    "launch", TimeoutSettings.launch_timeout, params
+                )
+            ),
+        )
+        browser._connect_to_browser_type(
+            self, str(tracesDir) if tracesDir is not None else None
         )
-        self._did_launch_browser(browser)
         return browser
 
     async def launch_persistent_context(
@@ -110,7 +117,6 @@ async def launch_persistent_context(
         timeout: float = None,
         env: Env = None,
         headless: bool = None,
-        devtools: bool = None,
         proxy: ProxySettings = None,
         downloadsPath: Union[str, Path] = None,
         slowMo: float = None,
@@ -134,6 +140,7 @@ async def launch_persistent_context(
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
         forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
         acceptDownloads: bool = None,
         tracesDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
@@ -150,37 +157,58 @@ async def launch_persistent_context(
         recordHarContent: HarContentPolicy = None,
         clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
-        userDataDir = str(Path(userDataDir)) if userDataDir else ""
+        userDataDir = self._user_data_dir(userDataDir)
         params = locals_to_params(locals())
-        await prepare_browser_context_params(params)
+        await self._prepare_browser_context_params(params)
         normalize_launch_params(params)
-        context = cast(
-            BrowserContext,
-            from_channel(await self._channel.send("launchPersistentContext", params)),
+        result = await self._channel.send_return_as_dict(
+            "launchPersistentContext", TimeoutSettings.launch_timeout, params
+        )
+        browser = cast(
+            Browser,
+            from_channel(result["browser"]),
+        )
+        browser._connect_to_browser_type(
+            self, str(tracesDir) if tracesDir is not None else None
+        )
+        context = cast(BrowserContext, from_channel(result["context"]))
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
         )
-        self._did_create_context(context, params, params)
         return context
 
+    def _user_data_dir(self, userDataDir: Optional[Union[str, Path]]) -> str:
+        if not userDataDir:
+            return ""
+        if not Path(userDataDir).is_absolute():
+            # Can be dropped once we drop Python 3.9 support (10/2025):
+            # https://github.com/python/cpython/issues/82852
+            if sys.platform == "win32" and sys.version_info[:2] < (3, 10):
+                return str(pathlib.Path.cwd() / userDataDir)
+            return str(Path(userDataDir).resolve())
+        return str(Path(userDataDir))
+
     async def connect_over_cdp(
         self,
         endpointURL: str,
         timeout: float = None,
         slowMo: float = None,
         headers: Dict[str, str] = None,
+        isLocal: bool = None,
     ) -> Browser:
         params = locals_to_params(locals())
         if params.get("headers"):
             params["headers"] = serialize_headers(params["headers"])
-        response = await self._channel.send_return_as_dict("connectOverCDP", params)
+        response = await self._channel.send_return_as_dict(
+            "connectOverCDP", TimeoutSettings.launch_timeout, params
+        )
         browser = cast(Browser, from_channel(response["browser"]))
-        self._did_launch_browser(browser)
+        browser._connect_to_browser_type(self, None)
 
-        default_context = cast(
-            Optional[BrowserContext],
-            from_nullable_channel(response.get("defaultContext")),
-        )
-        if default_context:
-            self._did_create_context(default_context, {}, {})
         return browser
 
     async def connect(
@@ -191,8 +219,6 @@ async def connect(
         headers: Dict[str, str] = None,
         exposeNetwork: str = None,
     ) -> Browser:
-        if timeout is None:
-            timeout = 30000
         if slowMo is None:
             slowMo = 0
 
@@ -201,11 +227,12 @@ async def connect(
         pipe_channel = (
             await local_utils._channel.send_return_as_dict(
                 "connect",
+                None,
                 {
                     "wsEndpoint": wsEndpoint,
                     "headers": headers,
                     "slowMo": slowMo,
-                    "timeout": timeout,
+                    "timeout": timeout if timeout is not None else 0,
                     "exposeNetwork": exposeNetwork,
                 },
             )
@@ -245,7 +272,10 @@ def handle_transport_close(reason: Optional[str]) -> None:
         connection._loop.create_task(connection.run())
         playwright_future = connection.playwright_future
 
-        timeout_future = throw_on_timeout(timeout, Error("Connection timed out"))
+        timeout_future = throw_on_timeout(
+            timeout if timeout is not None else PLAYWRIGHT_MAX_DEADLINE,
+            Error("Connection timed out"),
+        )
         done, pending = await asyncio.wait(
             {transport.on_error_future, playwright_future, timeout_future},
             return_when=asyncio.FIRST_COMPLETED,
@@ -260,18 +290,59 @@ def handle_transport_close(reason: Optional[str]) -> None:
         pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
         assert pre_launched_browser
         browser = cast(Browser, from_channel(pre_launched_browser))
-        self._did_launch_browser(browser)
         browser._should_close_connection_on_close = True
+        browser._connect_to_browser_type(self, None)
 
         return browser
 
-    def _did_create_context(
-        self, context: BrowserContext, context_options: Dict, browser_options: Dict
-    ) -> None:
-        context._set_options(context_options, browser_options)
+    async def _prepare_browser_context_params(self, params: Dict) -> None:
+        if params.get("noViewport"):
+            del params["noViewport"]
+            params["noDefaultViewport"] = True
+        if "defaultBrowserType" in params:
+            del params["defaultBrowserType"]
+        if "extraHTTPHeaders" in params:
+            params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
+        if "recordVideoDir" in params:
+            params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
+            if "recordVideoSize" in params:
+                params["recordVideo"]["size"] = params["recordVideoSize"]
+                del params["recordVideoSize"]
+            del params["recordVideoDir"]
+        if "storageState" in params:
+            storageState = params["storageState"]
+            if not isinstance(storageState, dict):
+                params["storageState"] = json.loads(
+                    (await async_readfile(storageState)).decode()
+                )
+        if params.get("colorScheme", None) == "null":
+            params["colorScheme"] = "no-override"
+        if params.get("reducedMotion", None) == "null":
+            params["reducedMotion"] = "no-override"
+        if params.get("forcedColors", None) == "null":
+            params["forcedColors"] = "no-override"
+        if params.get("contrast", None) == "null":
+            params["contrast"] = "no-override"
+        if "acceptDownloads" in params:
+            params["acceptDownloads"] = (
+                "accept" if params["acceptDownloads"] else "deny"
+            )
+
+        if "clientCertificates" in params:
+            params["clientCertificates"] = await to_client_certificates_protocol(
+                params["clientCertificates"]
+            )
+        params["selectorEngines"] = self._playwright.selectors._selector_engines
+        params["testIdAttributeName"] = (
+            self._playwright.selectors._test_id_attribute_name
+        )
 
-    def _did_launch_browser(self, browser: Browser) -> None:
-        browser._browser_type = self
+        # Remove HAR options
+        params.pop("recordHarPath", None)
+        params.pop("recordHarOmitContent", None)
+        params.pop("recordHarUrlFilter", None)
+        params.pop("recordHarMode", None)
+        params.pop("recordHarContent", None)
 
 
 def normalize_launch_params(params: Dict) -> None:
diff --git a/playwright/_impl/_cdp_session.py b/playwright/_impl/_cdp_session.py
index b6e383ff2..95e65c57a 100644
--- a/playwright/_impl/_cdp_session.py
+++ b/playwright/_impl/_cdp_session.py
@@ -29,7 +29,10 @@ def _on_event(self, params: Any) -> None:
         self.emit(params["method"], params.get("params"))
 
     async def send(self, method: str, params: Dict = None) -> Dict:
-        return await self._channel.send("send", locals_to_params(locals()))
+        return await self._channel.send("send", None, locals_to_params(locals()))
 
     async def detach(self) -> None:
-        await self._channel.send("detach")
+        await self._channel.send(
+            "detach",
+            None,
+        )
diff --git a/playwright/_impl/_clock.py b/playwright/_impl/_clock.py
index d8bb58718..f6eb7c42d 100644
--- a/playwright/_impl/_clock.py
+++ b/playwright/_impl/_clock.py
@@ -27,7 +27,9 @@ def __init__(self, browser_context: "BrowserContext") -> None:
 
     async def install(self, time: Union[float, str, datetime.datetime] = None) -> None:
         await self._browser_context._channel.send(
-            "clockInstall", parse_time(time) if time is not None else {}
+            "clockInstall",
+            None,
+            parse_time(time) if time is not None else {},
         )
 
     async def fast_forward(
@@ -35,43 +37,59 @@ async def fast_forward(
         ticks: Union[int, str],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockFastForward", parse_ticks(ticks)
+            "clockFastForward",
+            None,
+            parse_ticks(ticks),
         )
 
     async def pause_at(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
-        await self._browser_context._channel.send("clockPauseAt", parse_time(time))
+        await self._browser_context._channel.send(
+            "clockPauseAt",
+            None,
+            parse_time(time),
+        )
 
     async def resume(
         self,
     ) -> None:
-        await self._browser_context._channel.send("clockResume")
+        await self._browser_context._channel.send("clockResume", None)
 
     async def run_for(
         self,
         ticks: Union[int, str],
     ) -> None:
-        await self._browser_context._channel.send("clockRunFor", parse_ticks(ticks))
+        await self._browser_context._channel.send(
+            "clockRunFor",
+            None,
+            parse_ticks(ticks),
+        )
 
     async def set_fixed_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
-        await self._browser_context._channel.send("clockSetFixedTime", parse_time(time))
+        await self._browser_context._channel.send(
+            "clockSetFixedTime",
+            None,
+            parse_time(time),
+        )
 
     async def set_system_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockSetSystemTime", parse_time(time)
+            "clockSetSystemTime",
+            None,
+            parse_time(time),
         )
 
 
 def parse_time(
-    time: Union[float, str, datetime.datetime]
+    time: Union[float, str, datetime.datetime],
 ) -> Dict[str, Union[int, str]]:
     if isinstance(time, (float, int)):
         return {"timeNumber": int(time * 1_000)}
diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
index eb4d182d3..bbc42b6e1 100644
--- a/playwright/_impl/_connection.py
+++ b/playwright/_impl/_connection.py
@@ -37,6 +37,7 @@
 from pyee.asyncio import AsyncIOEventEmitter
 
 import playwright
+import playwright._impl._impl_to_api_mapping
 from playwright._impl._errors import TargetClosedError, rewrite_error
 from playwright._impl._greenlets import EventGreenlet
 from playwright._impl._helper import Error, ParsedMessagePayload, parse_error
@@ -46,6 +47,8 @@
     from playwright._impl._local_utils import LocalUtils
     from playwright._impl._playwright import Playwright
 
+TimeoutCalculator = Optional[Callable[[Optional[float]], float]]
+
 
 class Channel(AsyncIOEventEmitter):
     def __init__(self, connection: "Connection", object: "ChannelOwner") -> None:
@@ -55,35 +58,67 @@ def __init__(self, connection: "Connection", object: "ChannelOwner") -> None:
         self._object = object
         self.on("error", lambda exc: self._connection._on_event_listener_error(exc))
 
-    async def send(self, method: str, params: Dict = None) -> Any:
+    async def send(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> Any:
         return await self._connection.wrap_api_call(
-            lambda: self.inner_send(method, params, False)
+            lambda: self._inner_send(method, timeout_calculator, params, False),
+            is_internal,
+            title,
         )
 
-    async def send_return_as_dict(self, method: str, params: Dict = None) -> Any:
+    async def send_return_as_dict(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> Any:
         return await self._connection.wrap_api_call(
-            lambda: self.inner_send(method, params, True)
+            lambda: self._inner_send(method, timeout_calculator, params, True),
+            is_internal,
+            title,
         )
 
-    def send_no_reply(self, method: str, params: Dict = None) -> None:
+    def send_no_reply(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> None:
         # No reply messages are used to e.g. waitForEventInfo(after).
         self._connection.wrap_api_call_sync(
             lambda: self._connection._send_message_to_server(
-                self._object, method, {} if params is None else params, True
-            )
+                self._object,
+                method,
+                _augment_params(params, timeout_calculator),
+                True,
+            ),
+            is_internal,
+            title,
         )
 
-    async def inner_send(
-        self, method: str, params: Optional[Dict], return_as_dict: bool
+    async def _inner_send(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Optional[Dict],
+        return_as_dict: bool,
     ) -> Any:
-        if params is None:
-            params = {}
         if self._connection._error:
             error = self._connection._error
             self._connection._error = None
             raise error
         callback = self._connection._send_message_to_server(
-            self._object, method, _filter_none(params)
+            self._object, method, _augment_params(params, timeout_calculator)
         )
         done, _ = await asyncio.wait(
             {
@@ -164,7 +199,9 @@ def _update_subscription(self, event: str, enabled: bool) -> None:
         if protocol_event:
             self._connection.wrap_api_call_sync(
                 lambda: self._channel.send_no_reply(
-                    "updateSubscription", {"event": protocol_event, "enabled": enabled}
+                    "updateSubscription",
+                    None,
+                    {"event": protocol_event, "enabled": enabled},
                 ),
                 True,
             )
@@ -181,10 +218,12 @@ def remove_listener(self, event: str, f: Any) -> None:
 
 
 class ProtocolCallback:
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+    def __init__(self, loop: asyncio.AbstractEventLoop, no_reply: bool = False) -> None:
         self.stack_trace: traceback.StackSummary
-        self.no_reply: bool
+        self.no_reply = no_reply
         self.future = loop.create_future()
+        if no_reply:
+            self.future.set_result(None)
         # The outer task can get cancelled by the user, this forwards the cancellation to the inner task.
         current_task = asyncio.current_task()
 
@@ -197,9 +236,9 @@ def cb(task: asyncio.Task) -> None:
         if current_task:
             current_task.add_done_callback(cb)
             self.future.add_done_callback(
-                lambda _: current_task.remove_done_callback(cb)
-                if current_task
-                else None
+                lambda _: (
+                    current_task.remove_done_callback(cb) if current_task else None
+                )
             )
 
 
@@ -211,6 +250,7 @@ async def initialize(self) -> "Playwright":
         return from_channel(
             await self._channel.send(
                 "initialize",
+                None,
                 {
                     "sdkLanguage": "python",
                 },
@@ -243,9 +283,9 @@ def __init__(
         self._error: Optional[BaseException] = None
         self.is_remote = False
         self._init_task: Optional[asyncio.Task] = None
-        self._api_zone: contextvars.ContextVar[
-            Optional[ParsedStackTrace]
-        ] = contextvars.ContextVar("ApiZone", default=None)
+        self._api_zone: contextvars.ContextVar[Optional[ParsedStackTrace]] = (
+            contextvars.ContextVar("ApiZone", default=None)
+        )
         self._local_utils: Optional["LocalUtils"] = local_utils
         self._tracing_count = 0
         self._closed_error: Optional[Exception] = None
@@ -294,6 +334,8 @@ def cleanup(self, cause: str = None) -> None:
             # To prevent 'Future exception was never retrieved' we ignore all callbacks that are no_reply.
             if callback.no_reply:
                 continue
+            if callback.future.cancelled():
+                continue
             callback.future.set_exception(self._closed_error)
         self._callbacks.clear()
         self.emit("close")
@@ -320,14 +362,13 @@ def _send_message_to_server(
             )
         self._last_id += 1
         id = self._last_id
-        callback = ProtocolCallback(self._loop)
+        callback = ProtocolCallback(self._loop, no_reply=no_reply)
         task = asyncio.current_task(self._loop)
         callback.stack_trace = cast(
             traceback.StackSummary,
-            getattr(task, "__pw_stack_trace__", traceback.extract_stack()),
+            getattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10)),
         )
         callback.no_reply = no_reply
-        self._callbacks[id] = callback
         stack_trace_information = cast(ParsedStackTrace, self._api_zone.get())
         frames = stack_trace_information.get("frames", [])
         location = (
@@ -346,6 +387,9 @@ def _send_message_to_server(
         }
         if location:
             metadata["location"] = location  # type: ignore
+        title = stack_trace_information["title"]
+        if title:
+            metadata["title"] = title
         message = {
             "id": id,
             "guid": object._guid,
@@ -356,8 +400,8 @@ def _send_message_to_server(
         if self._tracing_count > 0 and frames and object._guid != "localUtils":
             self.local_utils.add_stack_to_tracing_no_reply(id, frames)
 
-        self._transport.send(message)
         self._callbacks[id] = callback
+        self._transport.send(message)
 
         return callback
 
@@ -378,9 +422,7 @@ def dispatch(self, msg: ParsedMessagePayload) -> None:
                 parsed_error = parse_error(
                     error["error"], format_call_log(msg.get("log"))  # type: ignore
                 )
-                parsed_error._stack = "".join(
-                    traceback.format_list(callback.stack_trace)[-10:]
-                )
+                parsed_error._stack = "".join(callback.stack_trace.format())
                 callback.future.set_exception(parsed_error)
             else:
                 result = self._replace_guids_with_channels(msg.get("result"))
@@ -500,13 +542,16 @@ def _replace_guids_with_channels(self, payload: Any) -> Any:
         return payload
 
     async def wrap_api_call(
-        self, cb: Callable[[], Any], is_internal: bool = False
+        self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
     ) -> Any:
         if self._api_zone.get():
             return await cb()
         task = asyncio.current_task(self._loop)
-        st: List[inspect.FrameInfo] = getattr(task, "__pw_stack__", inspect.stack())
-        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal)
+        st: List[inspect.FrameInfo] = getattr(
+            task, "__pw_stack__", None
+        ) or inspect.stack(0)
+
+        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
         self._api_zone.set(parsed_st)
         try:
             return await cb()
@@ -516,13 +561,15 @@ async def wrap_api_call(
             self._api_zone.set(None)
 
     def wrap_api_call_sync(
-        self, cb: Callable[[], Any], is_internal: bool = False
+        self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
     ) -> Any:
         if self._api_zone.get():
             return cb()
         task = asyncio.current_task(self._loop)
-        st: List[inspect.FrameInfo] = getattr(task, "__pw_stack__", inspect.stack())
-        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal)
+        st: List[inspect.FrameInfo] = getattr(
+            task, "__pw_stack__", None
+        ) or inspect.stack(0)
+        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
         self._api_zone.set(parsed_st)
         try:
             return cb()
@@ -550,16 +597,23 @@ class StackFrame(TypedDict):
 class ParsedStackTrace(TypedDict):
     frames: List[StackFrame]
     apiName: Optional[str]
+    title: Optional[str]
 
 
 def _extract_stack_trace_information_from_stack(
-    st: List[inspect.FrameInfo], is_internal: bool
+    st: List[inspect.FrameInfo], is_internal: bool, title: str = None
 ) -> ParsedStackTrace:
     playwright_module_path = str(Path(playwright.__file__).parents[0])
     last_internal_api_name = ""
     api_name = ""
     parsed_frames: List[StackFrame] = []
     for frame in st:
+        # Sync and Async implementations can have event handlers. When these are sync, they
+        # get evaluated in the context of the event loop, so they contain the stack trace of when
+        # the message was received. _impl_to_api_mapping is glue between the user-code and internal
+        # code to translate impl classes to api classes. We want to ignore these frames.
+        if playwright._impl._impl_to_api_mapping.__file__ == frame.filename:
+            continue
         is_playwright_internal = frame.filename.startswith(playwright_module_path)
 
         method_name = ""
@@ -587,11 +641,28 @@ def _extract_stack_trace_information_from_stack(
     return {
         "frames": parsed_frames,
         "apiName": "" if is_internal else api_name,
+        "title": title,
     }
 
 
+def _augment_params(
+    params: Optional[Dict],
+    timeout_calculator: Optional[Callable[[Optional[float]], float]],
+) -> Dict:
+    if params is None:
+        params = {}
+    if timeout_calculator:
+        params["timeout"] = timeout_calculator(params.get("timeout"))
+    return _filter_none(params)
+
+
 def _filter_none(d: Mapping) -> Dict:
-    return {k: v for k, v in d.items() if v is not None}
+    result = {}
+    for k, v in d.items():
+        if v is None:
+            continue
+        result[k] = _filter_none(v) if isinstance(v, dict) else v
+    return result
 
 
 def format_call_log(log: Optional[List[str]]) -> str:
@@ -599,4 +670,4 @@ def format_call_log(log: Optional[List[str]]) -> str:
         return ""
     if len(list(filter(lambda x: x.strip(), log))) == 0:
         return ""
-    return "\nCall log:\n" + "\n  - ".join(log) + "\n"
+    return "\nCall log:\n" + "\n".join(log) + "\n"
diff --git a/playwright/_impl/_console_message.py b/playwright/_impl/_console_message.py
index ba8fc0a38..f37e3dd4d 100644
--- a/playwright/_impl/_console_message.py
+++ b/playwright/_impl/_console_message.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from asyncio import AbstractEventLoop
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
 
 from playwright._impl._api_structures import SourceLocation
 from playwright._impl._connection import from_channel, from_nullable_channel
@@ -21,6 +21,7 @@
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._page import Page
+    from playwright._impl._worker import Worker
 
 
 class ConsoleMessage:
@@ -31,6 +32,7 @@ def __init__(
         self._loop = loop
         self._dispatcher_fiber = dispatcher_fiber
         self._page: Optional["Page"] = from_nullable_channel(event.get("page"))
+        self._worker: Optional["Worker"] = from_nullable_channel(event.get("worker"))
 
     def __repr__(self) -> str:
         return f"<ConsoleMessage type={self.type} text={self.text}>"
@@ -39,7 +41,27 @@ def __str__(self) -> str:
         return self.text
 
     @property
-    def type(self) -> str:
+    def type(self) -> Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
         return self._event["type"]
 
     @property
@@ -57,3 +79,7 @@ def location(self) -> SourceLocation:
     @property
     def page(self) -> Optional["Page"]:
         return self._page
+
+    @property
+    def worker(self) -> Optional["Worker"]:
+        return self._worker
diff --git a/playwright/_impl/_dialog.py b/playwright/_impl/_dialog.py
index a0c6ca77f..226e703b9 100644
--- a/playwright/_impl/_dialog.py
+++ b/playwright/_impl/_dialog.py
@@ -48,7 +48,10 @@ def page(self) -> Optional["Page"]:
         return self._page
 
     async def accept(self, promptText: str = None) -> None:
-        await self._channel.send("accept", locals_to_params(locals()))
+        await self._channel.send("accept", None, locals_to_params(locals()))
 
     async def dismiss(self) -> None:
-        await self._channel.send("dismiss")
+        await self._channel.send(
+            "dismiss",
+            None,
+        )
diff --git a/playwright/_impl/_element_handle.py b/playwright/_impl/_element_handle.py
index d7482fdea..3854669d0 100644
--- a/playwright/_impl/_element_handle.py
+++ b/playwright/_impl/_element_handle.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import base64
+import mimetypes
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -55,56 +56,63 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._frame = cast("Frame", parent)
 
     async def _createSelectorForTest(self, name: str) -> Optional[str]:
-        return await self._channel.send("createSelectorForTest", dict(name=name))
+        return await self._channel.send(
+            "createSelectorForTest", self._frame._timeout, dict(name=name)
+        )
 
     def as_element(self) -> Optional["ElementHandle"]:
         return self
 
     async def owner_frame(self) -> Optional["Frame"]:
-        return from_nullable_channel(await self._channel.send("ownerFrame"))
+        return from_nullable_channel(await self._channel.send("ownerFrame", None))
 
     async def content_frame(self) -> Optional["Frame"]:
-        return from_nullable_channel(await self._channel.send("contentFrame"))
+        return from_nullable_channel(await self._channel.send("contentFrame", None))
 
     async def get_attribute(self, name: str) -> Optional[str]:
-        return await self._channel.send("getAttribute", dict(name=name))
+        return await self._channel.send("getAttribute", None, dict(name=name))
 
     async def text_content(self) -> Optional[str]:
-        return await self._channel.send("textContent")
+        return await self._channel.send("textContent", None)
 
     async def inner_text(self) -> str:
-        return await self._channel.send("innerText")
+        return await self._channel.send("innerText", None)
 
     async def inner_html(self) -> str:
-        return await self._channel.send("innerHTML")
+        return await self._channel.send("innerHTML", None)
 
     async def is_checked(self) -> bool:
-        return await self._channel.send("isChecked")
+        return await self._channel.send("isChecked", None)
 
     async def is_disabled(self) -> bool:
-        return await self._channel.send("isDisabled")
+        return await self._channel.send("isDisabled", None)
 
     async def is_editable(self) -> bool:
-        return await self._channel.send("isEditable")
+        return await self._channel.send("isEditable", None)
 
     async def is_enabled(self) -> bool:
-        return await self._channel.send("isEnabled")
+        return await self._channel.send("isEnabled", None)
 
     async def is_hidden(self) -> bool:
-        return await self._channel.send("isHidden")
+        return await self._channel.send("isHidden", None)
 
     async def is_visible(self) -> bool:
-        return await self._channel.send("isVisible")
+        return await self._channel.send("isVisible", None)
 
     async def dispatch_event(self, type: str, eventInit: Dict = None) -> None:
         await self._channel.send(
-            "dispatchEvent", dict(type=type, eventInit=serialize_argument(eventInit))
+            "dispatchEvent",
+            None,
+            dict(type=type, eventInit=serialize_argument(eventInit)),
         )
 
     async def scroll_into_view_if_needed(self, timeout: float = None) -> None:
-        await self._channel.send("scrollIntoViewIfNeeded", locals_to_params(locals()))
+        await self._channel.send(
+            "scrollIntoViewIfNeeded", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def hover(
         self,
@@ -115,7 +123,9 @@ async def hover(
         force: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("hover", locals_to_params(locals()))
+        await self._channel.send(
+            "hover", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def click(
         self,
@@ -128,8 +138,11 @@ async def click(
         force: bool = None,
         noWaitAfter: bool = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("click", locals_to_params(locals()))
+        await self._channel.send(
+            "click", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def dblclick(
         self,
@@ -141,8 +154,11 @@ async def dblclick(
         force: bool = None,
         noWaitAfter: bool = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("dblclick", locals_to_params(locals()))
+        await self._channel.send(
+            "dblclick", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def select_option(
         self,
@@ -158,10 +174,10 @@ async def select_option(
             dict(
                 timeout=timeout,
                 force=force,
-                **convert_select_option_values(value, index, label, element)
+                **convert_select_option_values(value, index, label, element),
             )
         )
-        return await self._channel.send("selectOption", params)
+        return await self._channel.send("selectOption", self._frame._timeout, params)
 
     async def tap(
         self,
@@ -172,7 +188,9 @@ async def tap(
         noWaitAfter: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("tap", locals_to_params(locals()))
+        await self._channel.send(
+            "tap", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def fill(
         self,
@@ -181,13 +199,19 @@ async def fill(
         noWaitAfter: bool = None,
         force: bool = None,
     ) -> None:
-        await self._channel.send("fill", locals_to_params(locals()))
+        await self._channel.send(
+            "fill", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def select_text(self, force: bool = None, timeout: float = None) -> None:
-        await self._channel.send("selectText", locals_to_params(locals()))
+        await self._channel.send(
+            "selectText", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def input_value(self, timeout: float = None) -> str:
-        return await self._channel.send("inputValue", locals_to_params(locals()))
+        return await self._channel.send(
+            "inputValue", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def set_input_files(
         self,
@@ -203,6 +227,7 @@ async def set_input_files(
         converted = await convert_input_files(files, frame.page.context)
         await self._channel.send(
             "setInputFiles",
+            self._frame._timeout,
             {
                 "timeout": timeout,
                 **converted,
@@ -210,7 +235,7 @@ async def set_input_files(
         )
 
     async def focus(self) -> None:
-        await self._channel.send("focus")
+        await self._channel.send("focus", None)
 
     async def type(
         self,
@@ -219,7 +244,9 @@ async def type(
         timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("type", locals_to_params(locals()))
+        await self._channel.send(
+            "type", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def press(
         self,
@@ -228,7 +255,9 @@ async def press(
         timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("press", locals_to_params(locals()))
+        await self._channel.send(
+            "press", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def set_checked(
         self,
@@ -262,7 +291,9 @@ async def check(
         noWaitAfter: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("check", locals_to_params(locals()))
+        await self._channel.send(
+            "check", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def uncheck(
         self,
@@ -272,10 +303,12 @@ async def uncheck(
         noWaitAfter: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("uncheck", locals_to_params(locals()))
+        await self._channel.send(
+            "uncheck", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def bounding_box(self) -> Optional[FloatRect]:
-        return await self._channel.send("boundingBox")
+        return await self._channel.send("boundingBox", None)
 
     async def screenshot(
         self,
@@ -293,6 +326,8 @@ async def screenshot(
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
+            if "type" not in params:
+                params["type"] = determine_screenshot_type(params["path"])
             del params["path"]
         if "mask" in params:
             params["mask"] = list(
@@ -306,7 +341,9 @@ async def screenshot(
                     params["mask"],
                 )
             )
-        encoded_binary = await self._channel.send("screenshot", params)
+        encoded_binary = await self._channel.send(
+            "screenshot", self._frame._timeout, params
+        )
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
             make_dirs_for_file(path)
@@ -315,14 +352,16 @@ async def screenshot(
 
     async def query_selector(self, selector: str) -> Optional["ElementHandle"]:
         return from_nullable_channel(
-            await self._channel.send("querySelector", dict(selector=selector))
+            await self._channel.send("querySelector", None, dict(selector=selector))
         )
 
     async def query_selector_all(self, selector: str) -> List["ElementHandle"]:
         return list(
             map(
                 cast(Callable[[Any], Any], from_nullable_channel),
-                await self._channel.send("querySelectorAll", dict(selector=selector)),
+                await self._channel.send(
+                    "querySelectorAll", None, dict(selector=selector)
+                ),
             )
         )
 
@@ -335,6 +374,7 @@ async def eval_on_selector(
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
@@ -352,6 +392,7 @@ async def eval_on_selector_all(
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
@@ -367,7 +408,9 @@ async def wait_for_element_state(
         ],
         timeout: float = None,
     ) -> None:
-        await self._channel.send("waitForElementState", locals_to_params(locals()))
+        await self._channel.send(
+            "waitForElementState", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def wait_for_selector(
         self,
@@ -377,7 +420,9 @@ async def wait_for_selector(
         strict: bool = None,
     ) -> Optional["ElementHandle"]:
         return from_nullable_channel(
-            await self._channel.send("waitForSelector", locals_to_params(locals()))
+            await self._channel.send(
+                "waitForSelector", self._frame._timeout, locals_to_params(locals())
+            )
         )
 
 
@@ -392,15 +437,15 @@ def convert_select_option_values(
 
     options: Any = None
     elements: Any = None
-    if value:
+    if value is not None:
         if isinstance(value, str):
             value = [value]
         options = (options or []) + list(map(lambda e: dict(valueOrLabel=e), value))
-    if index:
+    if index is not None:
         if isinstance(index, int):
             index = [index]
         options = (options or []) + list(map(lambda e: dict(index=e), index))
-    if label:
+    if label is not None:
         if isinstance(label, str):
             label = [label]
         options = (options or []) + list(map(lambda e: dict(label=e), label))
@@ -410,3 +455,12 @@ def convert_select_option_values(
         elements = list(map(lambda e: e._channel, element))
 
     return dict(options=options, elements=elements)
+
+
+def determine_screenshot_type(path: Union[str, Path]) -> Literal["jpeg", "png"]:
+    mime_type, _ = mimetypes.guess_type(path)
+    if mime_type == "image/png":
+        return "png"
+    if mime_type == "image/jpeg":
+        return "jpeg"
+    raise Error(f'Unsupported screenshot mime type for path "{path}": {mime_type}')
diff --git a/playwright/_impl/_fetch.py b/playwright/_impl/_fetch.py
index a4de751bd..50bf4ad4a 100644
--- a/playwright/_impl/_fetch.py
+++ b/playwright/_impl/_fetch.py
@@ -18,7 +18,6 @@
 import typing
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union, cast
-from urllib.parse import parse_qs
 
 import playwright._impl._network as network
 from playwright._impl._api_structures import (
@@ -37,6 +36,7 @@
     Error,
     NameValue,
     TargetClosedError,
+    TimeoutSettings,
     async_readfile,
     async_writefile,
     is_file_payload,
@@ -74,6 +74,8 @@ async def new_context(
         timeout: float = None,
         storageState: Union[StorageState, str, Path] = None,
         clientCertificates: List[ClientCertificate] = None,
+        failOnStatusCode: bool = None,
+        maxRedirects: int = None,
     ) -> "APIRequestContext":
         params = locals_to_params(locals())
         if "storageState" in params:
@@ -89,8 +91,11 @@ async def new_context(
         )
         context = cast(
             APIRequestContext,
-            from_channel(await self.playwright._channel.send("newRequest", params)),
+            from_channel(
+                await self.playwright._channel.send("newRequest", None, params)
+            ),
         )
+        context._timeout_settings.set_default_timeout(timeout)
         return context
 
 
@@ -101,11 +106,12 @@ def __init__(
         super().__init__(parent, type, guid, initializer)
         self._tracing: Tracing = from_channel(initializer["tracing"])
         self._close_reason: Optional[str] = None
+        self._timeout_settings = TimeoutSettings(None)
 
     async def dispose(self, reason: str = None) -> None:
         self._close_reason = reason
         try:
-            await self._channel.send("dispose", {"reason": reason})
+            await self._channel.send("dispose", None, {"reason": reason})
         except Error as e:
             if is_target_closed_error(e):
                 return
@@ -403,16 +409,18 @@ async def _inner_fetch(
 
         response = await self._channel.send(
             "fetch",
+            self._timeout_settings.timeout,
             {
                 "url": url,
-                "params": params_to_protocol(params),
+                "timeout": timeout,
+                "params": object_to_array(params) if isinstance(params, dict) else None,
+                "encodedParams": params if isinstance(params, str) else None,
                 "method": method,
                 "headers": serialized_headers,
                 "postData": post_data,
                 "jsonData": json_data,
                 "formData": form_data,
                 "multipartData": multipart_data,
-                "timeout": timeout,
                 "failOnStatusCode": failOnStatusCode,
                 "ignoreHTTPSErrors": ignoreHTTPSErrors,
                 "maxRedirects": maxRedirects,
@@ -422,31 +430,18 @@ async def _inner_fetch(
         return APIResponse(self, response)
 
     async def storage_state(
-        self, path: Union[pathlib.Path, str] = None
+        self,
+        path: Union[pathlib.Path, str] = None,
+        indexedDB: bool = None,
     ) -> StorageState:
-        result = await self._channel.send_return_as_dict("storageState")
+        result = await self._channel.send_return_as_dict(
+            "storageState", None, {"indexedDB": indexedDB}
+        )
         if path:
             await async_writefile(path, json.dumps(result))
         return result
 
 
-def params_to_protocol(params: Optional[ParamsType]) -> Optional[List[NameValue]]:
-    if not params:
-        return None
-    if isinstance(params, dict):
-        return object_to_array(params)
-    if params.startswith("?"):
-        params = params[1:]
-    parsed = parse_qs(params)
-    if not parsed:
-        return None
-    out = []
-    for name, values in parsed.items():
-        for value in values:
-            out.append(NameValue(name=name, value=value))
-    return out
-
-
 def file_payload_to_json(payload: FilePayload) -> ServerFilePayload:
     return ServerFilePayload(
         name=payload["name"],
@@ -492,11 +487,15 @@ def headers_array(self) -> network.HeadersArray:
 
     async def body(self) -> bytes:
         try:
-            result = await self._request._channel.send_return_as_dict(
-                "fetchResponseBody",
-                {
-                    "fetchUid": self._fetch_uid,
-                },
+            result = await self._request._connection.wrap_api_call(
+                lambda: self._request._channel.send_return_as_dict(
+                    "fetchResponseBody",
+                    None,
+                    {
+                        "fetchUid": self._fetch_uid,
+                    },
+                ),
+                True,
             )
             if result is None:
                 raise Error("Response has been disposed")
@@ -517,6 +516,7 @@ async def json(self) -> Any:
     async def dispose(self) -> None:
         await self._request._channel.send(
             "disposeAPIResponse",
+            None,
             {
                 "fetchUid": self._fetch_uid,
             },
@@ -529,6 +529,7 @@ def _fetch_uid(self) -> str:
     async def _fetch_log(self) -> List[str]:
         return await self._request._channel.send(
             "fetchLog",
+            None,
             {
                 "fetchUid": self._fetch_uid,
             },
diff --git a/playwright/_impl/_frame.py b/playwright/_impl/_frame.py
index 1ce813636..b976667e7 100644
--- a/playwright/_impl/_frame.py
+++ b/playwright/_impl/_frame.py
@@ -19,6 +19,7 @@
     Any,
     Dict,
     List,
+    Literal,
     Optional,
     Pattern,
     Sequence,
@@ -29,7 +30,13 @@
 
 from pyee import EventEmitter
 
-from playwright._impl._api_structures import AriaRole, FilePayload, Position
+from playwright._impl._api_structures import (
+    AriaRole,
+    FilePayload,
+    FrameExpectOptions,
+    FrameExpectResult,
+    Position,
+)
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
@@ -42,19 +49,20 @@
     DocumentLoadState,
     FrameNavigatedEvent,
     KeyboardModifier,
-    Literal,
     MouseButton,
+    TimeoutSettings,
     URLMatch,
-    URLMatcher,
     async_readfile,
     locals_to_params,
     monotonic_time,
+    url_matches,
 )
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
     add_source_url_to_script,
     parse_result,
+    parse_value,
     serialize_argument,
 )
 from playwright._impl._locator import (
@@ -125,7 +133,7 @@ def _on_frame_navigated(self, event: FrameNavigatedEvent) -> None:
             self._page.emit("framenavigated", self)
 
     async def _query_count(self, selector: str) -> int:
-        return await self._channel.send("queryCount", {"selector": selector})
+        return await self._channel.send("queryCount", None, {"selector": selector})
 
     @property
     def page(self) -> "Page":
@@ -142,7 +150,9 @@ async def goto(
         return cast(
             Optional[Response],
             from_nullable_channel(
-                await self._channel.send("goto", locals_to_params(locals()))
+                await self._channel.send(
+                    "goto", self._navigation_timeout, locals_to_params(locals())
+                )
             ),
         )
 
@@ -163,11 +173,33 @@ def _setup_navigation_waiter(self, wait_name: str, timeout: float = None) -> Wai
             Error("Navigating frame was detached!"),
             lambda frame: frame == self,
         )
-        if timeout is None:
-            timeout = self._page._timeout_settings.navigation_timeout()
+        timeout = self._page._timeout_settings.navigation_timeout(timeout)
         waiter.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
         return waiter
 
+    async def _expect(
+        self,
+        selector: Optional[str],
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
+    ) -> FrameExpectResult:
+        if "expectedValue" in options:
+            options["expectedValue"] = serialize_argument(options["expectedValue"])
+        result = await self._channel.send_return_as_dict(
+            "expect",
+            self._timeout,
+            {
+                "selector": selector,
+                "expression": expression,
+                **options,
+            },
+            title=title,
+        )
+        if result.get("received"):
+            result["received"] = parse_value(result["received"])
+        return result
+
     def expect_navigation(
         self,
         url: URLMatch = None,
@@ -185,18 +217,17 @@ def expect_navigation(
 
         to_url = f' to "{url}"' if url else ""
         waiter.log(f"waiting for navigation{to_url} until '{waitUntil}'")
-        matcher = (
-            URLMatcher(self._page._browser_context._options.get("baseURL"), url)
-            if url
-            else None
-        )
 
         def predicate(event: Any) -> bool:
             # Any failed navigation results in a rejection.
             if event.get("error"):
                 return True
             waiter.log(f'  navigated to "{event["url"]}"')
-            return not matcher or matcher.matches(event["url"])
+            return url_matches(
+                cast("Page", self._page)._browser_context._base_url,
+                event["url"],
+                url,
+            )
 
         waiter.wait_for_event(
             self._event_emitter,
@@ -226,8 +257,7 @@ async def wait_for_url(
         timeout: float = None,
     ) -> None:
         assert self._page
-        matcher = URLMatcher(self._page._browser_context._options.get("baseURL"), url)
-        if matcher.matches(self.url):
+        if url_matches(self._page._browser_context._base_url, self.url, url):
             await self._wait_for_load_state_impl(state=waitUntil, timeout=timeout)
             return
         async with self.expect_navigation(
@@ -270,13 +300,26 @@ def handle_load_state_event(actual_state: str) -> bool:
             )
         await waiter.result()
 
+    def _timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
+        )
+        return timeout_settings.timeout(timeout)
+
+    def _navigation_timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
+        )
+        return timeout_settings.navigation_timeout(timeout)
+
     async def frame_element(self) -> ElementHandle:
-        return from_channel(await self._channel.send("frameElement"))
+        return from_channel(await self._channel.send("frameElement", None))
 
     async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -290,6 +333,7 @@ async def evaluate_handle(
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -301,14 +345,16 @@ async def query_selector(
         self, selector: str, strict: bool = None
     ) -> Optional[ElementHandle]:
         return from_nullable_channel(
-            await self._channel.send("querySelector", locals_to_params(locals()))
+            await self._channel.send("querySelector", None, locals_to_params(locals()))
         )
 
     async def query_selector_all(self, selector: str) -> List[ElementHandle]:
         return list(
             map(
                 from_channel,
-                await self._channel.send("querySelectorAll", dict(selector=selector)),
+                await self._channel.send(
+                    "querySelectorAll", None, dict(selector=selector)
+                ),
             )
         )
 
@@ -320,38 +366,48 @@ async def wait_for_selector(
         state: Literal["attached", "detached", "hidden", "visible"] = None,
     ) -> Optional[ElementHandle]:
         return from_nullable_channel(
-            await self._channel.send("waitForSelector", locals_to_params(locals()))
+            await self._channel.send(
+                "waitForSelector", self._timeout, locals_to_params(locals())
+            )
         )
 
     async def is_checked(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._channel.send("isChecked", locals_to_params(locals()))
+        return await self._channel.send(
+            "isChecked", self._timeout, locals_to_params(locals())
+        )
 
     async def is_disabled(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._channel.send("isDisabled", locals_to_params(locals()))
+        return await self._channel.send(
+            "isDisabled", self._timeout, locals_to_params(locals())
+        )
 
     async def is_editable(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._channel.send("isEditable", locals_to_params(locals()))
+        return await self._channel.send(
+            "isEditable", self._timeout, locals_to_params(locals())
+        )
 
     async def is_enabled(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._channel.send("isEnabled", locals_to_params(locals()))
+        return await self._channel.send(
+            "isEnabled", self._timeout, locals_to_params(locals())
+        )
 
-    async def is_hidden(
-        self, selector: str, strict: bool = None, timeout: float = None
-    ) -> bool:
-        return await self._channel.send("isHidden", locals_to_params(locals()))
+    async def is_hidden(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isHidden", self._timeout, locals_to_params(locals())
+        )
 
-    async def is_visible(
-        self, selector: str, strict: bool = None, timeout: float = None
-    ) -> bool:
-        return await self._channel.send("isVisible", locals_to_params(locals()))
+    async def is_visible(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isVisible", self._timeout, locals_to_params(locals())
+        )
 
     async def dispatch_event(
         self,
@@ -363,6 +419,7 @@ async def dispatch_event(
     ) -> None:
         await self._channel.send(
             "dispatchEvent",
+            self._timeout,
             locals_to_params(
                 dict(
                     selector=selector,
@@ -384,6 +441,7 @@ async def eval_on_selector(
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
+                None,
                 locals_to_params(
                     dict(
                         selector=selector,
@@ -404,6 +462,7 @@ async def eval_on_selector_all(
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
@@ -413,7 +472,7 @@ async def eval_on_selector_all(
         )
 
     async def content(self) -> str:
-        return await self._channel.send("content")
+        return await self._channel.send("content", None)
 
     async def set_content(
         self,
@@ -421,7 +480,9 @@ async def set_content(
         timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> None:
-        await self._channel.send("setContent", locals_to_params(locals()))
+        await self._channel.send(
+            "setContent", self._navigation_timeout, locals_to_params(locals())
+        )
 
     @property
     def name(self) -> str:
@@ -455,7 +516,7 @@ async def add_script_tag(
                 (await async_readfile(path)).decode(), path
             )
             del params["path"]
-        return from_channel(await self._channel.send("addScriptTag", params))
+        return from_channel(await self._channel.send("addScriptTag", None, params))
 
     async def add_style_tag(
         self, url: str = None, path: Union[str, Path] = None, content: str = None
@@ -469,7 +530,7 @@ async def add_style_tag(
                 + "*/"
             )
             del params["path"]
-        return from_channel(await self._channel.send("addStyleTag", params))
+        return from_channel(await self._channel.send("addStyleTag", None, params))
 
     async def click(
         self,
@@ -485,7 +546,24 @@ async def click(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("click", locals_to_params(locals()))
+        await self._click(**locals_to_params(locals()))
+
+    async def _click(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        steps: int = None,
+    ) -> None:
+        await self._channel.send("click", self._timeout, locals_to_params(locals()))
 
     async def dblclick(
         self,
@@ -500,7 +578,9 @@ async def dblclick(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("dblclick", locals_to_params(locals()))
+        await self._channel.send(
+            "dblclick", self._timeout, locals_to_params(locals()), title="Double click"
+        )
 
     async def tap(
         self,
@@ -513,7 +593,7 @@ async def tap(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("tap", locals_to_params(locals()))
+        await self._channel.send("tap", self._timeout, locals_to_params(locals()))
 
     async def fill(
         self,
@@ -524,7 +604,19 @@ async def fill(
         strict: bool = None,
         force: bool = None,
     ) -> None:
-        await self._channel.send("fill", locals_to_params(locals()))
+        await self._fill(**locals_to_params(locals()))
+
+    async def _fill(
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+        title: str = None,
+    ) -> None:
+        await self._channel.send("fill", self._timeout, locals_to_params(locals()))
 
     def locator(
         self,
@@ -605,27 +697,35 @@ def frame_locator(self, selector: str) -> FrameLocator:
     async def focus(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> None:
-        await self._channel.send("focus", locals_to_params(locals()))
+        await self._channel.send("focus", self._timeout, locals_to_params(locals()))
 
     async def text_content(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> Optional[str]:
-        return await self._channel.send("textContent", locals_to_params(locals()))
+        return await self._channel.send(
+            "textContent", self._timeout, locals_to_params(locals())
+        )
 
     async def inner_text(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> str:
-        return await self._channel.send("innerText", locals_to_params(locals()))
+        return await self._channel.send(
+            "innerText", self._timeout, locals_to_params(locals())
+        )
 
     async def inner_html(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> str:
-        return await self._channel.send("innerHTML", locals_to_params(locals()))
+        return await self._channel.send(
+            "innerHTML", self._timeout, locals_to_params(locals())
+        )
 
     async def get_attribute(
         self, selector: str, name: str, strict: bool = None, timeout: float = None
     ) -> Optional[str]:
-        return await self._channel.send("getAttribute", locals_to_params(locals()))
+        return await self._channel.send(
+            "getAttribute", self._timeout, locals_to_params(locals())
+        )
 
     async def hover(
         self,
@@ -638,7 +738,7 @@ async def hover(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("hover", locals_to_params(locals()))
+        await self._channel.send("hover", self._timeout, locals_to_params(locals()))
 
     async def drag_and_drop(
         self,
@@ -651,8 +751,11 @@ async def drag_and_drop(
         strict: bool = None,
         timeout: float = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("dragAndDrop", locals_to_params(locals()))
+        await self._channel.send(
+            "dragAndDrop", self._timeout, locals_to_params(locals())
+        )
 
     async def select_option(
         self,
@@ -675,7 +778,7 @@ async def select_option(
                 **convert_select_option_values(value, index, label, element),
             )
         )
-        return await self._channel.send("selectOption", params)
+        return await self._channel.send("selectOption", self._timeout, params)
 
     async def input_value(
         self,
@@ -683,7 +786,9 @@ async def input_value(
         strict: bool = None,
         timeout: float = None,
     ) -> str:
-        return await self._channel.send("inputValue", locals_to_params(locals()))
+        return await self._channel.send(
+            "inputValue", self._timeout, locals_to_params(locals())
+        )
 
     async def set_input_files(
         self,
@@ -698,10 +803,11 @@ async def set_input_files(
         converted = await convert_input_files(files, self.page.context)
         await self._channel.send(
             "setInputFiles",
+            self._timeout,
             {
                 "selector": selector,
                 "strict": strict,
-                "timeout": timeout,
+                "timeout": self._timeout(timeout),
                 **converted,
             },
         )
@@ -715,7 +821,7 @@ async def type(
         timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("type", locals_to_params(locals()))
+        await self._channel.send("type", self._timeout, locals_to_params(locals()))
 
     async def press(
         self,
@@ -726,7 +832,7 @@ async def press(
         timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("press", locals_to_params(locals()))
+        await self._channel.send("press", self._timeout, locals_to_params(locals()))
 
     async def check(
         self,
@@ -738,7 +844,7 @@ async def check(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("check", locals_to_params(locals()))
+        await self._channel.send("check", self._timeout, locals_to_params(locals()))
 
     async def uncheck(
         self,
@@ -750,10 +856,10 @@ async def uncheck(
         strict: bool = None,
         trial: bool = None,
     ) -> None:
-        await self._channel.send("uncheck", locals_to_params(locals()))
+        await self._channel.send("uncheck", self._timeout, locals_to_params(locals()))
 
     async def wait_for_timeout(self, timeout: float) -> None:
-        await self._channel.send("waitForTimeout", locals_to_params(locals()))
+        await self._channel.send("waitForTimeout", None, {"waitTimeout": timeout})
 
     async def wait_for_function(
         self,
@@ -768,10 +874,12 @@ async def wait_for_function(
         params["arg"] = serialize_argument(arg)
         if polling is not None and polling != "raf":
             params["pollingInterval"] = polling
-        return from_channel(await self._channel.send("waitForFunction", params))
+        return from_channel(
+            await self._channel.send("waitForFunction", self._timeout, params)
+        )
 
     async def title(self) -> str:
-        return await self._channel.send("title")
+        return await self._channel.send("title", None)
 
     async def set_checked(
         self,
@@ -804,4 +912,4 @@ async def set_checked(
             )
 
     async def _highlight(self, selector: str) -> None:
-        await self._channel.send("highlight", {"selector": selector})
+        await self._channel.send("highlight", None, {"selector": selector})
diff --git a/playwright/_impl/_glob.py b/playwright/_impl/_glob.py
index 2d899a789..b38826996 100644
--- a/playwright/_impl/_glob.py
+++ b/playwright/_impl/_glob.py
@@ -11,13 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import re
 
 #  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
 escaped_chars = {"$", "^", "+", ".", "*", "(", ")", "|", "\\", "?", "{", "}", "[", "]"}
 
 
-def glob_to_regex(glob: str) -> "re.Pattern[str]":
+def glob_to_regex_pattern(glob: str) -> str:
     tokens = ["^"]
     in_group = False
 
@@ -29,40 +28,38 @@ def glob_to_regex(glob: str) -> "re.Pattern[str]":
             tokens.append("\\" + char if char in escaped_chars else char)
             i += 1
         elif c == "*":
-            before_deep = glob[i - 1] if i > 0 else None
+            char_before = glob[i - 1] if i > 0 else None
             star_count = 1
             while i + 1 < len(glob) and glob[i + 1] == "*":
                 star_count += 1
                 i += 1
-            after_deep = glob[i + 1] if i + 1 < len(glob) else None
-            is_deep = (
-                star_count > 1
-                and (before_deep == "/" or before_deep is None)
-                and (after_deep == "/" or after_deep is None)
-            )
-            if is_deep:
-                tokens.append("((?:[^/]*(?:/|$))*)")
-                i += 1
+            if star_count > 1:
+                char_after = glob[i + 1] if i + 1 < len(glob) else None
+                if char_after == "/":
+                    if char_before == "/":
+                        tokens.append("((.+/)|)")
+                    else:
+                        tokens.append("(.*/)")
+                    i += 1
+                else:
+                    tokens.append("(.*)")
             else:
                 tokens.append("([^/]*)")
         else:
-            if c == "?":
-                tokens.append(".")
-            elif c == "[":
-                tokens.append("[")
-            elif c == "]":
-                tokens.append("]")
-            elif c == "{":
+            if c == "{":
                 in_group = True
                 tokens.append("(")
             elif c == "}":
                 in_group = False
                 tokens.append(")")
-            elif c == "," and in_group:
-                tokens.append("|")
+            elif c == ",":
+                if in_group:
+                    tokens.append("|")
+                else:
+                    tokens.append("\\" + c)
             else:
                 tokens.append("\\" + c if c in escaped_chars else c)
         i += 1
 
     tokens.append("$")
-    return re.compile("".join(tokens))
+    return "".join(tokens)
diff --git a/playwright/_impl/_har_router.py b/playwright/_impl/_har_router.py
index 33ff37871..1fa1b0433 100644
--- a/playwright/_impl/_har_router.py
+++ b/playwright/_impl/_har_router.py
@@ -49,7 +49,7 @@ async def create(
         not_found_action: RouteFromHarNotFoundPolicy,
         url_matcher: Optional[URLMatch] = None,
     ) -> "HarRouter":
-        har_id = await local_utils._channel.send("harOpen", {"file": file})
+        har_id = await local_utils._channel.send("harOpen", None, {"file": file})
         return HarRouter(
             local_utils=local_utils,
             har_id=har_id,
@@ -118,5 +118,5 @@ async def add_page_route(self, page: "Page") -> None:
 
     def dispose(self) -> None:
         asyncio.create_task(
-            self._local_utils._channel.send("harClose", {"harId": self._har_id})
+            self._local_utils._channel.send("harClose", None, {"harId": self._har_id})
         )
diff --git a/playwright/_impl/_helper.py b/playwright/_impl/_helper.py
index a27f4a789..1d7e4f67b 100644
--- a/playwright/_impl/_helper.py
+++ b/playwright/_impl/_helper.py
@@ -29,12 +29,13 @@
     Optional,
     Pattern,
     Set,
+    Tuple,
     TypedDict,
     TypeVar,
     Union,
     cast,
 )
-from urllib.parse import urljoin
+from urllib.parse import ParseResult, urljoin, urlparse, urlunparse
 
 from playwright._impl._api_structures import NameValue
 from playwright._impl._errors import (
@@ -44,13 +45,13 @@
     is_target_closed_error,
     rewrite_error,
 )
-from playwright._impl._glob import glob_to_regex
+from playwright._impl._glob import glob_to_regex_pattern
 from playwright._impl._greenlets import RouteGreenlet
 from playwright._impl._str_utils import escape_regex_flags
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._api_structures import HeadersArray
-    from playwright._impl._network import Request, Response, Route
+    from playwright._impl._network import Request, Response, Route, WebSocketRoute
 
 URLMatch = Union[str, Pattern[str], Callable[[str], bool]]
 URLMatchRequest = Union[str, Pattern[str], Callable[["Request"], bool]]
@@ -58,9 +59,11 @@
 RouteHandlerCallback = Union[
     Callable[["Route"], Any], Callable[["Route", "Request"], Any]
 ]
+WebSocketRouteHandlerCallback = Callable[["WebSocketRoute"], Any]
 
 ColorScheme = Literal["dark", "light", "no-preference", "null"]
 ForcedColors = Literal["active", "none", "null"]
+Contrast = Literal["more", "no-preference", "null"]
 ReducedMotion = Literal["no-preference", "null", "reduce"]
 DocumentLoadState = Literal["commit", "domcontentloaded", "load", "networkidle"]
 KeyboardModifier = Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]
@@ -141,27 +144,131 @@ class FrameNavigatedEvent(TypedDict):
 Env = Dict[str, Union[str, float, bool]]
 
 
-class URLMatcher:
-    def __init__(self, base_url: Union[str, None], match: URLMatch) -> None:
-        self._callback: Optional[Callable[[str], bool]] = None
-        self._regex_obj: Optional[Pattern[str]] = None
-        if isinstance(match, str):
-            if base_url and not match.startswith("*"):
-                match = urljoin(base_url, match)
-            regex = glob_to_regex(match)
-            self._regex_obj = re.compile(regex)
-        elif isinstance(match, Pattern):
-            self._regex_obj = match
+def url_matches(
+    base_url: Optional[str],
+    url_string: str,
+    match: Optional[URLMatch],
+    websocket_url: bool = None,
+) -> bool:
+    if not match:
+        return True
+    if isinstance(match, str):
+        match = re.compile(
+            resolve_glob_to_regex_pattern(base_url, match, websocket_url)
+        )
+    if isinstance(match, Pattern):
+        return bool(match.search(url_string))
+    return match(url_string)
+
+
+def resolve_glob_to_regex_pattern(
+    base_url: Optional[str], glob: str, websocket_url: bool = None
+) -> str:
+    if websocket_url:
+        base_url = to_websocket_base_url(base_url)
+    glob = resolve_glob_base(base_url, glob)
+    return glob_to_regex_pattern(glob)
+
+
+def to_websocket_base_url(base_url: Optional[str]) -> Optional[str]:
+    if base_url is not None and re.match(r"^https?://", base_url):
+        base_url = re.sub(r"^http", "ws", base_url)
+    return base_url
+
+
+def resolve_glob_base(base_url: Optional[str], match: str) -> str:
+    if match[0] == "*":
+        return match
+
+    token_map: Dict[str, str] = {}
+
+    def map_token(original: str, replacement: str) -> str:
+        if len(original) == 0:
+            return ""
+        token_map[replacement] = original
+        return replacement
+
+    # Escaped `\\?` behaves the same as `?` in our glob patterns.
+    match = match.replace(r"\\?", "?")
+    # Special case about: URLs as they are not relative to base_url
+    if (
+        match.startswith("about:")
+        or match.startswith("data:")
+        or match.startswith("chrome:")
+        or match.startswith("edge:")
+        or match.startswith("file:")
+    ):
+        # about: and data: URLs are not relative to base_url, so we return them as is.
+        return match
+    # Glob symbols may be escaped in the URL and some of them such as ? affect resolution,
+    # so we replace them with safe components first.
+    processed_parts = []
+    for index, token in enumerate(match.split("/")):
+        if token in (".", "..", ""):
+            processed_parts.append(token)
+            continue
+        # Handle special case of http*://, note that the new schema has to be
+        # a web schema so that slashes are properly inserted after domain.
+        if index == 0 and token.endswith(":"):
+            # Replace any pattern with http:
+            if "*" in token or "{" in token:
+                processed_parts.append(map_token(token, "http:"))
+            else:
+                # Preserve explicit schema as is as it may affect trailing slashes after domain.
+                processed_parts.append(token)
+            continue
+        question_index = token.find("?")
+        if question_index == -1:
+            processed_parts.append(map_token(token, f"$_{index}_$"))
         else:
-            self._callback = match
-        self.match = match
+            new_prefix = map_token(token[:question_index], f"$_{index}_$")
+            new_suffix = map_token(token[question_index:], f"?$_{index}_$")
+            processed_parts.append(new_prefix + new_suffix)
+
+    relative_path = "/".join(processed_parts)
+    resolved, case_insensitive_part = resolve_base_url(base_url, relative_path)
+
+    for token, original in token_map.items():
+        normalize = case_insensitive_part and token in case_insensitive_part
+        resolved = resolved.replace(
+            token, original.lower() if normalize else original, 1
+        )
+
+    return resolved
+
+
+def resolve_base_url(
+    base_url: Optional[str], given_url: str
+) -> Tuple[str, Optional[str]]:
+    try:
+        url = nodelike_urlparse(
+            urljoin(base_url if base_url is not None else "", given_url)
+        )
+        resolved = urlunparse(url)
+        # Schema and domain are case-insensitive.
+        hostname_port = (
+            url.hostname or ""
+        )  # can't use parsed.netloc because it includes userinfo (username:password)
+        if url.port:
+            hostname_port += f":{url.port}"
+        case_insensitive_prefix = f"{url.scheme}://{hostname_port}"
+        return resolved, case_insensitive_prefix
+    except Exception:
+        return given_url, None
+
 
-    def matches(self, url: str) -> bool:
-        if self._callback:
-            return self._callback(url)
-        if self._regex_obj:
-            return cast(bool, self._regex_obj.search(url))
-        return False
+def nodelike_urlparse(url: str) -> ParseResult:
+    parsed = urlparse(url, allow_fragments=True)
+
+    # https://url.spec.whatwg.org/#special-scheme
+    is_special_url = parsed.scheme in ["http", "https", "ws", "wss", "ftp", "file"]
+    if is_special_url:
+        # special urls have a list path, list paths are serialized as follows: https://url.spec.whatwg.org/#url-path-serializer
+        # urllib diverges, so we patch it here
+        if parsed.path == "":
+            parsed = parsed._replace(path="/")
+
+    return parsed
 
 
 class HarLookupResult(TypedDict, total=False):
@@ -173,7 +280,21 @@ class HarLookupResult(TypedDict, total=False):
     body: Optional[str]
 
 
+DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS = 30000
+DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS = 180000
+PLAYWRIGHT_MAX_DEADLINE = 2147483647  # 2^31-1
+
+
 class TimeoutSettings:
+
+    @staticmethod
+    def launch_timeout(timeout: Optional[float] = None) -> float:
+        return (
+            timeout
+            if timeout is not None
+            else DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS
+        )
+
     def __init__(self, parent: Optional["TimeoutSettings"]) -> None:
         self._parent = parent
         self._default_timeout: Optional[float] = None
@@ -189,7 +310,7 @@ def timeout(self, timeout: float = None) -> float:
             return self._default_timeout
         if self._parent:
             return self._parent.timeout()
-        return 30000
+        return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
 
     def set_default_navigation_timeout(
         self, navigation_timeout: Optional[float]
@@ -202,12 +323,16 @@ def default_navigation_timeout(self) -> Optional[float]:
     def default_timeout(self) -> Optional[float]:
         return self._default_timeout
 
-    def navigation_timeout(self) -> float:
+    def navigation_timeout(self, timeout: float = None) -> float:
+        if timeout is not None:
+            return timeout
         if self._default_navigation_timeout is not None:
             return self._default_navigation_timeout
+        if self._default_timeout is not None:
+            return self._default_timeout
         if self._parent:
             return self._parent.navigation_timeout()
-        return 30000
+        return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
 
 
 def serialize_error(ex: Exception, tb: Optional[TracebackType]) -> ErrorPayload:
@@ -270,12 +395,14 @@ def __init__(self, complete: "asyncio.Future", route: "Route") -> None:
 class RouteHandler:
     def __init__(
         self,
-        matcher: URLMatcher,
+        base_url: Optional[str],
+        url: URLMatch,
         handler: RouteHandlerCallback,
         is_sync: bool,
         times: Optional[int] = None,
     ):
-        self.matcher = matcher
+        self._base_url = base_url
+        self.url = url
         self.handler = handler
         self._times = times if times else math.inf
         self._handled_count = 0
@@ -284,7 +411,7 @@ def __init__(
         self._active_invocations: Set[RouteHandlerInvocation] = set()
 
     def matches(self, request_url: str) -> bool:
-        return self.matcher.matches(request_url)
+        return url_matches(self._base_url, request_url, self.url)
 
     async def handle(self, route: "Route") -> bool:
         handler_invocation = RouteHandlerInvocation(
@@ -361,13 +488,13 @@ def prepare_interception_patterns(
         patterns = []
         all = False
         for handler in handlers:
-            if isinstance(handler.matcher.match, str):
-                patterns.append({"glob": handler.matcher.match})
-            elif isinstance(handler.matcher._regex_obj, re.Pattern):
+            if isinstance(handler.url, str):
+                patterns.append({"glob": handler.url})
+            elif isinstance(handler.url, re.Pattern):
                 patterns.append(
                     {
-                        "regexSource": handler.matcher._regex_obj.pattern,
-                        "regexFlags": escape_regex_flags(handler.matcher._regex_obj),
+                        "regexSource": handler.url.pattern,
+                        "regexFlags": escape_regex_flags(handler.url),
                     }
                 )
             else:
diff --git a/playwright/_impl/_impl_to_api_mapping.py b/playwright/_impl/_impl_to_api_mapping.py
index 4315e1868..e26d22025 100644
--- a/playwright/_impl/_impl_to_api_mapping.py
+++ b/playwright/_impl/_impl_to_api_mapping.py
@@ -117,7 +117,7 @@ def to_impl(
         except RecursionError:
             raise Error("Maximum argument depth exceeded")
 
-    def wrap_handler(self, handler: Callable[..., None]) -> Callable[..., None]:
+    def wrap_handler(self, handler: Callable[..., Any]) -> Callable[..., None]:
         def wrapper_func(*args: Any) -> Any:
             arg_count = len(inspect.signature(handler).parameters)
             return handler(
diff --git a/playwright/_impl/_input.py b/playwright/_impl/_input.py
index a97ba5d11..8a39242ee 100644
--- a/playwright/_impl/_input.py
+++ b/playwright/_impl/_input.py
@@ -23,19 +23,19 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def down(self, key: str) -> None:
-        await self._channel.send("keyboardDown", locals_to_params(locals()))
+        await self._channel.send("keyboardDown", None, locals_to_params(locals()))
 
     async def up(self, key: str) -> None:
-        await self._channel.send("keyboardUp", locals_to_params(locals()))
+        await self._channel.send("keyboardUp", None, locals_to_params(locals()))
 
     async def insert_text(self, text: str) -> None:
-        await self._channel.send("keyboardInsertText", locals_to_params(locals()))
+        await self._channel.send("keyboardInsertText", None, locals_to_params(locals()))
 
     async def type(self, text: str, delay: float = None) -> None:
-        await self._channel.send("keyboardType", locals_to_params(locals()))
+        await self._channel.send("keyboardType", None, locals_to_params(locals()))
 
     async def press(self, key: str, delay: float = None) -> None:
-        await self._channel.send("keyboardPress", locals_to_params(locals()))
+        await self._channel.send("keyboardPress", None, locals_to_params(locals()))
 
 
 class Mouse:
@@ -45,21 +45,34 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def move(self, x: float, y: float, steps: int = None) -> None:
-        await self._channel.send("mouseMove", locals_to_params(locals()))
+        await self._channel.send("mouseMove", None, locals_to_params(locals()))
 
     async def down(
         self,
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseDown", locals_to_params(locals()))
+        await self._channel.send("mouseDown", None, locals_to_params(locals()))
 
     async def up(
         self,
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseUp", locals_to_params(locals()))
+        await self._channel.send("mouseUp", None, locals_to_params(locals()))
+
+    async def _click(
+        self,
+        x: float,
+        y: float,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        title: str = None,
+    ) -> None:
+        await self._channel.send(
+            "mouseClick", None, locals_to_params(locals()), title=title
+        )
 
     async def click(
         self,
@@ -69,7 +82,9 @@ async def click(
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseClick", locals_to_params(locals()))
+        params = locals()
+        del params["self"]
+        await self._click(**params)
 
     async def dblclick(
         self,
@@ -78,10 +93,12 @@ async def dblclick(
         delay: float = None,
         button: MouseButton = None,
     ) -> None:
-        await self.click(x, y, delay=delay, button=button, clickCount=2)
+        await self._click(
+            x, y, delay=delay, button=button, clickCount=2, title="Double click"
+        )
 
     async def wheel(self, deltaX: float, deltaY: float) -> None:
-        await self._channel.send("mouseWheel", locals_to_params(locals()))
+        await self._channel.send("mouseWheel", None, locals_to_params(locals()))
 
 
 class Touchscreen:
@@ -91,4 +108,4 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def tap(self, x: float, y: float) -> None:
-        await self._channel.send("touchscreenTap", locals_to_params(locals()))
+        await self._channel.send("touchscreenTap", None, locals_to_params(locals()))
diff --git a/playwright/_impl/_js_handle.py b/playwright/_impl/_js_handle.py
index a8be0ee18..84ef40d18 100644
--- a/playwright/_impl/_js_handle.py
+++ b/playwright/_impl/_js_handle.py
@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
 import collections.abc
 import datetime
 import math
+import struct
 import traceback
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
@@ -69,6 +71,7 @@ async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -82,6 +85,7 @@ async def evaluate_handle(
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -91,13 +95,16 @@ async def evaluate_handle(
 
     async def get_property(self, propertyName: str) -> "JSHandle":
         return from_channel(
-            await self._channel.send("getProperty", dict(name=propertyName))
+            await self._channel.send("getProperty", None, dict(name=propertyName))
         )
 
     async def get_properties(self) -> Dict[str, "JSHandle"]:
         return {
             prop["name"]: from_channel(prop["value"])
-            for prop in await self._channel.send("getPropertyList")
+            for prop in await self._channel.send(
+                "getPropertyList",
+                None,
+            )
         }
 
     def as_element(self) -> Optional["ElementHandle"]:
@@ -105,13 +112,21 @@ def as_element(self) -> Optional["ElementHandle"]:
 
     async def dispose(self) -> None:
         try:
-            await self._channel.send("dispose")
+            await self._channel.send(
+                "dispose",
+                None,
+            )
         except Exception as e:
             if not is_target_closed_error(e):
                 raise e
 
     async def json_value(self) -> Any:
-        return parse_result(await self._channel.send("jsonValue"))
+        return parse_result(
+            await self._channel.send(
+                "jsonValue",
+                None,
+            )
+        )
 
 
 def serialize_value(
@@ -145,13 +160,17 @@ def serialize_value(
         return {
             "e": {
                 "m": str(value),
-                "n": (value.name or "")
-                if isinstance(value, Error)
-                else value.__class__.__name__,
-                "s": (value.stack or "")
-                if isinstance(value, Error)
-                else "".join(
-                    traceback.format_exception(type(value), value=value, tb=None)
+                "n": (
+                    (value.name or "")
+                    if isinstance(value, Error)
+                    else value.__class__.__name__
+                ),
+                "s": (
+                    (value.stack or "")
+                    if isinstance(value, Error)
+                    else "".join(
+                        traceback.format_exception(type(value), value=value, tb=None)
+                    )
                 ),
             }
         }
@@ -256,6 +275,56 @@ def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
 
         if "b" in value:
             return value["b"]
+
+        if "ta" in value:
+            encoded_bytes = value["ta"]["b"]
+            decoded_bytes = base64.b64decode(encoded_bytes)
+            array_type = value["ta"]["k"]
+            if array_type == "i8":
+                word_size = 1
+                fmt = "b"
+            elif array_type == "ui8" or array_type == "ui8c":
+                word_size = 1
+                fmt = "B"
+            elif array_type == "i16":
+                word_size = 2
+                fmt = "h"
+            elif array_type == "ui16":
+                word_size = 2
+                fmt = "H"
+            elif array_type == "i32":
+                word_size = 4
+                fmt = "i"
+            elif array_type == "ui32":
+                word_size = 4
+                fmt = "I"
+            elif array_type == "f32":
+                word_size = 4
+                fmt = "f"
+            elif array_type == "f64":
+                word_size = 8
+                fmt = "d"
+            elif array_type == "bi64":
+                word_size = 8
+                fmt = "q"
+            elif array_type == "bui64":
+                word_size = 8
+                fmt = "Q"
+            else:
+                raise ValueError(f"Unsupported array type: {array_type}")
+
+            byte_len = len(decoded_bytes)
+            if byte_len % word_size != 0:
+                raise ValueError(
+                    f"Decoded bytes length {byte_len} is not a multiple of word size {word_size}"
+                )
+
+            if byte_len == 0:
+                return []
+            array_len = byte_len // word_size
+            # "<" denotes little-endian
+            format_string = f"<{array_len}{fmt}"
+            return list(struct.unpack(format_string, decoded_bytes))
     return value
 
 
diff --git a/playwright/_impl/_json_pipe.py b/playwright/_impl/_json_pipe.py
index f76bc7175..41973b8c7 100644
--- a/playwright/_impl/_json_pipe.py
+++ b/playwright/_impl/_json_pipe.py
@@ -33,11 +33,10 @@ def __init__(
         Transport.__init__(self, loop)
         self._stop_requested = False
         self._pipe_channel = pipe_channel
-        self._loop: asyncio.AbstractEventLoop
 
     def request_stop(self) -> None:
         self._stop_requested = True
-        self._pipe_channel.send_no_reply("close", {})
+        self._pipe_channel.send_no_reply("close", None, {})
 
     def dispose(self) -> None:
         self.on_error_future.cancel()
@@ -75,4 +74,4 @@ async def run(self) -> None:
     def send(self, message: Dict) -> None:
         if self._stop_requested:
             raise Error("Playwright connection closed")
-        self._pipe_channel.send_no_reply("send", {"message": message})
+        self._pipe_channel.send_no_reply("send", None, {"message": message})
diff --git a/playwright/_impl/_local_utils.py b/playwright/_impl/_local_utils.py
index 7172ee58a..c2d2d3fca 100644
--- a/playwright/_impl/_local_utils.py
+++ b/playwright/_impl/_local_utils.py
@@ -31,11 +31,11 @@ def __init__(
         }
 
     async def zip(self, params: Dict) -> None:
-        await self._channel.send("zip", params)
+        await self._channel.send("zip", None, params)
 
     async def har_open(self, file: str) -> None:
         params = locals_to_params(locals())
-        await self._channel.send("harOpen", params)
+        await self._channel.send("harOpen", None, params)
 
     async def har_lookup(
         self,
@@ -51,27 +51,28 @@ async def har_lookup(
             params["postData"] = base64.b64encode(params["postData"]).decode()
         return cast(
             HarLookupResult,
-            await self._channel.send_return_as_dict("harLookup", params),
+            await self._channel.send_return_as_dict("harLookup", None, params),
         )
 
     async def har_close(self, harId: str) -> None:
         params = locals_to_params(locals())
-        await self._channel.send("harClose", params)
+        await self._channel.send("harClose", None, params)
 
     async def har_unzip(self, zipFile: str, harFile: str) -> None:
         params = locals_to_params(locals())
-        await self._channel.send("harUnzip", params)
+        await self._channel.send("harUnzip", None, params)
 
     async def tracing_started(self, tracesDir: Optional[str], traceName: str) -> str:
         params = locals_to_params(locals())
-        return await self._channel.send("tracingStarted", params)
+        return await self._channel.send("tracingStarted", None, params)
 
     async def trace_discarded(self, stacks_id: str) -> None:
-        return await self._channel.send("traceDiscarded", {"stacksId": stacks_id})
+        return await self._channel.send("traceDiscarded", None, {"stacksId": stacks_id})
 
     def add_stack_to_tracing_no_reply(self, id: int, frames: List[StackFrame]) -> None:
         self._channel.send_no_reply(
             "addStackToTracingNoReply",
+            None,
             {
                 "callData": {
                     "stack": frames,
diff --git a/playwright/_impl/_locator.py b/playwright/_impl/_locator.py
index 521897978..2e6a7abed 100644
--- a/playwright/_impl/_locator.py
+++ b/playwright/_impl/_locator.py
@@ -14,6 +14,7 @@
 
 import json
 import pathlib
+import re
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -47,7 +48,7 @@
     monotonic_time,
     to_impl,
 )
-from playwright._impl._js_handle import Serializable, parse_value, serialize_argument
+from playwright._impl._js_handle import Serializable
 from playwright._impl._str_utils import (
     escape_for_attribute_selector,
     escape_for_text_selector,
@@ -70,6 +71,7 @@ def __init__(
         has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
         has_not: "Locator" = None,
+        visible: bool = None,
     ) -> None:
         self._frame = frame
         self._selector = selector
@@ -95,6 +97,9 @@ def __init__(
                 raise Error('Inner "has_not" locator must belong to the same frame.')
             self._selector += " >> internal:has-not=" + json.dumps(locator._selector)
 
+        if visible is not None:
+            self._selector += f" >> visible={bool_to_js_bool(visible)}"
+
     def __repr__(self) -> str:
         return f"<Locator frame={self._frame!r} selector={self._selector!r}>"
 
@@ -103,7 +108,7 @@ async def _with_element(
         task: Callable[[ElementHandle, float], Awaitable[T]],
         timeout: float = None,
     ) -> T:
-        timeout = self._frame.page._timeout_settings.timeout(timeout)
+        timeout = self._frame._timeout(timeout)
         deadline = (monotonic_time() + timeout) if timeout else 0
         handle = await self.element_handle(timeout=timeout)
         if not handle:
@@ -151,9 +156,10 @@ async def click(
         force: bool = None,
         noWaitAfter: bool = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
         params = locals_to_params(locals())
-        return await self._frame.click(self._selector, strict=True, **params)
+        return await self._frame._click(self._selector, strict=True, **params)
 
     async def dblclick(
         self,
@@ -165,6 +171,7 @@ async def dblclick(
         force: bool = None,
         noWaitAfter: bool = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
         params = locals_to_params(locals())
         return await self._frame.dblclick(self._selector, strict=True, **params)
@@ -213,7 +220,8 @@ async def clear(
         noWaitAfter: bool = None,
         force: bool = None,
     ) -> None:
-        await self.fill("", timeout=timeout, force=force)
+        params = locals_to_params(locals())
+        await self._frame._fill(self._selector, value="", title="Clear", **params)
 
     def locator(
         self,
@@ -332,12 +340,33 @@ def nth(self, index: int) -> "Locator":
     def content_frame(self) -> "FrameLocator":
         return FrameLocator(self._frame, self._selector)
 
+    def describe(self, description: str) -> "Locator":
+        return Locator(
+            self._frame,
+            f"{self._selector} >> internal:describe={json.dumps(description)}",
+        )
+
+    @property
+    def description(self) -> Optional[str]:
+        try:
+            match = re.search(
+                r' >> internal:describe=("(?:[^"\\]|\\.)*")$', self._selector
+            )
+            if match:
+                description = json.loads(match.group(1))
+                if isinstance(description, str):
+                    return description
+        except (json.JSONDecodeError, ValueError):
+            pass
+        return None
+
     def filter(
         self,
         hasText: Union[str, Pattern[str]] = None,
         hasNotText: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
         hasNot: "Locator" = None,
+        visible: bool = None,
     ) -> "Locator":
         return Locator(
             self._frame,
@@ -346,6 +375,7 @@ def filter(
             has_not_text=hasNotText,
             has=has,
             has_not=hasNot,
+            visible=visible,
         )
 
     def or_(self, locator: "Locator") -> "Locator":
@@ -371,6 +401,7 @@ async def focus(self, timeout: float = None) -> None:
     async def blur(self, timeout: float = None) -> None:
         await self._frame._channel.send(
             "blur",
+            self._frame._timeout,
             {
                 "selector": self._selector,
                 "strict": True,
@@ -400,6 +431,7 @@ async def drag_to(
         trial: bool = None,
         sourcePosition: Position = None,
         targetPosition: Position = None,
+        steps: int = None,
     ) -> None:
         params = locals_to_params(locals())
         del params["target"]
@@ -481,26 +513,24 @@ async def is_editable(self, timeout: float = None) -> bool:
 
     async def is_enabled(self, timeout: float = None) -> bool:
         params = locals_to_params(locals())
-        return await self._frame.is_editable(
+        return await self._frame.is_enabled(
             self._selector,
             strict=True,
             **params,
         )
 
     async def is_hidden(self, timeout: float = None) -> bool:
-        params = locals_to_params(locals())
+        # timeout is deprecated and does nothing
         return await self._frame.is_hidden(
             self._selector,
             strict=True,
-            **params,
         )
 
     async def is_visible(self, timeout: float = None) -> bool:
-        params = locals_to_params(locals())
+        # timeout is deprecated and does nothing
         return await self._frame.is_visible(
             self._selector,
             strict=True,
-            **params,
         )
 
     async def press(
@@ -534,6 +564,16 @@ async def screenshot(
             ),
         )
 
+    async def aria_snapshot(self, timeout: float = None) -> str:
+        return await self._frame._channel.send(
+            "ariaSnapshot",
+            self._frame._timeout,
+            {
+                "selector": self._selector,
+                **locals_to_params(locals()),
+            },
+        )
+
     async def scroll_into_view_if_needed(
         self,
         timeout: float = None,
@@ -696,21 +736,12 @@ async def set_checked(
             )
 
     async def _expect(
-        self, expression: str, options: FrameExpectOptions
+        self,
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
     ) -> FrameExpectResult:
-        if "expectedValue" in options:
-            options["expectedValue"] = serialize_argument(options["expectedValue"])
-        result = await self._frame._channel.send_return_as_dict(
-            "expect",
-            {
-                "selector": self._selector,
-                "expression": expression,
-                **options,
-            },
-        )
-        if result.get("received"):
-            result["received"] = parse_value(result["received"])
-        return result
+        return await self._frame._expect(self._selector, expression, options, title)
 
     async def highlight(self) -> None:
         await self._frame._highlight(self._selector)
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
index 91c2a460c..9f2c29f6e 100644
--- a/playwright/_impl/_network.py
+++ b/playwright/_impl/_network.py
@@ -18,6 +18,7 @@
 import json
 import json as json_utils
 import mimetypes
+import re
 from collections import defaultdict
 from pathlib import Path
 from types import SimpleNamespace
@@ -51,14 +52,21 @@
 )
 from playwright._impl._errors import Error
 from playwright._impl._event_context_manager import EventContextManagerImpl
-from playwright._impl._helper import async_readfile, locals_to_params
+from playwright._impl._helper import (
+    URLMatch,
+    WebSocketRouteHandlerCallback,
+    async_readfile,
+    locals_to_params,
+    url_matches,
+)
+from playwright._impl._str_utils import escape_regex_flags
 from playwright._impl._waiter import Waiter
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._browser_context import BrowserContext
     from playwright._impl._fetch import APIResponse
     from playwright._impl._frame import Frame
-    from playwright._impl._page import Page
+    from playwright._impl._page import Page, Worker
 
 
 class FallbackOverrideParameters(TypedDict, total=False):
@@ -176,6 +184,13 @@ def url(self) -> str:
     def resource_type(self) -> str:
         return self._initializer["resourceType"]
 
+    @property
+    def service_worker(self) -> Optional["Worker"]:
+        return cast(
+            Optional["Worker"],
+            from_nullable_channel(self._initializer.get("serviceWorker")),
+        )
+
     @property
     def method(self) -> str:
         return cast(str, self._fallback_overrides.method or self._initializer["method"])
@@ -184,7 +199,10 @@ async def sizes(self) -> RequestSizes:
         response = await self.response()
         if not response:
             raise Error("Unable to fetch sizes for failed request")
-        return await response._channel.send("sizes")
+        return await response._channel.send(
+            "sizes",
+            None,
+        )
 
     @property
     def post_data(self) -> Optional[str]:
@@ -218,7 +236,12 @@ def post_data_buffer(self) -> Optional[bytes]:
         return None
 
     async def response(self) -> Optional["Response"]:
-        return from_nullable_channel(await self._channel.send("response"))
+        return from_nullable_channel(
+            await self._channel.send(
+                "response",
+                None,
+            )
+        )
 
     @property
     def frame(self) -> "Frame":
@@ -283,7 +306,9 @@ async def _actual_headers(self) -> "RawHeaders":
             return RawHeaders(serialize_headers(override))
         if not self._all_headers_future:
             self._all_headers_future = asyncio.Future()
-            headers = await self._channel.send("rawRequestHeaders")
+            headers = await self._channel.send(
+                "rawRequestHeaders", None, is_internal=True
+            )
             self._all_headers_future.set_result(RawHeaders(headers))
         return await self._all_headers_future
 
@@ -340,9 +365,9 @@ async def abort(self, errorCode: str = None) -> None:
             lambda: self._race_with_page_close(
                 self._channel.send(
                     "abort",
+                    None,
                     {
                         "errorCode": errorCode,
-                        "requestUrl": self.request._initializer["url"],
                     },
                 )
             )
@@ -425,9 +450,8 @@ async def _inner_fulfill(
         if length and "content-length" not in headers:
             headers["content-length"] = str(length)
         params["headers"] = serialize_headers(headers)
-        params["requestUrl"] = self.request._initializer["url"]
 
-        await self._race_with_page_close(self._channel.send("fulfill", params))
+        await self._race_with_page_close(self._channel.send("fulfill", None, params))
 
     async def _handle_route(self, callback: Callable) -> None:
         self._check_not_handled()
@@ -484,48 +508,36 @@ async def continue_(
 
         async def _inner() -> None:
             self.request._apply_fallback_overrides(overrides)
-            await self._internal_continue()
+            await self._inner_continue(False)
 
         return await self._handle_route(_inner)
 
-    def _internal_continue(
-        self, is_internal: bool = False
-    ) -> Coroutine[Any, Any, None]:
-        async def continue_route() -> None:
-            try:
-                params: Dict[str, Any] = {}
-                params["url"] = self.request._fallback_overrides.url
-                params["method"] = self.request._fallback_overrides.method
-                params["headers"] = self.request._fallback_overrides.headers
-                if self.request._fallback_overrides.post_data_buffer is not None:
-                    params["postData"] = base64.b64encode(
-                        self.request._fallback_overrides.post_data_buffer
-                    ).decode()
-                params = locals_to_params(params)
-
-                if "headers" in params:
-                    params["headers"] = serialize_headers(params["headers"])
-                params["requestUrl"] = self.request._initializer["url"]
-                params["isFallback"] = is_internal
-                await self._connection.wrap_api_call(
-                    lambda: self._race_with_page_close(
-                        self._channel.send(
-                            "continue",
-                            params,
-                        )
+    async def _inner_continue(self, is_fallback: bool = False) -> None:
+        options = self.request._fallback_overrides
+        await self._race_with_page_close(
+            self._channel.send(
+                "continue",
+                None,
+                {
+                    "url": options.url,
+                    "method": options.method,
+                    "headers": (
+                        serialize_headers(options.headers) if options.headers else None
                     ),
-                    is_internal,
-                )
-            except Exception as e:
-                if not is_internal:
-                    raise e
-
-        return continue_route()
+                    "postData": (
+                        base64.b64encode(options.post_data_buffer).decode()
+                        if options.post_data_buffer is not None
+                        else None
+                    ),
+                    "isFallback": is_fallback,
+                },
+            )
+        )
 
     async def _redirected_navigation_request(self, url: str) -> None:
         await self._handle_route(
             lambda: self._race_with_page_close(
-                self._channel.send("redirectNavigationRequest", {"url": url})
+                self._channel.send("redirectNavigationRequest", None, {"url": url})
             )
         )
 
@@ -535,7 +547,7 @@ async def _race_with_page_close(self, future: Coroutine) -> None:
         setattr(
             fut,
             "__pw_stack__",
-            getattr(asyncio.current_task(self._loop), "__pw_stack__", inspect.stack()),
+            getattr(asyncio.current_task(self._loop), "__pw_stack__", inspect.stack(0)),
         )
         target_closed_future = self.request._target_closed_future()
         await asyncio.wait(
@@ -548,6 +560,239 @@ async def _race_with_page_close(self, future: Coroutine) -> None:
             await asyncio.gather(fut, return_exceptions=True)
 
 
+def _create_task_and_ignore_exception(
+    loop: asyncio.AbstractEventLoop, coro: Coroutine
+) -> None:
+    async def _ignore_exception() -> None:
+        try:
+            await coro
+        except Exception:
+            pass
+
+    loop.create_task(_ignore_exception())
+
+
+class ServerWebSocketRoute:
+    def __init__(self, ws: "WebSocketRoute"):
+        self._ws = ws
+
+    def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
+        self._ws._on_server_message = handler
+
+    def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
+        self._ws._on_server_close = handler
+
+    def connect_to_server(self) -> None:
+        raise NotImplementedError(
+            "connectToServer must be called on the page-side WebSocketRoute"
+        )
+
+    @property
+    def url(self) -> str:
+        return self._ws._initializer["url"]
+
+    def close(self, code: int = None, reason: str = None) -> None:
+        _create_task_and_ignore_exception(
+            self._ws._loop,
+            self._ws._channel.send(
+                "closeServer",
+                None,
+                {
+                    "code": code,
+                    "reason": reason,
+                    "wasClean": True,
+                },
+            ),
+        )
+
+    def send(self, message: Union[str, bytes]) -> None:
+        if isinstance(message, str):
+            _create_task_and_ignore_exception(
+                self._ws._loop,
+                self._ws._channel.send(
+                    "sendToServer", None, {"message": message, "isBase64": False}
+                ),
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._ws._loop,
+                self._ws._channel.send(
+                    "sendToServer",
+                    None,
+                    {"message": base64.b64encode(message).decode(), "isBase64": True},
+                ),
+            )
+
+
+class WebSocketRoute(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._on_page_message: Optional[Callable[[Union[str, bytes]], Any]] = None
+        self._on_page_close: Optional[Callable[[Optional[int], Optional[str]], Any]] = (
+            None
+        )
+        self._on_server_message: Optional[Callable[[Union[str, bytes]], Any]] = None
+        self._on_server_close: Optional[
+            Callable[[Optional[int], Optional[str]], Any]
+        ] = None
+        self._server = ServerWebSocketRoute(self)
+        self._connected = False
+
+        self._channel.on("messageFromPage", self._channel_message_from_page)
+        self._channel.on("messageFromServer", self._channel_message_from_server)
+        self._channel.on("closePage", self._channel_close_page)
+        self._channel.on("closeServer", self._channel_close_server)
+
+    def _channel_message_from_page(self, event: Dict) -> None:
+        if self._on_page_message:
+            self._on_page_message(
+                base64.b64decode(event["message"])
+                if event["isBase64"]
+                else event["message"]
+            )
+        elif self._connected:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("sendToServer", None, event)
+            )
+
+    def _channel_message_from_server(self, event: Dict) -> None:
+        if self._on_server_message:
+            self._on_server_message(
+                base64.b64decode(event["message"])
+                if event["isBase64"]
+                else event["message"]
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("sendToPage", None, event)
+            )
+
+    def _channel_close_page(self, event: Dict) -> None:
+        if self._on_page_close:
+            self._on_page_close(event["code"], event["reason"])
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("closeServer", None, event)
+            )
+
+    def _channel_close_server(self, event: Dict) -> None:
+        if self._on_server_close:
+            self._on_server_close(event["code"], event["reason"])
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("closePage", None, event)
+            )
+
+    @property
+    def url(self) -> str:
+        return self._initializer["url"]
+
+    async def close(self, code: int = None, reason: str = None) -> None:
+        try:
+            await self._channel.send(
+                "closePage", None, {"code": code, "reason": reason, "wasClean": True}
+            )
+        except Exception:
+            pass
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        if self._connected:
+            raise Error("Already connected to the server")
+        self._connected = True
+        asyncio.create_task(
+            self._channel.send(
+                "connect",
+                None,
+            )
+        )
+        return cast("WebSocketRoute", self._server)
+
+    def send(self, message: Union[str, bytes]) -> None:
+        if isinstance(message, str):
+            _create_task_and_ignore_exception(
+                self._loop,
+                self._channel.send(
+                    "sendToPage", None, {"message": message, "isBase64": False}
+                ),
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._loop,
+                self._channel.send(
+                    "sendToPage",
+                    None,
+                    {
+                        "message": base64.b64encode(message).decode(),
+                        "isBase64": True,
+                    },
+                ),
+            )
+
+    def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
+        self._on_page_message = handler
+
+    def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
+        self._on_page_close = handler
+
+    async def _after_handle(self) -> None:
+        if self._connected:
+            return
+        # Ensure that websocket is "open" and can send messages without an actual server connection.
+        try:
+            await self._channel.send(
+                "ensureOpened",
+                None,
+            )
+        except Exception:
+            pass
+
+
+class WebSocketRouteHandler:
+    def __init__(
+        self,
+        base_url: Optional[str],
+        url: URLMatch,
+        handler: WebSocketRouteHandlerCallback,
+    ):
+        self._base_url = base_url
+        self.url = url
+        self.handler = handler
+
+    @staticmethod
+    def prepare_interception_patterns(
+        handlers: List["WebSocketRouteHandler"],
+    ) -> List[dict]:
+        patterns = []
+        all_urls = False
+        for handler in handlers:
+            if isinstance(handler.url, str):
+                patterns.append({"glob": handler.url})
+            elif isinstance(handler.url, re.Pattern):
+                patterns.append(
+                    {
+                        "regexSource": handler.url.pattern,
+                        "regexFlags": escape_regex_flags(handler.url),
+                    }
+                )
+            else:
+                all_urls = True
+
+        if all_urls:
+            return [{"glob": "**/*"}]
+        return patterns
+
+    def matches(self, ws_url: str) -> bool:
+        return url_matches(self._base_url, ws_url, self.url, True)
+
+    async def handle(self, websocket_route: "WebSocketRoute") -> None:
+        coro_or_future = self.handler(websocket_route)
+        if asyncio.iscoroutine(coro_or_future):
+            await coro_or_future
+        await websocket_route._after_handle()
+
+
 class Response(ChannelOwner):
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
@@ -614,15 +859,27 @@ async def header_values(self, name: str) -> List[str]:
     async def _actual_headers(self) -> "RawHeaders":
         if not self._raw_headers_future:
             self._raw_headers_future = asyncio.Future()
-            headers = cast(HeadersArray, await self._channel.send("rawResponseHeaders"))
+            headers = cast(
+                HeadersArray,
+                await self._channel.send(
+                    "rawResponseHeaders",
+                    None,
+                ),
+            )
             self._raw_headers_future.set_result(RawHeaders(headers))
         return await self._raw_headers_future
 
     async def server_addr(self) -> Optional[RemoteAddr]:
-        return await self._channel.send("serverAddr")
+        return await self._channel.send(
+            "serverAddr",
+            None,
+        )
 
     async def security_details(self) -> Optional[SecurityDetails]:
-        return await self._channel.send("securityDetails")
+        return await self._channel.send(
+            "securityDetails",
+            None,
+        )
 
     async def finished(self) -> None:
         async def on_finished() -> None:
@@ -641,7 +898,10 @@ async def on_finished() -> None:
             await on_finished_task
 
     async def body(self) -> bytes:
-        binary = await self._channel.send("body")
+        binary = await self._channel.send(
+            "body",
+            None,
+        )
         return base64.b64decode(binary)
 
     async def text(self) -> str:
diff --git a/playwright/_impl/_object_factory.py b/playwright/_impl/_object_factory.py
index 2652e41fe..b44009bc3 100644
--- a/playwright/_impl/_object_factory.py
+++ b/playwright/_impl/_object_factory.py
@@ -26,10 +26,15 @@
 from playwright._impl._frame import Frame
 from playwright._impl._js_handle import JSHandle
 from playwright._impl._local_utils import LocalUtils
-from playwright._impl._network import Request, Response, Route, WebSocket
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocket,
+    WebSocketRoute,
+)
 from playwright._impl._page import BindingCall, Page, Worker
 from playwright._impl._playwright import Playwright
-from playwright._impl._selectors import SelectorsOwner
 from playwright._impl._stream import Stream
 from playwright._impl._tracing import Tracing
 from playwright._impl._writable_stream import WritableStream
@@ -88,10 +93,10 @@ def create_remote_object(
         return Tracing(parent, type, guid, initializer)
     if type == "WebSocket":
         return WebSocket(parent, type, guid, initializer)
+    if type == "WebSocketRoute":
+        return WebSocketRoute(parent, type, guid, initializer)
     if type == "Worker":
         return Worker(parent, type, guid, initializer)
     if type == "WritableStream":
         return WritableStream(parent, type, guid, initializer)
-    if type == "Selectors":
-        return SelectorsOwner(parent, type, guid, initializer)
     return DummyObject(parent, type, guid, initializer)
diff --git a/playwright/_impl/_page.py b/playwright/_impl/_page.py
index 88c6da720..1f05a9048 100644
--- a/playwright/_impl/_page.py
+++ b/playwright/_impl/_page.py
@@ -33,7 +33,6 @@
     cast,
 )
 
-from playwright._impl._accessibility import Accessibility
 from playwright._impl._api_structures import (
     AriaRole,
     FilePayload,
@@ -51,7 +50,7 @@
 )
 from playwright._impl._console_message import ConsoleMessage
 from playwright._impl._download import Download
-from playwright._impl._element_handle import ElementHandle
+from playwright._impl._element_handle import ElementHandle, determine_screenshot_type
 from playwright._impl._errors import Error, TargetClosedError, is_target_closed_error
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._file_chooser import FileChooser
@@ -60,6 +59,7 @@
 from playwright._impl._har_router import HarRouter
 from playwright._impl._helper import (
     ColorScheme,
+    Contrast,
     DocumentLoadState,
     ForcedColors,
     HarMode,
@@ -71,14 +71,16 @@
     RouteHandlerCallback,
     TimeoutSettings,
     URLMatch,
-    URLMatcher,
     URLMatchRequest,
     URLMatchResponse,
+    WebSocketRouteHandlerCallback,
     async_readfile,
     async_writefile,
     locals_to_params,
     make_dirs_for_file,
+    parse_error,
     serialize_error,
+    url_matches,
 )
 from playwright._impl._input import Keyboard, Mouse, Touchscreen
 from playwright._impl._js_handle import (
@@ -88,7 +90,14 @@
     parse_result,
     serialize_argument,
 )
-from playwright._impl._network import Request, Response, Route, serialize_headers
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocketRoute,
+    WebSocketRouteHandler,
+    serialize_headers,
+)
 from playwright._impl._video import Video
 from playwright._impl._waiter import Waiter
 
@@ -140,7 +149,6 @@ class Page(ChannelOwner):
         WebSocket="websocket",
         Worker="worker",
     )
-    accessibility: Accessibility
     keyboard: Keyboard
     mouse: Mouse
     touchscreen: Touchscreen
@@ -150,7 +158,6 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._browser_context = cast("BrowserContext", parent)
-        self.accessibility = Accessibility(self._channel)
         self.keyboard = Keyboard(self._channel)
         self.mouse = Mouse(self._channel)
         self.touchscreen = Touchscreen(self._channel)
@@ -163,6 +170,7 @@ def __init__(
         self._workers: List["Worker"] = []
         self._bindings: Dict[str, Any] = {}
         self._routes: List[RouteHandler] = []
+        self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._owned_context: Optional["BrowserContext"] = None
         self._timeout_settings: TimeoutSettings = TimeoutSettings(
             self._browser_context._timeout_settings
@@ -210,7 +218,14 @@ def __init__(
                 self._on_route(from_channel(params["route"]))
             ),
         )
+        self._channel.on(
+            "webSocketRoute",
+            lambda params: self._loop.create_task(
+                self._on_web_socket_route(from_channel(params["webSocketRoute"]))
+            ),
+        )
         self._channel.on("video", lambda params: self._on_video(params))
+        self._channel.on("viewportSizeChanged", self._on_viewport_size_changed)
         self._channel.on(
             "webSocket",
             lambda params: self.emit(
@@ -270,7 +285,7 @@ async def _on_route(self, route: Route) -> None:
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
             # If the page was closed we stall all requests right away.
-            if self._close_was_called or self.context._close_was_called:
+            if self._close_was_called or self.context._closing_or_closed:
                 return
             if not route_handler.matches(route.request.url):
                 continue
@@ -298,6 +313,20 @@ async def _update_interceptor_patterns_ignore_exceptions() -> None:
                 return
         await self._browser_context._on_route(route)
 
+    async def _on_web_socket_route(self, web_socket_route: WebSocketRoute) -> None:
+        route_handler = next(
+            (
+                route_handler
+                for route_handler in self._web_socket_routes
+                if route_handler.matches(web_socket_route.url)
+            ),
+            None,
+        )
+        if route_handler:
+            await route_handler.handle(web_socket_route)
+        else:
+            await self._browser_context._on_web_socket_route(web_socket_route)
+
     def _on_binding(self, binding_call: "BindingCall") -> None:
         func = self._bindings.get(binding_call._initializer["name"])
         if func:
@@ -313,8 +342,6 @@ def _on_close(self) -> None:
         self._is_closed = True
         if self in self._browser_context._pages:
             self._browser_context._pages.remove(self)
-        if self in self._browser_context._background_pages:
-            self._browser_context._background_pages.remove(self)
         self._dispose_har_routers()
         self.emit(Page.Events.Close, self)
 
@@ -333,6 +360,9 @@ def _on_video(self, params: Any) -> None:
         artifact = from_channel(params["artifact"])
         self._force_video()._artifact_ready(artifact)
 
+    def _on_viewport_size_changed(self, params: Any) -> None:
+        self._viewport_size = params["viewportSize"]
+
     @property
     def context(self) -> "BrowserContext":
         return self._browser_context
@@ -351,16 +381,12 @@ def main_frame(self) -> Frame:
         return self._main_frame
 
     def frame(self, name: str = None, url: URLMatch = None) -> Optional[Frame]:
-        matcher = (
-            URLMatcher(self._browser_context._options.get("baseURL"), url)
-            if url
-            else None
-        )
         for frame in self._frames:
             if name and frame.name == name:
                 return frame
-            if url and matcher and matcher.matches(frame.url):
+            if url and url_matches(self._browser_context._base_url, frame.url, url):
                 return frame
+
         return None
 
     @property
@@ -369,13 +395,9 @@ def frames(self) -> List[Frame]:
 
     def set_default_navigation_timeout(self, timeout: float) -> None:
         self._timeout_settings.set_default_navigation_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
-        )
 
     def set_default_timeout(self, timeout: float) -> None:
         self._timeout_settings.set_default_timeout(timeout)
-        self._channel.send_no_reply("setDefaultTimeoutNoReply", dict(timeout=timeout))
 
     async def query_selector(
         self,
@@ -419,12 +441,14 @@ async def is_enabled(
     async def is_hidden(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._main_frame.is_hidden(**locals_to_params(locals()))
+        # timeout is deprecated and does nothing
+        return await self._main_frame.is_hidden(selector=selector, strict=strict)
 
     async def is_visible(
         self, selector: str, strict: bool = None, timeout: float = None
     ) -> bool:
-        return await self._main_frame.is_visible(**locals_to_params(locals()))
+        # timeout is deprecated and does nothing
+        return await self._main_frame.is_visible(selector=selector, strict=strict)
 
     async def dispatch_event(
         self,
@@ -491,12 +515,16 @@ async def expose_binding(
             )
         self._bindings[name] = callback
         await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+            "exposeBinding",
+            None,
+            dict(name=name, needsHandle=handle or False),
         )
 
     async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
         await self._channel.send(
-            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+            "setExtraHTTPHeaders",
+            None,
+            dict(headers=serialize_headers(headers)),
         )
 
     @property
@@ -529,7 +557,11 @@ async def reload(
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("reload", locals_to_params(locals()))
+            await self._channel.send(
+                "reload",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
     async def wait_for_load_state(
@@ -560,7 +592,11 @@ async def go_back(
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("goBack", locals_to_params(locals()))
+            await self._channel.send(
+                "goBack",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
     async def go_forward(
@@ -569,15 +605,23 @@ async def go_forward(
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("goForward", locals_to_params(locals()))
+            await self._channel.send(
+                "goForward",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
+    async def request_gc(self) -> None:
+        await self._channel.send("requestGC", None)
+
     async def emulate_media(
         self,
         media: Literal["null", "print", "screen"] = None,
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
         forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
     ) -> None:
         params = locals_to_params(locals())
         if "media" in params:
@@ -594,18 +638,26 @@ async def emulate_media(
             params["forcedColors"] = (
                 "no-override" if params["forcedColors"] == "null" else forcedColors
             )
-        await self._channel.send("emulateMedia", params)
+        if "contrast" in params:
+            params["contrast"] = (
+                "no-override" if params["contrast"] == "null" else contrast
+            )
+        await self._channel.send("emulateMedia", None, params)
 
     async def set_viewport_size(self, viewportSize: ViewportSize) -> None:
         self._viewport_size = viewportSize
-        await self._channel.send("setViewportSize", locals_to_params(locals()))
+        await self._channel.send(
+            "setViewportSize",
+            None,
+            locals_to_params(locals()),
+        )
 
     @property
     def viewport_size(self) -> Optional[ViewportSize]:
         return self._viewport_size
 
     async def bring_to_front(self) -> None:
-        await self._channel.send("bringToFront")
+        await self._channel.send("bringToFront", None)
 
     async def add_init_script(
         self, script: str = None, path: Union[str, Path] = None
@@ -616,7 +668,7 @@ async def add_init_script(
             )
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=script))
+        await self._channel.send("addInitScript", None, dict(source=script))
 
     async def route(
         self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
@@ -624,7 +676,8 @@ async def route(
         self._routes.insert(
             0,
             RouteHandler(
-                URLMatcher(self._browser_context._options.get("baseURL"), url),
+                self._browser_context._base_url,
+                url,
                 handler,
                 True if self._dispatcher_fiber else False,
                 times,
@@ -638,7 +691,7 @@ async def unroute(
         removed = []
         remaining = []
         for route in self._routes:
-            if route.matcher.match != url or (handler and route.handler != handler):
+            if route.url != url or (handler and route.handler != handler):
                 remaining.append(route)
             else:
                 removed.append(route)
@@ -651,15 +704,23 @@ async def _unroute_internal(
         behavior: Literal["default", "ignoreErrors", "wait"] = None,
     ) -> None:
         self._routes = remaining
-        await self._update_interception_patterns()
-        if behavior is None or behavior == "default":
-            return
-        await asyncio.gather(
-            *map(
-                lambda route: route.stop(behavior),  # type: ignore
-                removed,
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(
+                *map(
+                    lambda route: route.stop(behavior),  # type: ignore
+                    removed,
+                )
             )
+        await self._update_interception_patterns()
+
+    async def route_web_socket(
+        self, url: URLMatch, handler: WebSocketRouteHandlerCallback
+    ) -> None:
+        self._web_socket_routes.insert(
+            0,
+            WebSocketRouteHandler(self._browser_context._base_url, url, handler),
         )
+        await self._update_web_socket_interception_patterns()
 
     def _dispose_har_routers(self) -> None:
         for router in self._har_routers:
@@ -702,7 +763,19 @@ async def route_from_har(
     async def _update_interception_patterns(self) -> None:
         patterns = RouteHandler.prepare_interception_patterns(self._routes)
         await self._channel.send(
-            "setNetworkInterceptionPatterns", {"patterns": patterns}
+            "setNetworkInterceptionPatterns",
+            None,
+            {"patterns": patterns},
+        )
+
+    async def _update_web_socket_interception_patterns(self) -> None:
+        patterns = WebSocketRouteHandler.prepare_interception_patterns(
+            self._web_socket_routes
+        )
+        await self._channel.send(
+            "setWebSocketInterceptionPatterns",
+            None,
+            {"patterns": patterns},
         )
 
     async def screenshot(
@@ -723,6 +796,8 @@ async def screenshot(
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
+            if "type" not in params:
+                params["type"] = determine_screenshot_type(params["path"])
             del params["path"]
         if "mask" in params:
             params["mask"] = list(
@@ -736,7 +811,9 @@ async def screenshot(
                     params["mask"],
                 )
             )
-        encoded_binary = await self._channel.send("screenshot", params)
+        encoded_binary = await self._channel.send(
+            "screenshot", self._timeout_settings.timeout, params
+        )
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
             make_dirs_for_file(path)
@@ -750,7 +827,7 @@ async def close(self, runBeforeUnload: bool = None, reason: str = None) -> None:
         self._close_reason = reason
         self._close_was_called = True
         try:
-            await self._channel.send("close", locals_to_params(locals()))
+            await self._channel.send("close", None, locals_to_params(locals()))
             if self._owned_context:
                 await self._owned_context.close()
         except Exception as e:
@@ -774,7 +851,7 @@ async def click(
         trial: bool = None,
         strict: bool = None,
     ) -> None:
-        return await self._main_frame.click(**locals_to_params(locals()))
+        return await self._main_frame._click(**locals_to_params(locals()))
 
     async def dblclick(
         self,
@@ -937,6 +1014,7 @@ async def drag_and_drop(
         timeout: float = None,
         strict: bool = None,
         trial: bool = None,
+        steps: int = None,
     ) -> None:
         return await self._main_frame.drag_and_drop(**locals_to_params(locals()))
 
@@ -1049,7 +1127,9 @@ async def pause(self) -> None:
         try:
             await asyncio.wait(
                 [
-                    asyncio.create_task(self._browser_context._channel.send("pause")),
+                    asyncio.create_task(
+                        self._browser_context._channel.send("pause", None)
+                    ),
                     self._closed_or_crashed_future,
                 ],
                 return_when=asyncio.FIRST_COMPLETED,
@@ -1081,7 +1161,7 @@ async def pdf(
         params = locals_to_params(locals())
         if "path" in params:
             del params["path"]
-        encoded_binary = await self._channel.send("pdf", params)
+        encoded_binary = await self._channel.send("pdf", None, params)
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
             make_dirs_for_file(path)
@@ -1100,7 +1180,7 @@ def video(
         # Note: we are creating Video object lazily, because we do not know
         # BrowserContextOptions when constructing the page - it is assigned
         # too late during launchPersistentContext.
-        if not self._browser_context._options.get("recordVideo"):
+        if not self._browser_context._videos_dir:
             return None
         return self._force_video()
 
@@ -1184,21 +1264,14 @@ def expect_request(
         urlOrPredicate: URLMatchRequest,
         timeout: float = None,
     ) -> EventContextManagerImpl[Request]:
-        matcher = (
-            None
-            if callable(urlOrPredicate)
-            else URLMatcher(
-                self._browser_context._options.get("baseURL"), urlOrPredicate
-            )
-        )
-        predicate = urlOrPredicate if callable(urlOrPredicate) else None
-
         def my_predicate(request: Request) -> bool:
-            if matcher:
-                return matcher.matches(request.url)
-            if predicate:
-                return predicate(request)
-            return True
+            if not callable(urlOrPredicate):
+                return url_matches(
+                    self._browser_context._base_url,
+                    request.url,
+                    urlOrPredicate,
+                )
+            return urlOrPredicate(request)
 
         trimmed_url = trim_url(urlOrPredicate)
         log_line = f"waiting for request {trimmed_url}" if trimmed_url else None
@@ -1223,21 +1296,14 @@ def expect_response(
         urlOrPredicate: URLMatchResponse,
         timeout: float = None,
     ) -> EventContextManagerImpl[Response]:
-        matcher = (
-            None
-            if callable(urlOrPredicate)
-            else URLMatcher(
-                self._browser_context._options.get("baseURL"), urlOrPredicate
-            )
-        )
-        predicate = urlOrPredicate if callable(urlOrPredicate) else None
-
-        def my_predicate(response: Response) -> bool:
-            if matcher:
-                return matcher.matches(response.url)
-            if predicate:
-                return predicate(response)
-            return True
+        def my_predicate(request: Response) -> bool:
+            if not callable(urlOrPredicate):
+                return url_matches(
+                    self._browser_context._base_url,
+                    request.url,
+                    urlOrPredicate,
+                )
+            return urlOrPredicate(request)
 
         trimmed_url = trim_url(urlOrPredicate)
         log_line = f"waiting for response {trimmed_url}" if trimmed_url else None
@@ -1305,6 +1371,7 @@ async def add_locator_handler(
             return
         uid = await self._channel.send(
             "registerLocatorHandler",
+            None,
             {
                 "selector": locator._selector,
                 "noWaitAfter": noWaitAfter,
@@ -1345,7 +1412,9 @@ def _handler() -> None:
             try:
                 await self._connection.wrap_api_call(
                     lambda: self._channel.send(
-                        "resolveLocatorHandlerNoReply", {"uid": uid, "remove": remove}
+                        "resolveLocatorHandlerNoReply",
+                        None,
+                        {"uid": uid, "remove": remove},
                     ),
                     is_internal=True,
                 )
@@ -1356,16 +1425,38 @@ async def remove_locator_handler(self, locator: "Locator") -> None:
         for uid, data in self._locator_handlers.copy().items():
             if data.locator._equals(locator):
                 del self._locator_handlers[uid]
-                self._channel.send_no_reply("unregisterLocatorHandler", {"uid": uid})
+                self._channel.send_no_reply(
+                    "unregisterLocatorHandler",
+                    None,
+                    {"uid": uid},
+                )
+
+    async def requests(self) -> List[Request]:
+        request_objects = await self._channel.send("requests", None)
+        return [from_channel(r) for r in request_objects]
+
+    async def console_messages(self) -> List[ConsoleMessage]:
+        message_dicts = await self._channel.send("consoleMessages", None)
+        return [
+            ConsoleMessage(
+                {**event, "page": self._channel}, self._loop, self._dispatcher_fiber
+            )
+            for event in message_dicts
+        ]
+
+    async def page_errors(self) -> List[Error]:
+        error_objects = await self._channel.send("pageErrors", None)
+        return [parse_error(error["error"]) for error in error_objects]
 
 
 class Worker(ChannelOwner):
-    Events = SimpleNamespace(Close="close")
+    Events = SimpleNamespace(Close="close", Console="console")
 
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._set_event_to_subscription_mapping({Worker.Events.Console: "console"})
         self._channel.on("close", lambda _: self._on_close())
         self._page: Optional[Page] = None
         self._context: Optional["BrowserContext"] = None
@@ -1388,6 +1479,7 @@ async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -1401,6 +1493,7 @@ async def evaluate_handle(
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -1408,6 +1501,31 @@ async def evaluate_handle(
             )
         )
 
+    def expect_event(
+        self,
+        event: str,
+        predicate: Callable = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl:
+        if timeout is None:
+            if self._page:
+                timeout = self._page._timeout_settings.timeout()
+            elif self._context:
+                timeout = self._context._timeout_settings.timeout()
+            else:
+                timeout = 30000
+        waiter = Waiter(self, f"worker.expect_event({event})")
+        waiter.reject_on_timeout(
+            cast(float, timeout),
+            f'Timeout {timeout}ms exceeded while waiting for event "{event}"',
+        )
+        if event != Worker.Events.Close:
+            waiter.reject_on_event(
+                self, Worker.Events.Close, lambda: TargetClosedError()
+            )
+        waiter.wait_for_event(self, event, predicate)
+        return EventContextManagerImpl(waiter.result())
+
 
 class BindingCall(ChannelOwner):
     def __init__(
@@ -1426,12 +1544,14 @@ async def call(self, func: Callable) -> None:
                 result = func(source, *func_args)
             if inspect.iscoroutine(result):
                 result = await result
-            await self._channel.send("resolve", dict(result=serialize_argument(result)))
+            await self._channel.send(
+                "resolve", None, dict(result=serialize_argument(result))
+            )
         except Exception as e:
             tb = sys.exc_info()[2]
             asyncio.create_task(
                 self._channel.send(
-                    "reject", dict(error=dict(error=serialize_error(e, tb)))
+                    "reject", None, dict(error=dict(error=serialize_error(e, tb)))
                 )
             )
 
diff --git a/playwright/_impl/_path_utils.py b/playwright/_impl/_path_utils.py
index 267a82ab0..b405a0675 100644
--- a/playwright/_impl/_path_utils.py
+++ b/playwright/_impl/_path_utils.py
@@ -14,12 +14,14 @@
 
 import inspect
 from pathlib import Path
+from types import FrameType
+from typing import cast
 
 
 def get_file_dirname() -> Path:
     """Returns the callee (`__file__`) directory name"""
-    frame = inspect.stack()[1]
-    module = inspect.getmodule(frame[0])
+    frame = cast(FrameType, inspect.currentframe()).f_back
+    module = inspect.getmodule(frame)
     assert module
     assert module.__file__
     return Path(module.__file__).parent.absolute()
diff --git a/playwright/_impl/_playwright.py b/playwright/_impl/_playwright.py
index c02e73316..5c0151158 100644
--- a/playwright/_impl/_playwright.py
+++ b/playwright/_impl/_playwright.py
@@ -17,7 +17,7 @@
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._connection import ChannelOwner, from_channel
 from playwright._impl._fetch import APIRequest
-from playwright._impl._selectors import Selectors, SelectorsOwner
+from playwright._impl._selectors import Selectors
 
 
 class Playwright(ChannelOwner):
@@ -41,12 +41,7 @@ def __init__(
         self.webkit._playwright = self
 
         self.selectors = Selectors(self._loop, self._dispatcher_fiber)
-        selectors_owner: SelectorsOwner = from_channel(initializer["selectors"])
-        self.selectors._add_channel(selectors_owner)
 
-        self._connection.on(
-            "close", lambda: self.selectors._remove_channel(selectors_owner)
-        )
         self.devices = self._connection.local_utils.devices
 
     def __getitem__(self, value: str) -> "BrowserType":
@@ -59,10 +54,7 @@ def __getitem__(self, value: str) -> "BrowserType":
         raise ValueError("Invalid browser " + value)
 
     def _set_selectors(self, selectors: Selectors) -> None:
-        selectors_owner = from_channel(self._initializer["selectors"])
-        self.selectors._remove_channel(selectors_owner)
         self.selectors = selectors
-        self.selectors._add_channel(selectors_owner)
 
     async def stop(self) -> None:
         pass
diff --git a/playwright/_impl/_selectors.py b/playwright/_impl/_selectors.py
index cf8af8c06..c3bac78e5 100644
--- a/playwright/_impl/_selectors.py
+++ b/playwright/_impl/_selectors.py
@@ -14,20 +14,21 @@
 
 import asyncio
 from pathlib import Path
-from typing import Any, Dict, List, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
-from playwright._impl._connection import ChannelOwner
+from playwright._impl._browser_context import BrowserContext
 from playwright._impl._errors import Error
 from playwright._impl._helper import async_readfile
-from playwright._impl._locator import set_test_id_attribute_name, test_id_attribute_name
+from playwright._impl._locator import set_test_id_attribute_name
 
 
 class Selectors:
     def __init__(self, loop: asyncio.AbstractEventLoop, dispatcher_fiber: Any) -> None:
         self._loop = loop
-        self._channels: Set[SelectorsOwner] = set()
-        self._registrations: List[Dict] = []
+        self._contexts_for_selectors: Set[BrowserContext] = set()
+        self._selector_engines: List[Dict] = []
         self._dispatcher_fiber = dispatcher_fiber
+        self._test_id_attribute_name: Optional[str] = None
 
     async def register(
         self,
@@ -36,41 +37,31 @@ async def register(
         path: Union[str, Path] = None,
         contentScript: bool = None,
     ) -> None:
+        if any(engine for engine in self._selector_engines if engine["name"] == name):
+            raise Error(
+                f'Selectors.register: "{name}" selector engine has been already registered'
+            )
         if not script and not path:
             raise Error("Either source or path should be specified")
         if path:
             script = (await async_readfile(path)).decode()
-        params: Dict[str, Any] = dict(name=name, source=script)
+        engine: Dict[str, Any] = dict(name=name, source=script)
         if contentScript:
-            params["contentScript"] = True
-        for channel in self._channels:
-            await channel._channel.send("register", params)
-        self._registrations.append(params)
+            engine["contentScript"] = contentScript
+        for context in self._contexts_for_selectors:
+            await context._channel.send(
+                "registerSelectorEngine",
+                None,
+                {"selectorEngine": engine},
+            )
+        self._selector_engines.append(engine)
 
     def set_test_id_attribute(self, attributeName: str) -> None:
         set_test_id_attribute_name(attributeName)
-        for channel in self._channels:
-            channel._channel.send_no_reply(
-                "setTestIdAttributeName", {"testIdAttributeName": attributeName}
-            )
-
-    def _add_channel(self, channel: "SelectorsOwner") -> None:
-        self._channels.add(channel)
-        for params in self._registrations:
-            # This should not fail except for connection closure, but just in case we catch.
-            channel._channel.send_no_reply("register", params)
-            channel._channel.send_no_reply(
+        self._test_id_attribute_name = attributeName
+        for context in self._contexts_for_selectors:
+            context._channel.send_no_reply(
                 "setTestIdAttributeName",
-                {"testIdAttributeName": test_id_attribute_name()},
+                None,
+                {"testIdAttributeName": attributeName},
             )
-
-    def _remove_channel(self, channel: "SelectorsOwner") -> None:
-        if channel in self._channels:
-            self._channels.remove(channel)
-
-
-class SelectorsOwner(ChannelOwner):
-    def __init__(
-        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
-    ) -> None:
-        super().__init__(parent, type, guid, initializer)
diff --git a/playwright/_impl/_set_input_files_helpers.py b/playwright/_impl/_set_input_files_helpers.py
index ababf5fab..65307e0a2 100644
--- a/playwright/_impl/_set_input_files_helpers.py
+++ b/playwright/_impl/_set_input_files_helpers.py
@@ -14,6 +14,7 @@
 import base64
 import collections.abc
 import os
+import stat
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -84,6 +85,7 @@ async def convert_input_files(
             result = await context._connection.wrap_api_call(
                 lambda: context._channel.send_return_as_dict(
                     "createTempFiles",
+                    None,
                     {
                         "rootDirName": (
                             os.path.basename(local_directory)
@@ -138,12 +140,13 @@ async def convert_input_files(
 
 
 def resolve_paths_and_directory_for_input_files(
-    items: Sequence[Union[str, Path]]
+    items: Sequence[Union[str, Path]],
 ) -> Tuple[Optional[List[str]], Optional[str]]:
     local_paths: Optional[List[str]] = None
     local_directory: Optional[str] = None
     for item in items:
-        if os.path.isdir(item):
+        item_stat = os.stat(item)  # Raises FileNotFoundError if doesn't exist
+        if stat.S_ISDIR(item_stat.st_mode):
             if local_directory:
                 raise Error("Multiple directories are not supported")
             local_directory = str(Path(item).resolve())
diff --git a/playwright/_impl/_stream.py b/playwright/_impl/_stream.py
index d27427589..04afa48e1 100644
--- a/playwright/_impl/_stream.py
+++ b/playwright/_impl/_stream.py
@@ -28,7 +28,7 @@ def __init__(
     async def save_as(self, path: Union[str, Path]) -> None:
         file = await self._loop.run_in_executor(None, lambda: open(path, "wb"))
         while True:
-            binary = await self._channel.send("read", {"size": 1024 * 1024})
+            binary = await self._channel.send("read", None, {"size": 1024 * 1024})
             if not binary:
                 break
             await self._loop.run_in_executor(
@@ -39,7 +39,7 @@ async def save_as(self, path: Union[str, Path]) -> None:
     async def read_all(self) -> bytes:
         binary = b""
         while True:
-            chunk = await self._channel.send("read", {"size": 1024 * 1024})
+            chunk = await self._channel.send("read", None, {"size": 1024 * 1024})
             if not chunk:
                 break
             binary += base64.b64decode(chunk)
diff --git a/playwright/_impl/_sync_base.py b/playwright/_impl/_sync_base.py
index f07b947b2..3fef433b5 100644
--- a/playwright/_impl/_sync_base.py
+++ b/playwright/_impl/_sync_base.py
@@ -105,8 +105,8 @@ def _sync(
 
         g_self = greenlet.getcurrent()
         task: asyncio.tasks.Task[Any] = self._loop.create_task(coro)
-        setattr(task, "__pw_stack__", inspect.stack())
-        setattr(task, "__pw_stack_trace__", traceback.extract_stack())
+        setattr(task, "__pw_stack__", inspect.stack(0))
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10))
 
         task.add_done_callback(lambda _: g_self.switch())
         while not task.done():
@@ -114,7 +114,9 @@ def _sync(
         asyncio._set_running_loop(self._loop)
         return task.result()
 
-    def _wrap_handler(self, handler: Any) -> Callable[..., None]:
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
         if callable(handler):
             return mapping.wrap_handler(handler)
         return handler
@@ -140,11 +142,10 @@ def __enter__(self: Self) -> Self:
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
-        exc_val: BaseException,
-        _traceback: TracebackType,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        _traceback: Optional[TracebackType],
     ) -> None:
         self.close()
 
-    def close(self) -> None:
-        ...
+    def close(self) -> None: ...
diff --git a/playwright/_impl/_tracing.py b/playwright/_impl/_tracing.py
index b2d4b5df9..bbc6ec35e 100644
--- a/playwright/_impl/_tracing.py
+++ b/playwright/_impl/_tracing.py
@@ -15,6 +15,7 @@
 import pathlib
 from typing import Dict, Optional, Union, cast
 
+from playwright._impl._api_structures import TracingGroupLocation
 from playwright._impl._artifact import Artifact
 from playwright._impl._connection import ChannelOwner, from_nullable_channel
 from playwright._impl._helper import locals_to_params
@@ -41,18 +42,15 @@ async def start(
         params = locals_to_params(locals())
         self._include_sources = bool(sources)
 
-        async def _inner_start() -> str:
-            await self._channel.send("tracingStart", params)
-            return await self._channel.send(
-                "tracingStartChunk", {"title": title, "name": name}
-            )
-
-        trace_name = await self._connection.wrap_api_call(_inner_start, True)
+        await self._channel.send("tracingStart", None, params)
+        trace_name = await self._channel.send(
+            "tracingStartChunk", None, {"title": title, "name": name}
+        )
         await self._start_collecting_stacks(trace_name)
 
     async def start_chunk(self, title: str = None, name: str = None) -> None:
         params = locals_to_params(locals())
-        trace_name = await self._channel.send("tracingStartChunk", params)
+        trace_name = await self._channel.send("tracingStartChunk", None, params)
         await self._start_collecting_stacks(trace_name)
 
     async def _start_collecting_stacks(self, trace_name: str) -> None:
@@ -64,21 +62,21 @@ async def _start_collecting_stacks(self, trace_name: str) -> None:
         )
 
     async def stop_chunk(self, path: Union[pathlib.Path, str] = None) -> None:
-        await self._connection.wrap_api_call(lambda: self._do_stop_chunk(path), True)
+        await self._do_stop_chunk(path)
 
     async def stop(self, path: Union[pathlib.Path, str] = None) -> None:
-        async def _inner() -> None:
-            await self._do_stop_chunk(path)
-            await self._channel.send("tracingStop")
-
-        await self._connection.wrap_api_call(_inner, True)
+        await self._do_stop_chunk(path)
+        await self._channel.send(
+            "tracingStop",
+            None,
+        )
 
     async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> None:
         self._reset_stack_counter()
 
         if not file_path:
             # Not interested in any artifacts
-            await self._channel.send("tracingStopChunk", {"mode": "discard"})
+            await self._channel.send("tracingStopChunk", None, {"mode": "discard"})
             if self._stacks_id:
                 await self._connection.local_utils.trace_discarded(self._stacks_id)
             return
@@ -87,7 +85,7 @@ async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> No
 
         if is_local:
             result = await self._channel.send_return_as_dict(
-                "tracingStopChunk", {"mode": "entries"}
+                "tracingStopChunk", None, {"mode": "entries"}
             )
             await self._connection.local_utils.zip(
                 {
@@ -102,6 +100,7 @@ async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> No
 
         result = await self._channel.send_return_as_dict(
             "tracingStopChunk",
+            None,
             {
                 "mode": "archive",
             },
@@ -136,3 +135,12 @@ def _reset_stack_counter(self) -> None:
         if self._is_tracing:
             self._is_tracing = False
             self._connection.set_is_tracing(False)
+
+    async def group(self, name: str, location: TracingGroupLocation = None) -> None:
+        await self._channel.send("tracingGroup", None, locals_to_params(locals()))
+
+    async def group_end(self) -> None:
+        await self._channel.send(
+            "tracingGroupEnd",
+            None,
+        )
diff --git a/playwright/_impl/_transport.py b/playwright/_impl/_transport.py
index 124f57823..2ca84d459 100644
--- a/playwright/_impl/_transport.py
+++ b/playwright/_impl/_transport.py
@@ -167,7 +167,7 @@ async def run(self) -> None:
                 break
             await asyncio.sleep(0)
 
-        await self._proc.wait()
+        await self._proc.communicate()
         self._stopped_future.set_result(None)
 
     def send(self, message: Dict) -> None:
diff --git a/playwright/_impl/_waiter.py b/playwright/_impl/_waiter.py
index 7b0ad2cc6..f7ff4b6c1 100644
--- a/playwright/_impl/_waiter.py
+++ b/playwright/_impl/_waiter.py
@@ -38,6 +38,7 @@ def __init__(self, channel_owner: ChannelOwner, event: str) -> None:
     def _wait_for_event_info_before(self, wait_id: str, event: str) -> None:
         self._channel.send_no_reply(
             "waitForEventInfo",
+            None,
             {
                 "info": {
                     "waitId": wait_id,
@@ -51,6 +52,7 @@ def _wait_for_event_info_after(self, wait_id: str, error: Exception = None) -> N
         self._channel._connection.wrap_api_call_sync(
             lambda: self._channel.send_no_reply(
                 "waitForEventInfo",
+                None,
                 {
                     "info": {
                         "waitId": wait_id,
@@ -130,6 +132,7 @@ def log(self, message: str) -> None:
             self._channel._connection.wrap_api_call_sync(
                 lambda: self._channel.send_no_reply(
                     "waitForEventInfo",
+                    None,
                     {
                         "info": {
                             "waitId": self._wait_id,
diff --git a/playwright/_impl/_web_error.py b/playwright/_impl/_web_error.py
index eb1b51948..345f95b8f 100644
--- a/playwright/_impl/_web_error.py
+++ b/playwright/_impl/_web_error.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from asyncio import AbstractEventLoop
-from typing import Optional
+from typing import Any, Optional
 
 from playwright._impl._helper import Error
 from playwright._impl._page import Page
@@ -21,9 +21,14 @@
 
 class WebError:
     def __init__(
-        self, loop: AbstractEventLoop, page: Optional[Page], error: Error
+        self,
+        loop: AbstractEventLoop,
+        dispatcher_fiber: Any,
+        page: Optional[Page],
+        error: Error,
     ) -> None:
         self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
         self._page = page
         self._error = error
 
diff --git a/playwright/_impl/_writable_stream.py b/playwright/_impl/_writable_stream.py
index 702adf153..7d5b7704b 100644
--- a/playwright/_impl/_writable_stream.py
+++ b/playwright/_impl/_writable_stream.py
@@ -37,6 +37,6 @@ async def copy(self, path: Union[str, Path]) -> None:
                 if not data:
                     break
                 await self._channel.send(
-                    "write", {"binary": base64.b64encode(data).decode()}
+                    "write", None, {"binary": base64.b64encode(data).decode()}
                 )
-        await self._channel.send("close")
+        await self._channel.send("close", None)
diff --git a/playwright/async_api/__init__.py b/playwright/async_api/__init__.py
index 554e83927..c05735fcd 100644
--- a/playwright/async_api/__init__.py
+++ b/playwright/async_api/__init__.py
@@ -30,7 +30,6 @@
 from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
 from playwright.async_api._context_manager import PlaywrightContextManager
 from playwright.async_api._generated import (
-    Accessibility,
     APIRequest,
     APIRequestContext,
     APIResponse,
@@ -60,7 +59,9 @@
     Selectors,
     Touchscreen,
     Video,
+    WebError,
     WebSocket,
+    WebSocketRoute,
     Worker,
 )
 
@@ -77,6 +78,7 @@
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
 SourceLocation = playwright._impl._api_structures.SourceLocation
 StorageState = playwright._impl._api_structures.StorageState
+StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
 ViewportSize = playwright._impl._api_structures.ViewportSize
 
 Error = playwright._impl._errors.Error
@@ -107,20 +109,19 @@ def set_options(self, timeout: Optional[float] = _unset) -> None:
             self._timeout = timeout
 
     @overload
-    def __call__(self, actual: Page, message: Optional[str] = None) -> PageAssertions:
-        ...
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
 
     @overload
     def __call__(
         self, actual: Locator, message: Optional[str] = None
-    ) -> LocatorAssertions:
-        ...
+    ) -> LocatorAssertions: ...
 
     @overload
     def __call__(
         self, actual: APIResponse, message: Optional[str] = None
-    ) -> APIResponseAssertions:
-        ...
+    ) -> APIResponseAssertions: ...
 
     def __call__(
         self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
@@ -148,7 +149,6 @@ def __call__(
 __all__ = [
     "expect",
     "async_playwright",
-    "Accessibility",
     "APIRequest",
     "APIRequestContext",
     "APIResponse",
@@ -186,10 +186,13 @@ def __call__(
     "Selectors",
     "SourceLocation",
     "StorageState",
+    "StorageStateCookie",
     "TimeoutError",
     "Touchscreen",
     "Video",
     "ViewportSize",
+    "WebError",
     "WebSocket",
+    "WebSocketRoute",
     "Worker",
 ]
diff --git a/playwright/async_api/_generated.py b/playwright/async_api/_generated.py
index 98bf96cc0..bd694886d 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -18,7 +18,6 @@
 import typing
 from typing import Literal
 
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
 from playwright._impl._api_structures import (
     ClientCertificate,
     Cookie,
@@ -37,6 +36,7 @@
     SetCookieParam,
     SourceLocation,
     StorageState,
+    TracingGroupLocation,
     ViewportSize,
 )
 from playwright._impl._assertions import (
@@ -75,6 +75,7 @@
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
 from playwright._impl._network import WebSocket as WebSocketImpl
+from playwright._impl._network import WebSocketRoute as WebSocketRouteImpl
 from playwright._impl._page import Page as PageImpl
 from playwright._impl._page import Worker as WorkerImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
@@ -85,6 +86,7 @@
 
 
 class Request(AsyncBase):
+
     @property
     def url(self) -> str:
         """Request.url
@@ -111,6 +113,24 @@ def resource_type(self) -> str:
         """
         return mapping.from_maybe_impl(self._impl_obj.resource_type)
 
+    @property
+    def service_worker(self) -> typing.Optional["Worker"]:
+        """Request.service_worker
+
+        The Service `Worker` that is performing the request.
+
+        **Details**
+
+        This method is Chromium only. It's safe to call when using other browsers, but it will always be `null`.
+
+        Requests originated in a Service Worker do not have a `request.frame()` available.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.service_worker)
+
     @property
     def method(self) -> str:
         """Request.method
@@ -385,6 +405,7 @@ async def header_value(self, name: str) -> typing.Optional[str]:
 
 
 class Response(AsyncBase):
+
     @property
     def url(self) -> str:
         """Response.url
@@ -621,6 +642,7 @@ async def json(self) -> typing.Any:
 
 
 class Route(AsyncBase):
+
     @property
     def request(self) -> "Request":
         """Route.request
@@ -669,9 +691,9 @@ async def fulfill(
         headers: typing.Optional[typing.Dict[str, str]] = None,
         body: typing.Optional[typing.Union[str, bytes]] = None,
         json: typing.Optional[typing.Any] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content_type: typing.Optional[str] = None,
-        response: typing.Optional["APIResponse"] = None
+        response: typing.Optional["APIResponse"] = None,
     ) -> None:
         """Route.fulfill
 
@@ -735,7 +757,7 @@ async def fetch(
         post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
         max_redirects: typing.Optional[int] = None,
         max_retries: typing.Optional[int] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> "APIResponse":
         """Route.fetch
 
@@ -804,7 +826,7 @@ async def fallback(
         url: typing.Optional[str] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
     ) -> None:
         """Route.fallback
 
@@ -895,7 +917,7 @@ async def continue_(
         url: typing.Optional[str] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
     ) -> None:
         """Route.continue_
 
@@ -918,13 +940,19 @@ async def handle(route, request):
 
         **Details**
 
-        Note that any overrides such as `url` or `headers` only apply to the request being routed. If this request results
-        in a redirect, overrides will not be applied to the new redirected request. If you want to propagate a header
-        through redirects, use the combination of `route.fetch()` and `route.fulfill()` instead.
+        The `headers` option applies to both the routed request and any redirects it initiates. However, `url`, `method`,
+        and `postData` only apply to the original request and are not carried over to redirected requests.
 
         `route.continue_()` will immediately send the request to the network, other matching handlers won't be
         invoked. Use `route.fallback()` If you want next matching handler in the chain to be invoked.
 
+        **NOTE** Some request headers are **forbidden** and cannot be overridden (for example, `Cookie`, `Host`,
+        `Content-Length` and others, see
+        [this MDN page](https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_request_header) for full list). If an
+        override is provided for a forbidden header, it will be ignored and the original request header will be used.
+
+        To set custom cookies, use `browser_context.add_cookies()`.
+
         Parameters
         ----------
         url : Union[str, None]
@@ -951,6 +979,7 @@ async def handle(route, request):
 
 
 class WebSocket(AsyncBase):
+
     @typing.overload
     def on(
         self,
@@ -1062,7 +1091,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager:
         """WebSocket.expect_event
 
@@ -1095,7 +1124,7 @@ async def wait_for_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """WebSocket.wait_for_event
 
@@ -1142,7 +1171,135 @@ def is_closed(self) -> bool:
 mapping.register(WebSocketImpl, WebSocket)
 
 
+class WebSocketRoute(AsyncBase):
+
+    @property
+    def url(self) -> str:
+        """WebSocketRoute.url
+
+        URL of the WebSocket created in the page.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    async def close(
+        self, *, code: typing.Optional[int] = None, reason: typing.Optional[str] = None
+    ) -> None:
+        """WebSocketRoute.close
+
+        Closes one side of the WebSocket connection.
+
+        Parameters
+        ----------
+        code : Union[int, None]
+            Optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code).
+        reason : Union[str, None]
+            Optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.close(code=code, reason=reason)
+        )
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        """WebSocketRoute.connect_to_server
+
+        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
+          `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 `web_socket_route.on_message()` is
+          called on the original `WebSocketRoute`.
+
+        See examples at the top for more details.
+
+        Returns
+        -------
+        WebSocketRoute
+        """
+
+        return mapping.from_impl(self._impl_obj.connect_to_server())
+
+    def send(self, message: typing.Union[str, bytes]) -> None:
+        """WebSocketRoute.send
+
+        Sends a message to the WebSocket. When called on the original WebSocket, sends the message to the page. When called
+        on the result of `web_socket_route.connect_to_server()`, sends the message to the server. See examples at the
+        top for more details.
+
+        Parameters
+        ----------
+        message : Union[bytes, str]
+            Message to send.
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.send(message=message))
+
+    def on_message(
+        self, handler: typing.Callable[[typing.Union[str, bytes]], typing.Any]
+    ) -> None:
+        """WebSocketRoute.on_message
+
+        This method allows to handle messages that are sent by the WebSocket, either from the page or from the server.
+
+        When called on the original WebSocket route, this method handles messages sent from the page. You can handle this
+        messages by responding to them with `web_socket_route.send()`, forwarding them to the server-side connection
+        returned by `web_socket_route.connect_to_server()` or do something else.
+
+        Once this method is called, messages are not automatically forwarded to the server or to the page - you should do
+        that manually by calling `web_socket_route.send()`. See examples at the top for more details.
+
+        Calling this method again will override the handler with a new one.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[bytes, str]], Any]
+            Function that will handle messages.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_message(handler=self._wrap_handler(handler))
+        )
+
+    def on_close(
+        self,
+        handler: typing.Callable[
+            [typing.Optional[int], typing.Optional[str]], typing.Any
+        ],
+    ) -> None:
+        """WebSocketRoute.on_close
+
+        Allows to handle [`WebSocket.close`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close).
+
+        By default, closing one side of the connection, either in the page or on the server, will close the other side.
+        However, when `web_socket_route.on_close()` handler is set up, the default forwarding of closure is disabled,
+        and handler should take care of it.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[int, None], Union[str, None]], Any]
+            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).
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_close(handler=self._wrap_handler(handler))
+        )
+
+
+mapping.register(WebSocketRouteImpl, WebSocketRoute)
+
+
 class Keyboard(AsyncBase):
+
     async def down(self, key: str) -> None:
         """Keyboard.down
 
@@ -1306,6 +1463,7 @@ async def press(self, key: str, *, delay: typing.Optional[float] = None) -> None
 
 
 class Mouse(AsyncBase):
+
     async def move(
         self, x: float, y: float, *, steps: typing.Optional[int] = None
     ) -> None:
@@ -1320,7 +1478,8 @@ async def move(
         y : float
             Y coordinate relative to the main frame's viewport in CSS pixels.
         steps : Union[int, None]
-            Defaults to 1. Sends intermediate `mousemove` events.
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(await self._impl_obj.move(x=x, y=y, steps=steps))
@@ -1329,7 +1488,7 @@ async def down(
         self,
         *,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.down
 
@@ -1351,7 +1510,7 @@ async def up(
         self,
         *,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.up
 
@@ -1376,7 +1535,7 @@ async def click(
         *,
         delay: typing.Optional[float] = None,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.click
 
@@ -1408,7 +1567,7 @@ async def dblclick(
         y: float,
         *,
         delay: typing.Optional[float] = None,
-        button: typing.Optional[Literal["left", "middle", "right"]] = None
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
     ) -> None:
         """Mouse.dblclick
 
@@ -1457,6 +1616,7 @@ async def wheel(self, delta_x: float, delta_y: float) -> None:
 
 
 class Touchscreen(AsyncBase):
+
     async def tap(self, x: float, y: float) -> None:
         """Touchscreen.tap
 
@@ -1479,6 +1639,7 @@ async def tap(self, x: float, y: float) -> None:
 
 
 class JSHandle(AsyncBase):
+
     async def evaluate(
         self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
@@ -1634,6 +1795,7 @@ async def json_value(self) -> typing.Any:
 
 
 class ElementHandle(JSHandle):
+
     def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
@@ -1882,7 +2044,7 @@ async def hover(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.hover
 
@@ -1942,7 +2104,8 @@ async def click(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """ElementHandle.click
 
@@ -1985,6 +2148,9 @@ async def click(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -1998,6 +2164,7 @@ async def click(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -2013,7 +2180,8 @@ async def dblclick(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """ElementHandle.dblclick
 
@@ -2053,6 +2221,9 @@ async def dblclick(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -2065,6 +2236,7 @@ async def dblclick(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -2079,7 +2251,7 @@ async def select_option(
         ] = None,
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """ElementHandle.select_option
 
@@ -2154,7 +2326,7 @@ async def tap(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.tap
 
@@ -2209,7 +2381,7 @@ async def fill(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.fill
 
@@ -2247,7 +2419,7 @@ async def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """ElementHandle.select_text
 
@@ -2306,7 +2478,7 @@ async def set_input_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.set_input_files
 
@@ -2350,7 +2522,7 @@ async def type(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.type
 
@@ -2387,7 +2559,7 @@ async def press(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.press
 
@@ -2443,7 +2615,7 @@ async def set_checked(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.set_checked
 
@@ -2497,7 +2669,7 @@ async def check(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.check
 
@@ -2549,7 +2721,7 @@ async def uncheck(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.uncheck
 
@@ -2629,7 +2801,7 @@ async def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         animations: typing.Optional[Literal["allow", "disabled"]] = None,
@@ -2637,7 +2809,7 @@ async def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """ElementHandle.screenshot
 
@@ -2684,7 +2856,9 @@ async def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -2850,7 +3024,7 @@ async def wait_for_element_state(
             "disabled", "editable", "enabled", "hidden", "stable", "visible"
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """ElementHandle.wait_for_element_state
 
@@ -2890,7 +3064,7 @@ async def wait_for_selector(
             Literal["attached", "detached", "hidden", "visible"]
         ] = None,
         timeout: typing.Optional[float] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Optional["ElementHandle"]:
         """ElementHandle.wait_for_selector
 
@@ -2947,72 +3121,8 @@ async def wait_for_selector(
 mapping.register(ElementHandleImpl, ElementHandle)
 
 
-class Accessibility(AsyncBase):
-    async def snapshot(
-        self,
-        *,
-        interesting_only: typing.Optional[bool] = None,
-        root: typing.Optional["ElementHandle"] = None
-    ) -> typing.Optional[typing.Dict]:
-        """Accessibility.snapshot
-
-        Captures the current state of the accessibility tree. The returned object represents the root accessible node of
-        the page.
-
-        **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen
-        readers. Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to
-        `false`.
-
-        **Usage**
-
-        An example of dumping the entire accessibility tree:
-
-        ```py
-        snapshot = await page.accessibility.snapshot()
-        print(snapshot)
-        ```
-
-        An example of logging the focused node's name:
-
-        ```py
-        def find_focused_node(node):
-            if node.get(\"focused\"):
-                return node
-            for child in (node.get(\"children\") or []):
-                found_node = find_focused_node(child)
-                if found_node:
-                    return found_node
-            return None
-
-        snapshot = await page.accessibility.snapshot()
-        node = find_focused_node(snapshot)
-        if node:
-            print(node[\"name\"])
-        ```
-
-        Parameters
-        ----------
-        interesting_only : Union[bool, None]
-            Prune uninteresting nodes from the tree. Defaults to `true`.
-        root : Union[ElementHandle, None]
-            The root DOM element for the snapshot. Defaults to the whole page.
-
-        Returns
-        -------
-        Union[Dict, None]
-        """
-
-        return mapping.from_maybe_impl(
-            await self._impl_obj.snapshot(
-                interestingOnly=interesting_only, root=mapping.to_impl(root)
-            )
-        )
-
-
-mapping.register(AccessibilityImpl, Accessibility)
-
-
 class FileChooser(AsyncBase):
+
     @property
     def page(self) -> "Page":
         """FileChooser.page
@@ -3060,7 +3170,7 @@ async def set_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """FileChooser.set_files
 
@@ -3089,6 +3199,7 @@ async def set_files(
 
 
 class Frame(AsyncBase):
+
     @property
     def page(self) -> "Page":
         """Frame.page
@@ -3160,7 +3271,7 @@ async def goto(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        referer: typing.Optional[str] = None
+        referer: typing.Optional[str] = None,
     ) -> typing.Optional["Response"]:
         """Frame.goto
 
@@ -3225,7 +3336,7 @@ def expect_navigation(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Response"]:
         """Frame.expect_navigation
 
@@ -3285,7 +3396,7 @@ async def wait_for_url(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.wait_for_url
 
@@ -3331,7 +3442,7 @@ async def wait_for_load_state(
             Literal["domcontentloaded", "load", "networkidle"]
         ] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.wait_for_load_state
 
@@ -3567,7 +3678,7 @@ async def wait_for_selector(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["ElementHandle"]:
         """Frame.wait_for_selector
 
@@ -3640,7 +3751,7 @@ async def is_checked(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_checked
 
@@ -3674,7 +3785,7 @@ async def is_disabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_disabled
 
@@ -3708,7 +3819,7 @@ async def is_editable(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_editable
 
@@ -3742,7 +3853,7 @@ async def is_enabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_enabled
 
@@ -3772,11 +3883,7 @@ async def is_enabled(
         )
 
     async def is_hidden(
-        self,
-        selector: str,
-        *,
-        strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        self, selector: str, *, strict: typing.Optional[bool] = None
     ) -> bool:
         """Frame.is_hidden
 
@@ -3791,8 +3898,6 @@ async def is_hidden(
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
-        timeout : Union[float, None]
-            Deprecated: This option is ignored. `frame.is_hidden()` does not wait for the element to become hidden and returns immediately.
 
         Returns
         -------
@@ -3800,17 +3905,11 @@ async def is_hidden(
         """
 
         return mapping.from_maybe_impl(
-            await self._impl_obj.is_hidden(
-                selector=selector, strict=strict, timeout=timeout
-            )
+            await self._impl_obj.is_hidden(selector=selector, strict=strict)
         )
 
     async def is_visible(
-        self,
-        selector: str,
-        *,
-        strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        self, selector: str, *, strict: typing.Optional[bool] = None
     ) -> bool:
         """Frame.is_visible
 
@@ -3825,8 +3924,6 @@ async def is_visible(
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
-        timeout : Union[float, None]
-            Deprecated: This option is ignored. `frame.is_visible()` does not wait for the element to become visible and returns immediately.
 
         Returns
         -------
@@ -3834,9 +3931,7 @@ async def is_visible(
         """
 
         return mapping.from_maybe_impl(
-            await self._impl_obj.is_visible(
-                selector=selector, strict=strict, timeout=timeout
-            )
+            await self._impl_obj.is_visible(selector=selector, strict=strict)
         )
 
     async def dispatch_event(
@@ -3846,7 +3941,7 @@ async def dispatch_event(
         event_init: typing.Optional[typing.Dict] = None,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.dispatch_event
 
@@ -3916,7 +4011,7 @@ async def eval_on_selector(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Any:
         """Frame.eval_on_selector
 
@@ -4022,7 +4117,7 @@ async def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Frame.set_content
 
@@ -4070,9 +4165,9 @@ async def add_script_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content: typing.Optional[str] = None,
-        type: typing.Optional[str] = None
+        type: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Frame.add_script_tag
 
@@ -4108,8 +4203,8 @@ async def add_style_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content: typing.Optional[str] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Frame.add_style_tag
 
@@ -4152,7 +4247,7 @@ async def click(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.click
 
@@ -4200,7 +4295,9 @@ async def click(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4233,7 +4330,7 @@ async def dblclick(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.dblclick
 
@@ -4279,7 +4376,9 @@ async def dblclick(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4309,7 +4408,7 @@ async def tap(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.tap
 
@@ -4350,7 +4449,9 @@ async def tap(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4374,7 +4475,7 @@ async def fill(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Frame.fill
 
@@ -4424,10 +4525,10 @@ def locator(
         self,
         selector: str,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Frame.locator
 
@@ -4485,7 +4586,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_alt_text
 
@@ -4522,7 +4623,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_label
 
@@ -4563,7 +4664,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_placeholder
 
@@ -4692,10 +4793,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_role
 
@@ -4749,6 +4850,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -4842,7 +4944,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_text
 
@@ -4906,7 +5008,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_title
 
@@ -4974,7 +5076,7 @@ async def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.focus
 
@@ -5005,7 +5107,7 @@ async def text_content(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Frame.text_content
 
@@ -5039,7 +5141,7 @@ async def inner_text(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.inner_text
 
@@ -5073,7 +5175,7 @@ async def inner_html(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.inner_html
 
@@ -5108,7 +5210,7 @@ async def get_attribute(
         name: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Frame.get_attribute
 
@@ -5151,7 +5253,7 @@ async def hover(
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.hover
 
@@ -5190,7 +5292,9 @@ async def hover(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -5217,7 +5321,8 @@ async def drag_and_drop(
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Frame.drag_and_drop
 
@@ -5249,6 +5354,9 @@ async def drag_and_drop(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -5262,6 +5370,7 @@ async def drag_and_drop(
                 strict=strict,
                 timeout=timeout,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -5278,7 +5387,7 @@ async def select_option(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Frame.select_option
 
@@ -5355,7 +5464,7 @@ async def input_value(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.input_value
 
@@ -5401,7 +5510,7 @@ async def set_input_files(
         *,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.set_input_files
 
@@ -5448,7 +5557,7 @@ async def type(
         delay: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.type
 
@@ -5498,7 +5607,7 @@ async def press(
         delay: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.press
 
@@ -5564,7 +5673,7 @@ async def check(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.check
 
@@ -5626,7 +5735,7 @@ async def uncheck(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.uncheck
 
@@ -5703,7 +5812,7 @@ async def wait_for_function(
         *,
         arg: typing.Optional[typing.Any] = None,
         timeout: typing.Optional[float] = None,
-        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
     ) -> "JSHandle":
         """Frame.wait_for_function
 
@@ -5790,7 +5899,7 @@ async def set_checked(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.set_checked
 
@@ -5851,6 +5960,7 @@ async def set_checked(
 
 
 class FrameLocator(AsyncBase):
+
     @property
     def first(self) -> "FrameLocator":
         """FrameLocator.first
@@ -5889,7 +5999,7 @@ def owner(self) -> "Locator":
         **Usage**
 
         ```py
-        frame_locator = page.frame_locator(\"iframe[name=\\\"embedded\\\"]\")
+        frame_locator = page.locator(\"iframe[name=\\\"embedded\\\"]\").content_frame
         # ...
         locator = frame_locator.owner
         await expect(locator).to_be_visible()
@@ -5905,10 +6015,10 @@ def locator(
         self,
         selector_or_locator: typing.Union["Locator", str],
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """FrameLocator.locator
 
@@ -5963,7 +6073,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_alt_text
 
@@ -6000,7 +6110,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_label
 
@@ -6041,7 +6151,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_placeholder
 
@@ -6170,10 +6280,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_role
 
@@ -6227,6 +6337,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -6320,7 +6431,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_text
 
@@ -6384,7 +6495,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_title
 
@@ -6458,6 +6569,8 @@ def nth(self, index: int) -> "FrameLocator":
 
 
 class Worker(AsyncBase):
+
+    @typing.overload
     def on(
         self,
         event: Literal["close"],
@@ -6466,8 +6579,27 @@ def on(
         """
         Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
         terminated."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
         return super().on(event=event, f=f)
 
+    @typing.overload
     def once(
         self,
         event: Literal["close"],
@@ -6476,6 +6608,24 @@ def once(
         """
         Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
         terminated."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
         return super().once(event=event, f=f)
 
     @property
@@ -6553,18 +6703,60 @@ async def evaluate_handle(
             )
         )
 
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager:
+        """Worker.expect_event
 
-mapping.register(WorkerImpl, Worker)
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
 
+        **Usage**
 
-class Selectors(AsyncBase):
-    async def register(
+        ```py
+        async with worker.expect_event(\"console\") as event_info:
+            await worker.evaluate(\"console.log(42)\")
+        message = await event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            Maximum time to wait for in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The
+            default value can be changed by using the `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_event(
+                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+            ).future
+        )
+
+
+mapping.register(WorkerImpl, Worker)
+
+
+class Selectors(AsyncBase):
+
+    async def register(
         self,
         name: str,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content_script: typing.Optional[bool] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_script: typing.Optional[bool] = None,
     ) -> None:
         """Selectors.register
 
@@ -6655,10 +6847,11 @@ def set_test_id_attribute(self, attribute_name: str) -> None:
 
 
 class Clock(AsyncBase):
+
     async def install(
         self,
         *,
-        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
     ) -> None:
         """Clock.install
 
@@ -6725,6 +6918,18 @@ async def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> N
         await page.clock.pause_at(\"2020-02-02\")
         ```
 
+        For best results, install the clock before navigating the page and set it to a time slightly before the intended
+        test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck.
+        Once the page has fully loaded, you can safely use `clock.pause_at()` to pause the clock.
+
+        ```py
+        # Initialize clock with some time before the test time and let the page load
+        # naturally. `Date.now` will progress as the timers fire.
+        await page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        await page.goto(\"http://localhost:3333\")
+        await page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
         Parameters
         ----------
         time : Union[datetime.datetime, float, str]
@@ -6769,6 +6974,9 @@ async def set_fixed_time(
 
         Makes `Date.now` and `new Date()` return fixed fake time at all times, keeps all the timers running.
 
+        Use this method for simple scenarios where you only need to test with a predefined time. For more advanced
+        scenarios, use `clock.install()` instead. Read docs on [clock emulation](https://playwright.dev/python/docs/clock) to learn more.
+
         **Usage**
 
         ```py
@@ -6790,7 +6998,8 @@ async def set_system_time(
     ) -> None:
         """Clock.set_system_time
 
-        Sets current system time but does not trigger any timers.
+        Sets system time, but does not trigger any timers. Use this to test how the web page reacts to a time shift, for
+        example switching from summer to winter time, or changing time zones.
 
         **Usage**
 
@@ -6813,17 +7022,36 @@ async def set_system_time(
 
 
 class ConsoleMessage(AsyncBase):
+
     @property
-    def type(self) -> str:
+    def type(
+        self,
+    ) -> typing.Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
         """ConsoleMessage.type
 
-        One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-        `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`,
-        `'profileEnd'`, `'count'`, `'timeEnd'`.
-
         Returns
         -------
-        str
+        Union["assert", "clear", "count", "debug", "dir", "dirxml", "endGroup", "error", "info", "log", "profile", "profileEnd", "startGroup", "startGroupCollapsed", "table", "time", "timeEnd", "trace", "warning"]
         """
         return mapping.from_maybe_impl(self._impl_obj.type)
 
@@ -6873,11 +7101,25 @@ def page(self) -> typing.Optional["Page"]:
         """
         return mapping.from_impl_nullable(self._impl_obj.page)
 
+    @property
+    def worker(self) -> typing.Optional["Worker"]:
+        """ConsoleMessage.worker
+
+        The web worker or service worker that produced this console message, if any. Note that console messages from web
+        workers also have non-null `console_message.page()`.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.worker)
+
 
 mapping.register(ConsoleMessageImpl, ConsoleMessage)
 
 
 class Dialog(AsyncBase):
+
     @property
     def type(self) -> str:
         """Dialog.type
@@ -6954,6 +7196,7 @@ async def dismiss(self) -> None:
 
 
 class Download(AsyncBase):
+
     @property
     def page(self) -> "Page":
         """Download.page
@@ -7063,6 +7306,7 @@ async def cancel(self) -> None:
 
 
 class Video(AsyncBase):
+
     async def path(self) -> pathlib.Path:
         """Video.path
 
@@ -7103,6 +7347,7 @@ async def delete(self) -> None:
 
 
 class Page(AsyncContextManager):
+
     @typing.overload
     def on(
         self,
@@ -7643,16 +7888,6 @@ def once(
     ) -> None:
         return super().once(event=event, f=f)
 
-    @property
-    def accessibility(self) -> "Accessibility":
-        """Page.accessibility
-
-        Returns
-        -------
-        Accessibility
-        """
-        return mapping.from_impl(self._impl_obj.accessibility)
-
     @property
     def keyboard(self) -> "Keyboard":
         """Page.keyboard
@@ -7810,7 +8045,7 @@ def frame(
         *,
         url: typing.Optional[
             typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Frame"]:
         """Page.frame
 
@@ -7873,7 +8108,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -7933,7 +8168,7 @@ async def wait_for_selector(
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
         ] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Optional["ElementHandle"]:
         """Page.wait_for_selector
 
@@ -8006,7 +8241,7 @@ async def is_checked(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_checked
 
@@ -8040,7 +8275,7 @@ async def is_disabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_disabled
 
@@ -8074,7 +8309,7 @@ async def is_editable(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_editable
 
@@ -8108,7 +8343,7 @@ async def is_enabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_enabled
 
@@ -8142,7 +8377,7 @@ async def is_hidden(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_hidden
 
@@ -8176,7 +8411,7 @@ async def is_visible(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_visible
 
@@ -8212,7 +8447,7 @@ async def dispatch_event(
         event_init: typing.Optional[typing.Dict] = None,
         *,
         timeout: typing.Optional[float] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.dispatch_event
 
@@ -8394,7 +8629,7 @@ async def eval_on_selector(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Any:
         """Page.eval_on_selector
 
@@ -8481,9 +8716,9 @@ async def add_script_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content: typing.Optional[str] = None,
-        type: typing.Optional[str] = None
+        type: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Page.add_script_tag
 
@@ -8518,8 +8753,8 @@ async def add_style_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content: typing.Optional[str] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Page.add_style_tag
 
@@ -8612,7 +8847,7 @@ async def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
+        handle: typing.Optional[bool] = None,
     ) -> None:
         """Page.expose_binding
 
@@ -8714,7 +8949,7 @@ async def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Page.set_content
 
@@ -8754,7 +8989,7 @@ async def goto(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        referer: typing.Optional[str] = None
+        referer: typing.Optional[str] = None,
     ) -> typing.Optional["Response"]:
         """Page.goto
 
@@ -8818,7 +9053,7 @@ async def reload(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.reload
 
@@ -8857,7 +9092,7 @@ async def wait_for_load_state(
             Literal["domcontentloaded", "load", "networkidle"]
         ] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.wait_for_load_state
 
@@ -8913,7 +9148,7 @@ async def wait_for_url(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.wait_for_url
 
@@ -8958,7 +9193,7 @@ async def wait_for_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """Page.wait_for_event
 
@@ -8995,7 +9230,7 @@ async def go_back(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.go_back
 
@@ -9035,7 +9270,7 @@ async def go_forward(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.go_forward
 
@@ -9069,6 +9304,28 @@ async def go_forward(
             await self._impl_obj.go_forward(timeout=timeout, waitUntil=wait_until)
         )
 
+    async def request_gc(self) -> None:
+        """Page.request_gc
+
+        Request the page to perform garbage collection. Note that there is no guarantee that all unreachable objects will
+        be collected.
+
+        This is useful to help detect memory leaks. For example, if your page has a large object `'suspect'` that might be
+        leaked, you can check that it does not leak by using a
+        [`WeakRef`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef).
+
+        ```py
+        # 1. In your page, save a WeakRef for the \"suspect\".
+        await page.evaluate(\"globalThis.suspectWeakRef = new WeakRef(suspect)\")
+        # 2. Request garbage collection.
+        await page.request_gc()
+        # 3. Check that weak ref does not deref to the original object.
+        assert await page.evaluate(\"!globalThis.suspectWeakRef.deref()\")
+        ```
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.request_gc())
+
     async def emulate_media(
         self,
         *,
@@ -9079,7 +9336,8 @@ async def emulate_media(
         reduced_motion: typing.Optional[
             Literal["no-preference", "null", "reduce"]
         ] = None,
-        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
     ) -> None:
         """Page.emulate_media
 
@@ -9113,8 +9371,6 @@ async def emulate_media(
         # → True
         await page.evaluate(\"matchMedia('(prefers-color-scheme: light)').matches\")
         # → False
-        await page.evaluate(\"matchMedia('(prefers-color-scheme: no-preference)').matches\")
-        # → False
         ```
 
         Parameters
@@ -9123,12 +9379,14 @@ async def emulate_media(
             Changes the CSS media type of the page. The only allowed values are `'Screen'`, `'Print'` and `'Null'`. Passing
             `'Null'` disables CSS media emulation.
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`.
-            Passing `'Null'` disables color scheme emulation.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. Passing `'Null'` disables color scheme emulation.
+            `'no-preference'` is deprecated.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. Passing
             `null` disables reduced motion emulation.
         forced_colors : Union["active", "none", "null", None]
+        contrast : Union["more", "no-preference", "null", None]
         """
 
         return mapping.from_maybe_impl(
@@ -9137,6 +9395,7 @@ async def emulate_media(
                 colorScheme=color_scheme,
                 reducedMotion=reduced_motion,
                 forcedColors=forced_colors,
+                contrast=contrast,
             )
         )
 
@@ -9180,7 +9439,7 @@ async def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> None:
         """Page.add_init_script
 
@@ -9225,7 +9484,7 @@ async def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """Page.route
 
@@ -9238,7 +9497,7 @@ async def route(
 
         **NOTE** `page.route()` will not intercept requests intercepted by Service Worker. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         **NOTE** `page.route()` will not intercept the first request of a popup page. Use
         `browser_context.route()` instead.
@@ -9285,8 +9544,8 @@ async def handle_route(route: Route):
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a `baseURL` via the context
-            options was provided and the passed URL is a path, it gets merged via the
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
             handler function to route the request.
@@ -9331,10 +9590,53 @@ async def unroute(
             )
         )
 
+    async def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """Page.route_web_socket
+
+        This method allows to modify websocket connections that are made by the page.
+
+        Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this
+        method before navigating the page.
+
+        **Usage**
+
+        Below is an example of a simple mock that responds to a single message. See `WebSocketRoute` for more details and
+        examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"request\":
+            ws.send(\"response\")
+
+        def handler(ws: WebSocketRoute):
+          ws.on_message(lambda message: message_handler(ws, message))
+
+        await page.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_web_socket(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
     async def unroute_all(
         self,
         *,
-        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
     ) -> None:
         """Page.unroute_all
 
@@ -9359,11 +9661,11 @@ async def route_from_har(
         self,
         har: typing.Union[pathlib.Path, str],
         *,
-        url: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         not_found: typing.Optional[Literal["abort", "fallback"]] = None,
         update: typing.Optional[bool] = None,
         update_content: typing.Optional[Literal["attach", "embed"]] = None,
-        update_mode: typing.Optional[Literal["full", "minimal"]] = None
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
     ) -> None:
         """Page.route_from_har
 
@@ -9372,7 +9674,7 @@ async def route_from_har(
 
         Playwright will not serve requests intercepted by Service Worker from the HAR file. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         Parameters
         ----------
@@ -9415,7 +9717,7 @@ async def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         full_page: typing.Optional[bool] = None,
@@ -9425,7 +9727,7 @@ async def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """Page.screenshot
 
@@ -9470,7 +9772,9 @@ async def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -9518,7 +9822,7 @@ async def close(
         self,
         *,
         run_before_unload: typing.Optional[bool] = None,
-        reason: typing.Optional[str] = None
+        reason: typing.Optional[str] = None,
     ) -> None:
         """Page.close
 
@@ -9570,7 +9874,7 @@ async def click(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         trial: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.click
 
@@ -9615,7 +9919,9 @@ async def click(
             Deprecated: This option will default to `true` in the future.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
@@ -9651,7 +9957,7 @@ async def dblclick(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.dblclick
 
@@ -9696,7 +10002,9 @@ async def dblclick(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -9726,7 +10034,7 @@ async def tap(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.tap
 
@@ -9767,7 +10075,9 @@ async def tap(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -9791,7 +10101,7 @@ async def fill(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Page.fill
 
@@ -9841,10 +10151,10 @@ def locator(
         self,
         selector: str,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Page.locator
 
@@ -9900,7 +10210,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_alt_text
 
@@ -9937,7 +10247,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_label
 
@@ -9978,7 +10288,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_placeholder
 
@@ -10107,10 +10417,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_role
 
@@ -10164,6 +10474,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -10257,7 +10568,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_text
 
@@ -10321,7 +10632,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_title
 
@@ -10389,7 +10700,7 @@ async def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.focus
 
@@ -10420,7 +10731,7 @@ async def text_content(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Page.text_content
 
@@ -10454,7 +10765,7 @@ async def inner_text(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.inner_text
 
@@ -10488,7 +10799,7 @@ async def inner_html(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.inner_html
 
@@ -10523,7 +10834,7 @@ async def get_attribute(
         name: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Page.get_attribute
 
@@ -10566,7 +10877,7 @@ async def hover(
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.hover
 
@@ -10605,7 +10916,9 @@ async def hover(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -10632,7 +10945,8 @@ async def drag_and_drop(
         no_wait_after: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Page.drag_and_drop
 
@@ -10680,6 +10994,9 @@ async def drag_and_drop(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -10693,6 +11010,7 @@ async def drag_and_drop(
                 timeout=timeout,
                 strict=strict,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -10709,7 +11027,7 @@ async def select_option(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Page.select_option
 
@@ -10787,7 +11105,7 @@ async def input_value(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.input_value
 
@@ -10833,7 +11151,7 @@ async def set_input_files(
         *,
         timeout: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Page.set_input_files
 
@@ -10881,7 +11199,7 @@ async def type(
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.type
 
@@ -10931,7 +11249,7 @@ async def press(
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.press
 
@@ -11013,7 +11331,7 @@ async def check(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.check
 
@@ -11075,7 +11393,7 @@ async def uncheck(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.uncheck
 
@@ -11159,7 +11477,7 @@ async def wait_for_function(
         *,
         arg: typing.Optional[typing.Any] = None,
         timeout: typing.Optional[float] = None,
-        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
     ) -> "JSHandle":
         """Page.wait_for_function
 
@@ -11227,14 +11545,13 @@ async def main():
     async def pause(self) -> None:
         """Page.pause
 
-        Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume'
-        button in the page overlay or to call `playwright.resume()` in the DevTools console.
+        Pauses script execution. Playwright will stop executing the script and wait for the user to either press the
+        'Resume' button in the page overlay or to call `playwright.resume()` in the DevTools console.
 
         User can inspect selectors or perform manual steps while paused. Resume will continue running the original script
         from the place it was paused.
 
-        **NOTE** This method requires Playwright to be started in a headed mode, with a falsy `headless` value in the
-        `browser_type.launch()`.
+        **NOTE** This method requires Playwright to be started in a headed mode, with a falsy `headless` option.
         """
 
         return mapping.from_maybe_impl(await self._impl_obj.pause())
@@ -11254,16 +11571,14 @@ async def pdf(
         height: typing.Optional[typing.Union[str, float]] = None,
         prefer_css_page_size: typing.Optional[bool] = None,
         margin: typing.Optional[PdfMargins] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         outline: typing.Optional[bool] = None,
-        tagged: typing.Optional[bool] = None
+        tagged: typing.Optional[bool] = None,
     ) -> bytes:
         """Page.pdf
 
         Returns the PDF buffer.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
-
         `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
         `page.emulate_media()` before calling `page.pdf()`:
 
@@ -11380,7 +11695,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager:
         """Page.expect_event
 
@@ -11420,7 +11735,7 @@ def expect_console_message(
         self,
         predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["ConsoleMessage"]:
         """Page.expect_console_message
 
@@ -11451,7 +11766,7 @@ def expect_download(
         self,
         predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Download"]:
         """Page.expect_download
 
@@ -11482,7 +11797,7 @@ def expect_file_chooser(
         self,
         predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["FileChooser"]:
         """Page.expect_file_chooser
 
@@ -11518,7 +11833,7 @@ def expect_navigation(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Response"]:
         """Page.expect_navigation
 
@@ -11577,7 +11892,7 @@ def expect_popup(
         self,
         predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Page"]:
         """Page.expect_popup
 
@@ -11610,7 +11925,7 @@ def expect_request(
             str, typing.Pattern[str], typing.Callable[["Request"], bool]
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Request"]:
         """Page.expect_request
 
@@ -11655,7 +11970,7 @@ def expect_request_finished(
         self,
         predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Request"]:
         """Page.expect_request_finished
 
@@ -11688,7 +12003,7 @@ def expect_response(
             str, typing.Pattern[str], typing.Callable[["Response"], bool]
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Response"]:
         """Page.expect_response
 
@@ -11735,7 +12050,7 @@ def expect_websocket(
         self,
         predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["WebSocket"]:
         """Page.expect_websocket
 
@@ -11766,7 +12081,7 @@ def expect_worker(
         self,
         predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Worker"]:
         """Page.expect_worker
 
@@ -11803,7 +12118,7 @@ async def set_checked(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.set_checked
 
@@ -11867,7 +12182,7 @@ async def add_locator_handler(
         ],
         *,
         no_wait_after: typing.Optional[bool] = None,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """Page.add_locator_handler
 
@@ -11895,13 +12210,16 @@ async def add_locator_handler(
 
         **NOTE** Running the handler will alter your page state mid-test. For example it will change the currently focused
         element and move the mouse. Make sure that actions that run after the handler are self-contained and do not rely on
-        the focus and mouse state being unchanged. <br /> <br /> For example, consider a test that calls
-        `locator.focus()` followed by `keyboard.press()`. If your handler clicks a button between these two
-        actions, the focused element most likely will be wrong, and key press will happen on the unexpected element. Use
-        `locator.press()` instead to avoid this problem. <br /> <br /> Another example is a series of mouse
-        actions, where `mouse.move()` is followed by `mouse.down()`. Again, when the handler runs between
-        these two actions, the mouse position will be wrong during the mouse down. Prefer self-contained actions like
-        `locator.click()` that do not rely on the state being unchanged by a handler.
+        the focus and mouse state being unchanged.
+
+        For example, consider a test that calls `locator.focus()` followed by `keyboard.press()`. If your
+        handler clicks a button between these two actions, the focused element most likely will be wrong, and key press
+        will happen on the unexpected element. Use `locator.press()` instead to avoid this problem.
+
+        Another example is a series of mouse actions, where `mouse.move()` is followed by `mouse.down()`.
+        Again, when the handler runs between these two actions, the mouse position will be wrong during the mouse down.
+        Prefer self-contained actions like `locator.click()` that do not rely on the state being unchanged by a
+        handler.
 
         **Usage**
 
@@ -11994,11 +12312,55 @@ async def remove_locator_handler(self, locator: "Locator") -> None:
             await self._impl_obj.remove_locator_handler(locator=locator._impl_obj)
         )
 
+    async def requests(self) -> typing.List["Request"]:
+        """Page.requests
+
+        Returns up to (currently) 100 last network request from this page. See `page.on('request')` for more details.
+
+        Returned requests should be accessed immediately, otherwise they might be collected to prevent unbounded memory
+        growth as new requests come in. Once collected, retrieving most information about the request is impossible.
+
+        Note that requests reported through the `page.on('request')` request are not collected, so there is a trade off
+        between efficient memory usage with `page.requests()` and the amount of available information reported
+        through `page.on('request')`.
+
+        Returns
+        -------
+        List[Request]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.requests())
+
+    async def console_messages(self) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Returns
+        -------
+        List[ConsoleMessage]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.console_messages())
+
+    async def page_errors(self) -> typing.List["Error"]:
+        """Page.page_errors
+
+        Returns up to (currently) 200 last page errors from this page. See `page.on('page_error')` for more details.
+
+        Returns
+        -------
+        List[Error]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.page_errors())
+
 
 mapping.register(PageImpl, Page)
 
 
 class WebError(AsyncBase):
+
     @property
     def page(self) -> typing.Optional["Page"]:
         """WebError.page
@@ -12028,6 +12390,7 @@ def error(self) -> "Error":
 
 
 class BrowserContext(AsyncContextManager):
+
     @typing.overload
     def on(
         self,
@@ -12035,13 +12398,7 @@ def on(
         f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         """
-        **NOTE** Only works with Chromium browser's persistent context.
-
-        Emitted when new background page is created in the context.
-
-        ```py
-        background_page = await context.wait_for_event(\"backgroundpage\")
-        ```"""
+        This event is not emitted."""
 
     @typing.overload
     def on(
@@ -12215,13 +12572,7 @@ def once(
         f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         """
-        **NOTE** Only works with Chromium browser's persistent context.
-
-        Emitted when new background page is created in the context.
-
-        ```py
-        background_page = await context.wait_for_event(\"backgroundpage\")
-        ```"""
+        This event is not emitted."""
 
     @typing.overload
     def once(
@@ -12404,7 +12755,8 @@ def pages(self) -> typing.List["Page"]:
     def browser(self) -> typing.Optional["Browser"]:
         """BrowserContext.browser
 
-        Returns the browser instance of the context. If it was launched as a persistent context null gets returned.
+        Gets the browser instance that owns the context. Returns `null` if the context is created outside of normal
+        browser, e.g. Android or Electron.
 
         Returns
         -------
@@ -12416,9 +12768,7 @@ def browser(self) -> typing.Optional["Browser"]:
     def background_pages(self) -> typing.List["Page"]:
         """BrowserContext.background_pages
 
-        **NOTE** Background pages are only supported on Chromium-based browsers.
-
-        All existing background pages in the context.
+        Returns an empty list.
 
         Returns
         -------
@@ -12510,7 +12860,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -12544,7 +12894,7 @@ async def cookies(
 
         Returns
         -------
-        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}]
+        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"], partitionKey: Union[str, None]}]
         """
 
         return mapping.from_impl_list(
@@ -12565,7 +12915,7 @@ async def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
 
         Parameters
         ----------
-        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None]}]
+        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None], partitionKey: Union[str, None]}]
         """
 
         return mapping.from_maybe_impl(
@@ -12575,9 +12925,9 @@ async def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
     async def clear_cookies(
         self,
         *,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        domain: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        path: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        domain: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        path: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
     ) -> None:
         """BrowserContext.clear_cookies
 
@@ -12618,9 +12968,13 @@ async def grant_permissions(
         Parameters
         ----------
         permissions : Sequence[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
+            A list of permissions to grant.
+
+            **NOTE** Supported permissions differ between browsers, and even between different versions of the same browser.
+            Any permission may stop working after an update.
+
+            Here are some permissions that may be supported by some browsers:
             - `'accelerometer'`
-            - `'accessibility-events'`
             - `'ambient-light-sensor'`
             - `'background-sync'`
             - `'camera'`
@@ -12628,6 +12982,8 @@ async def grant_permissions(
             - `'clipboard-write'`
             - `'geolocation'`
             - `'gyroscope'`
+            - `'local-fonts'`
+            - `'local-network-access'`
             - `'magnetometer'`
             - `'microphone'`
             - `'midi-sysex'` (system-exclusive midi)
@@ -12726,7 +13082,7 @@ async def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> None:
         """BrowserContext.add_init_script
 
@@ -12768,7 +13124,7 @@ async def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
+        handle: typing.Optional[bool] = None,
     ) -> None:
         """BrowserContext.expose_binding
 
@@ -12899,7 +13255,7 @@ async def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """BrowserContext.route
 
@@ -12908,7 +13264,7 @@ async def route(
 
         **NOTE** `browser_context.route()` will not intercept requests intercepted by Service Worker. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         **Usage**
 
@@ -12955,8 +13311,8 @@ async def handle_route(route: Route):
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a `baseURL` via the context
-            options was provided and the passed URL is a path, it gets merged via the
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
             handler function to route the request.
@@ -13002,10 +13358,55 @@ async def unroute(
             )
         )
 
+    async def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """BrowserContext.route_web_socket
+
+        This method allows to modify websocket connections that are made by any page in the browser context.
+
+        Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this
+        method before creating any pages.
+
+        **Usage**
+
+        Below is an example of a simple handler that blocks some websocket messages. See `WebSocketRoute` for more details
+        and examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"to-be-blocked\":
+            return
+          ws.send(message)
+
+        async def handler(ws: WebSocketRoute):
+          ws.route_send(lambda message: message_handler(ws, message))
+          await ws.connect()
+
+        await context.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_web_socket(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
     async def unroute_all(
         self,
         *,
-        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
     ) -> None:
         """BrowserContext.unroute_all
 
@@ -13030,11 +13431,11 @@ async def route_from_har(
         self,
         har: typing.Union[pathlib.Path, str],
         *,
-        url: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         not_found: typing.Optional[Literal["abort", "fallback"]] = None,
         update: typing.Optional[bool] = None,
         update_content: typing.Optional[Literal["attach", "embed"]] = None,
-        update_mode: typing.Optional[Literal["full", "minimal"]] = None
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
     ) -> None:
         """BrowserContext.route_from_har
 
@@ -13043,7 +13444,7 @@ async def route_from_har(
 
         Playwright will not serve requests intercepted by Service Worker from the HAR file. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         Parameters
         ----------
@@ -13086,7 +13487,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager:
         """BrowserContext.expect_event
 
@@ -13138,31 +13539,41 @@ async def close(self, *, reason: typing.Optional[str] = None) -> None:
         return mapping.from_maybe_impl(await self._impl_obj.close(reason=reason))
 
     async def storage_state(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
     ) -> StorageState:
         """BrowserContext.storage_state
 
-        Returns storage state for this browser context, contains current cookies and local storage snapshot.
+        Returns storage state for this browser context, contains current cookies, local storage snapshot and IndexedDB
+        snapshot.
 
         Parameters
         ----------
         path : Union[pathlib.Path, str, None]
             The file path to save the storage state to. If `path` is a relative path, then it is resolved relative to current
             working directory. If no path is provided, storage state is still returned, but won't be saved to the disk.
+        indexed_db : Union[bool, None]
+            Set to `true` to include [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) in the storage
+            state snapshot. If your application uses IndexedDB to store authentication tokens, like Firebase Authentication,
+            enable this.
 
         Returns
         -------
         {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        return mapping.from_impl(await self._impl_obj.storage_state(path=path))
+        return mapping.from_impl(
+            await self._impl_obj.storage_state(path=path, indexedDB=indexed_db)
+        )
 
     async def wait_for_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """BrowserContext.wait_for_event
 
@@ -13197,7 +13608,7 @@ def expect_console_message(
         self,
         predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["ConsoleMessage"]:
         """BrowserContext.expect_console_message
 
@@ -13229,7 +13640,7 @@ def expect_page(
         self,
         predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Page"]:
         """BrowserContext.expect_page
 
@@ -13283,6 +13694,7 @@ async def new_cdp_session(
 
 
 class CDPSession(AsyncBase):
+
     async def send(
         self, method: str, params: typing.Optional[typing.Dict] = None
     ) -> typing.Dict:
@@ -13318,6 +13730,7 @@ async def detach(self) -> None:
 
 
 class Browser(AsyncContextManager):
+
     def on(
         self,
         event: Literal["disconnected"],
@@ -13426,12 +13839,13 @@ async def new_context(
             Literal["no-preference", "null", "reduce"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         accept_downloads: typing.Optional[bool] = None,
         default_browser_type: typing.Optional[str] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
@@ -13440,11 +13854,11 @@ async def new_context(
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """Browser.new_context
 
@@ -13520,9 +13934,9 @@ async def new_context(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -13531,6 +13945,10 @@ async def new_context(
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         accept_downloads : Union[bool, None]
             Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
@@ -13591,11 +14009,14 @@ async def new_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         BrowserContext
@@ -13623,6 +14044,7 @@ async def new_context(
                 colorScheme=color_scheme,
                 reducedMotion=reduced_motion,
                 forcedColors=forced_colors,
+                contrast=contrast,
                 acceptDownloads=accept_downloads,
                 defaultBrowserType=default_browser_type,
                 proxy=proxy,
@@ -13665,15 +14087,16 @@ async def new_page(
             Literal["dark", "light", "no-preference", "null"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         reduced_motion: typing.Optional[
             Literal["no-preference", "null", "reduce"]
         ] = None,
         accept_downloads: typing.Optional[bool] = None,
         default_browser_type: typing.Optional[str] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
@@ -13682,11 +14105,11 @@ async def new_page(
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "Page":
         """Browser.new_page
 
@@ -13746,13 +14169,17 @@ async def new_page(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         forced_colors : Union["active", "none", "null", None]
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -13817,11 +14244,14 @@ async def new_page(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         Page
@@ -13848,6 +14278,7 @@ async def new_page(
                 hasTouch=has_touch,
                 colorScheme=color_scheme,
                 forcedColors=forced_colors,
+                contrast=contrast,
                 reducedMotion=reduced_motion,
                 acceptDownloads=accept_downloads,
                 defaultBrowserType=default_browser_type,
@@ -13876,9 +14307,9 @@ async def close(self, *, reason: typing.Optional[str] = None) -> None:
         In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from
         the browser server.
 
-        **NOTE** This is similar to force quitting the browser. Therefore, you should call `browser_context.close()`
-        on any `BrowserContext`'s you explicitly created earlier with `browser.new_context()` **before** calling
-        `browser.close()`.
+        **NOTE** This is similar to force-quitting the browser. To close pages gracefully and ensure you receive page close
+        events, call `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
 
         The `Browser` object itself is considered to be disposed and cannot be used anymore.
 
@@ -13908,9 +14339,9 @@ async def start_tracing(
         self,
         *,
         page: typing.Optional["Page"] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         screenshots: typing.Optional[bool] = None,
-        categories: typing.Optional[typing.Sequence[str]] = None
+        categories: typing.Optional[typing.Sequence[str]] = None,
     ) -> None:
         """Browser.start_tracing
 
@@ -13973,6 +14404,7 @@ async def stop_tracing(self) -> bytes:
 
 
 class BrowserType(AsyncBase):
+
     @property
     def name(self) -> str:
         """BrowserType.name
@@ -14000,7 +14432,7 @@ def executable_path(self) -> str:
     async def launch(
         self,
         *,
-        executable_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         channel: typing.Optional[str] = None,
         args: typing.Optional[typing.Sequence[str]] = None,
         ignore_default_args: typing.Optional[
@@ -14012,15 +14444,14 @@ async def launch(
         timeout: typing.Optional[float] = None,
         env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         headless: typing.Optional[bool] = None,
-        devtools: typing.Optional[bool] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        downloads_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         slow_mo: typing.Optional[float] = None,
-        traces_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         chromium_sandbox: typing.Optional[bool] = None,
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
-        ] = None
+        ] = None,
     ) -> "Browser":
         """BrowserType.launch
 
@@ -14058,9 +14489,12 @@ async def launch(
             resolved relative to the current working directory. Note that Playwright only works with the bundled Chromium,
             Firefox or WebKit, use at your own risk.
         channel : Union[str, None]
-            Browser distribution channel.  Supported values are "chrome", "chrome-beta", "chrome-dev", "chrome-canary",
-            "msedge", "msedge-beta", "msedge-dev", "msedge-canary". Read more about using
-            [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
+
+            Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
+            "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
         args : Union[Sequence[str], None]
             **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.
 
@@ -14083,12 +14517,7 @@ async def launch(
         headless : Union[bool, None]
             Whether to run browser in headless mode. More details for
             [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the
-            `devtools` option is `true`.
-        devtools : Union[bool, None]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the
-            `headless` option will be set `false`.
-            Deprecated: Use [debugging tools](../debug.md) instead.
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
             Network proxy settings.
         downloads_path : Union[pathlib.Path, str, None]
@@ -14106,6 +14535,9 @@ async def launch(
             Firefox user preferences. Learn more about the Firefox user preferences at
             [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
 
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+
         Returns
         -------
         Browser
@@ -14123,7 +14555,6 @@ async def launch(
                 timeout=timeout,
                 env=mapping.to_impl(env),
                 headless=headless,
-                devtools=devtools,
                 proxy=proxy,
                 downloadsPath=downloads_path,
                 slowMo=slow_mo,
@@ -14138,7 +14569,7 @@ async def launch_persistent_context(
         user_data_dir: typing.Union[str, pathlib.Path],
         *,
         channel: typing.Optional[str] = None,
-        executable_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         args: typing.Optional[typing.Sequence[str]] = None,
         ignore_default_args: typing.Optional[
             typing.Union[bool, typing.Sequence[str]]
@@ -14149,9 +14580,8 @@ async def launch_persistent_context(
         timeout: typing.Optional[float] = None,
         env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         headless: typing.Optional[bool] = None,
-        devtools: typing.Optional[bool] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        downloads_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         slow_mo: typing.Optional[float] = None,
         viewport: typing.Optional[ViewportSize] = None,
         screen: typing.Optional[ViewportSize] = None,
@@ -14177,25 +14607,26 @@ async def launch_persistent_context(
             Literal["no-preference", "null", "reduce"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         accept_downloads: typing.Optional[bool] = None,
-        traces_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         chromium_sandbox: typing.Optional[bool] = None,
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
         ] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         base_url: typing.Optional[str] = None,
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -14207,15 +14638,29 @@ async def launch_persistent_context(
         Parameters
         ----------
         user_data_dir : Union[pathlib.Path, str]
-            Path to a User Data Directory, which stores browser session data like cookies and local storage. More details for
+            Path to a User Data Directory, which stores browser session data like cookies and local storage. Pass an empty
+            string to create a temporary directory.
+
+            More details for
             [Chromium](https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md#introduction) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Command_Line_Options#User_Profile). Note that Chromium's
-            user data directory is the **parent** directory of the "Profile Path" seen at `chrome://version`. Pass an empty
-            string to use a temporary directory instead.
+            [Firefox](https://wiki.mozilla.org/Firefox/CommandLineOptions#User_profile). Chromium's user data directory is the
+            **parent** directory of the "Profile Path" seen at `chrome://version`.
+
+            Note that browsers do not allow launching multiple instances with the same User Data Directory.
+
+            **NOTE** Chromium/Chrome: Due to recent Chrome policy changes, automating the default Chrome user profile is not
+            supported. Pointing `userDataDir` to Chrome's main "User Data" directory (the profile used for your regular
+            browsing) may result in pages not loading or the browser exiting. Create and use a separate directory (for example,
+            an empty folder) as your automation profile instead. See https://developer.chrome.com/blog/remote-debugging-port
+            for details.
+
         channel : Union[str, None]
-            Browser distribution channel.  Supported values are "chrome", "chrome-beta", "chrome-dev", "chrome-canary",
-            "msedge", "msedge-beta", "msedge-dev", "msedge-canary". Read more about using
-            [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
+
+            Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
+            "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
         executable_path : Union[pathlib.Path, str, None]
             Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is
             resolved relative to the current working directory. Note that Playwright only works with the bundled Chromium,
@@ -14242,12 +14687,7 @@ async def launch_persistent_context(
         headless : Union[bool, None]
             Whether to run browser in headless mode. More details for
             [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the
-            `devtools` option is `true`.
-        devtools : Union[bool, None]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the
-            `headless` option will be set `false`.
-            Deprecated: Use [debugging tools](../debug.md) instead.
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
             Network proxy settings.
         downloads_path : Union[pathlib.Path, str, None]
@@ -14305,9 +14745,9 @@ async def launch_persistent_context(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -14316,6 +14756,10 @@ async def launch_persistent_context(
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         accept_downloads : Union[bool, None]
             Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
         traces_dir : Union[pathlib.Path, str, None]
@@ -14325,6 +14769,9 @@ async def launch_persistent_context(
         firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
             Firefox user preferences. Learn more about the Firefox user preferences at
             [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
         record_har_path : Union[pathlib.Path, str, None]
             Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
             on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
@@ -14376,11 +14823,14 @@ async def launch_persistent_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         BrowserContext
@@ -14399,7 +14849,6 @@ async def launch_persistent_context(
                 timeout=timeout,
                 env=mapping.to_impl(env),
                 headless=headless,
-                devtools=devtools,
                 proxy=proxy,
                 downloadsPath=downloads_path,
                 slowMo=slow_mo,
@@ -14423,6 +14872,7 @@ async def launch_persistent_context(
                 colorScheme=color_scheme,
                 reducedMotion=reduced_motion,
                 forcedColors=forced_colors,
+                contrast=contrast,
                 acceptDownloads=accept_downloads,
                 tracesDir=traces_dir,
                 chromiumSandbox=chromium_sandbox,
@@ -14447,7 +14897,8 @@ async def connect_over_cdp(
         *,
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
-        headers: typing.Optional[typing.Dict[str, str]] = None
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        is_local: typing.Optional[bool] = None,
     ) -> "Browser":
         """BrowserType.connect_over_cdp
 
@@ -14457,6 +14908,10 @@ async def connect_over_cdp(
 
         **NOTE** Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
 
+        **NOTE** This connection is significantly lower fidelity than the Playwright protocol connection via
+        `browser_type.connect()`. If you are experiencing issues or attempting to use advanced functionality, you
+        probably want to use `browser_type.connect()`.
+
         **Usage**
 
         ```py
@@ -14478,6 +14933,9 @@ async def connect_over_cdp(
             on. Defaults to 0.
         headers : Union[Dict[str, str], None]
             Additional HTTP headers to be sent with connect request. Optional.
+        is_local : Union[bool, None]
+            Tells Playwright that it runs on the same host as the CDP server. It will enable certain optimizations that rely
+            upon the file system being the same between Playwright and the Browser.
 
         Returns
         -------
@@ -14490,6 +14948,7 @@ async def connect_over_cdp(
                 timeout=timeout,
                 slowMo=slow_mo,
                 headers=mapping.to_impl(headers),
+                isLocal=is_local,
             )
         )
 
@@ -14500,18 +14959,19 @@ async def connect(
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        expose_network: typing.Optional[str] = None
+        expose_network: typing.Optional[str] = None,
     ) -> "Browser":
         """BrowserType.connect
 
-        This method attaches Playwright to an existing browser instance. When connecting to another browser launched via
-        `BrowserType.launchServer` in Node.js, the major and minor version needs to match the client version (1.2.3 → is
-        compatible with 1.2.x).
+        This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
+
+        **NOTE** The major and minor version of the Playwright instance that connects needs to match the version of
+        Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).
 
         Parameters
         ----------
         ws_endpoint : str
-            A browser websocket endpoint to connect to.
+            A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.
         timeout : Union[float, None]
             Maximum time in milliseconds to wait for the connection to be established. Defaults to `0` (no timeout).
         slow_mo : Union[float, None]
@@ -14554,6 +15014,7 @@ async def connect(
 
 
 class Playwright(AsyncBase):
+
     @property
     def devices(self) -> typing.Dict:
         """Playwright.devices
@@ -14648,6 +15109,7 @@ def request(self) -> "APIRequest":
         return mapping.from_impl(self._impl_obj.request)
 
     def __getitem__(self, value: str) -> "BrowserType":
+
         return mapping.from_impl(self._impl_obj.__getitem__(value=value))
 
     async def stop(self) -> None:
@@ -14678,6 +15140,7 @@ async def stop(self) -> None:
 
 
 class Tracing(AsyncBase):
+
     async def start(
         self,
         *,
@@ -14685,12 +15148,21 @@ async def start(
         title: typing.Optional[str] = None,
         snapshots: typing.Optional[bool] = None,
         screenshots: typing.Optional[bool] = None,
-        sources: typing.Optional[bool] = None
+        sources: typing.Optional[bool] = None,
     ) -> None:
         """Tracing.start
 
         Start tracing.
 
+        **NOTE** You probably want to
+        [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead
+        of using `Tracing.start`.
+
+        The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions
+        (like `expect` calls). We recommend
+        [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace),
+        which includes those assertions and provides a more complete trace for debugging test failures.
+
         **Usage**
 
         ```py
@@ -14704,8 +15176,8 @@ async def start(
         ----------
         name : Union[str, None]
             If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
-            `tracesDir` folder specified in `browser_type.launch()`. To specify the final trace zip file name, you need
-            to pass `path` option to `tracing.stop()` instead.
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop()` instead.
         title : Union[str, None]
             Trace name to be shown in the Trace Viewer.
         snapshots : Union[bool, None]
@@ -14761,8 +15233,8 @@ async def start_chunk(
             Trace name to be shown in the Trace Viewer.
         name : Union[str, None]
             If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
-            `tracesDir` folder specified in `browser_type.launch()`. To specify the final trace zip file name, you need
-            to pass `path` option to `tracing.stop_chunk()` instead.
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop_chunk()` instead.
         """
 
         return mapping.from_maybe_impl(
@@ -14770,7 +15242,7 @@ async def start_chunk(
         )
 
     async def stop_chunk(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
     ) -> None:
         """Tracing.stop_chunk
 
@@ -14785,7 +15257,7 @@ async def stop_chunk(
         return mapping.from_maybe_impl(await self._impl_obj.stop_chunk(path=path))
 
     async def stop(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
     ) -> None:
         """Tracing.stop
 
@@ -14799,13 +15271,56 @@ async def stop(
 
         return mapping.from_maybe_impl(await self._impl_obj.stop(path=path))
 
+    async def group(
+        self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
+    ) -> None:
+        """Tracing.group
 
-mapping.register(TracingImpl, Tracing)
+        **NOTE** Use `test.step` instead when available.
 
+        Creates a new group within the trace, assigning any subsequent API calls to this group, until
+        `tracing.group_end()` is called. Groups can be nested and will be visible in the trace viewer.
 
-class Locator(AsyncBase):
-    @property
-    def page(self) -> "Page":
+        **Usage**
+
+        ```py
+        # All actions between group and group_end
+        # will be shown in the trace viewer as a group.
+        page.context.tracing.group(\"Open Playwright.dev > API\")
+        page.goto(\"https://playwright.dev/\")
+        page.get_by_role(\"link\", name=\"API\").click()
+        page.context.tracing.group_end()
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Group name shown in the trace viewer.
+        location : Union[{file: str, line: Union[int, None], column: Union[int, None]}, None]
+            Specifies a custom location for the group to be shown in the trace viewer. Defaults to the location of the
+            `tracing.group()` call.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.group(name=name, location=location)
+        )
+
+    async def group_end(self) -> None:
+        """Tracing.group_end
+
+        Closes the last group created by `tracing.group()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.group_end())
+
+
+mapping.register(TracingImpl, Tracing)
+
+
+class Locator(AsyncBase):
+
+    @property
+    def page(self) -> "Page":
         """Locator.page
 
         A page this locator belongs to.
@@ -14872,6 +15387,29 @@ def content_frame(self) -> "FrameLocator":
         """
         return mapping.from_impl(self._impl_obj.content_frame)
 
+    @property
+    def description(self) -> typing.Optional[str]:
+        """Locator.description
+
+        Returns locator description previously set with `locator.describe()`. Returns `null` if no custom
+        description has been set.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_role(\"button\").describe(\"Subscribe button\")
+        print(button.description())  # \"Subscribe button\"
+
+        input = page.get_by_role(\"textbox\")
+        print(input.description())  # None
+        ```
+
+        Returns
+        -------
+        Union[str, None]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.description)
+
     async def bounding_box(
         self, *, timeout: typing.Optional[float] = None
     ) -> typing.Optional[FloatRect]:
@@ -14922,7 +15460,7 @@ async def check(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.check
 
@@ -14990,7 +15528,8 @@ async def click(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.click
 
@@ -15052,7 +15591,12 @@ async def click(
             Deprecated: This option will default to `true` in the future.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -15066,6 +15610,7 @@ async def click(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -15081,7 +15626,8 @@ async def dblclick(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.dblclick
 
@@ -15124,7 +15670,12 @@ async def dblclick(
             Deprecated: This option has no effect.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -15137,6 +15688,7 @@ async def dblclick(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -15145,7 +15697,7 @@ async def dispatch_event(
         type: str,
         event_init: typing.Optional[typing.Dict] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Locator.dispatch_event
 
@@ -15181,7 +15733,6 @@ async def dispatch_event(
         You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
 
         ```py
-        # note you can only create data_transfer in chromium and firefox
         data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
         await locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
         ```
@@ -15208,7 +15759,7 @@ async def evaluate(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """Locator.evaluate
 
@@ -15225,9 +15776,11 @@ async def evaluate(
 
         **Usage**
 
+        Passing argument to `expression`:
+
         ```py
-        tweets = page.locator(\".tweet .retweets\")
-        assert await tweets.evaluate(\"node => node.innerText\") == \"10 retweets\"
+        result = await page.get_by_testid(\"myId\").evaluate(\"(element, [x, y]) => element.textContent + ' ' + x * y\", [7, 8])
+        print(result) # prints \"myId text 56\"
         ```
 
         Parameters
@@ -15238,8 +15791,8 @@ async def evaluate(
         arg : Union[Any, None]
             Optional argument to pass to `expression`.
         timeout : Union[float, None]
-            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
         Returns
         -------
@@ -15299,7 +15852,7 @@ async def evaluate_handle(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> "JSHandle":
         """Locator.evaluate_handle
 
@@ -15328,8 +15881,8 @@ async def evaluate_handle(
         arg : Union[Any, None]
             Optional argument to pass to `expression`.
         timeout : Union[float, None]
-            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
         Returns
         -------
@@ -15348,7 +15901,7 @@ async def fill(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Locator.fill
 
@@ -15397,7 +15950,7 @@ async def clear(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Locator.clear
 
@@ -15441,10 +15994,10 @@ def locator(
         self,
         selector_or_locator: typing.Union[str, "Locator"],
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Locator.locator
 
@@ -15499,7 +16052,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_alt_text
 
@@ -15536,7 +16089,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_label
 
@@ -15577,7 +16130,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_placeholder
 
@@ -15706,10 +16259,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_role
 
@@ -15763,6 +16316,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -15856,7 +16410,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_text
 
@@ -15920,7 +16474,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_title
 
@@ -16035,13 +16589,39 @@ def nth(self, index: int) -> "Locator":
 
         return mapping.from_impl(self._impl_obj.nth(index=index))
 
+    def describe(self, description: str) -> "Locator":
+        """Locator.describe
+
+        Describes the locator, description is used in the trace viewer and reports. Returns the locator pointing to the
+        same element.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_test_id(\"btn-sub\").describe(\"Subscribe button\")
+        await button.click()
+        ```
+
+        Parameters
+        ----------
+        description : str
+            Locator description.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.describe(description=description))
+
     def filter(
         self,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
+        visible: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.filter
 
@@ -16083,6 +16663,8 @@ def filter(
             outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.
 
             Note that outer and inner locators must belong to the same frame. Inner locator must not contain `FrameLocator`s.
+        visible : Union[bool, None]
+            Only matches visible or invisible elements.
 
         Returns
         -------
@@ -16095,23 +16677,31 @@ def filter(
                 hasNotText=has_not_text,
                 has=has._impl_obj if has else None,
                 hasNot=has_not._impl_obj if has_not else None,
+                visible=visible,
             )
         )
 
     def or_(self, locator: "Locator") -> "Locator":
         """Locator.or_
 
-        Creates a locator that matches either of the two locators.
+        Creates a locator matching all elements that match one or both of the two locators.
+
+        Note that when both locators match something, the resulting locator will have multiple matches, potentially causing
+        a [locator strictness](https://playwright.dev/python/docs/locators#strictness) violation.
 
         **Usage**
 
         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.
 
+        **NOTE** If both \"New email\" button and security dialog appear on screen, the \"or\" locator will match both of them,
+        possibly throwing the [\"strict mode violation\" error](https://playwright.dev/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
         ```py
         new_email = page.get_by_role(\"button\", name=\"New\")
         dialog = page.get_by_text(\"Confirm security settings\")
-        await expect(new_email.or_(dialog)).to_be_visible()
+        await expect(new_email.or_(dialog).first).to_be_visible()
         if (await dialog.is_visible()):
           await page.get_by_role(\"button\", name=\"Dismiss\").click()
         await new_email.click()
@@ -16139,7 +16729,7 @@ def and_(self, locator: "Locator") -> "Locator":
         The following example finds a button with a specific title.
 
         ```py
-        button = page.get_by_role(\"button\").and_(page.getByTitle(\"Subscribe\"))
+        button = page.get_by_role(\"button\").and_(page.get_by_title(\"Subscribe\"))
         ```
 
         Parameters
@@ -16189,9 +16779,13 @@ async def all(self) -> typing.List["Locator"]:
         elements.
 
         **NOTE** `locator.all()` does not wait for elements to match the locator, and instead immediately returns
-        whatever is present in the page.  When the list of elements changes dynamically, `locator.all()` will
-        produce unpredictable and flaky results.  When the list of elements is stable, but loaded dynamically, wait for the
-        full list to finish loading before calling `locator.all()`.
+        whatever is present in the page.
+
+        When the list of elements changes dynamically, `locator.all()` will produce unpredictable and flaky
+        results.
+
+        When the list of elements is stable, but loaded dynamically, wait for the full list to finish loading before
+        calling `locator.all()`.
 
         **Usage**
 
@@ -16237,7 +16831,8 @@ async def drag_to(
         timeout: typing.Optional[float] = None,
         trial: typing.Optional[bool] = None,
         source_position: typing.Optional[Position] = None,
-        target_position: typing.Optional[Position] = None
+        target_position: typing.Optional[Position] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.drag_to
 
@@ -16284,6 +16879,9 @@ async def drag_to(
         target_position : Union[{x: float, y: float}, None]
             Drops on the target element at this point relative to the top-left corner of the element's padding box. If not
             specified, some visible point of the element is used.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -16295,6 +16893,7 @@ async def drag_to(
                 trial=trial,
                 sourcePosition=source_position,
                 targetPosition=target_position,
+                steps=steps,
             )
         )
 
@@ -16335,7 +16934,7 @@ async def hover(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.hover
 
@@ -16378,7 +16977,9 @@ async def hover(
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -16526,7 +17127,9 @@ async def is_disabled(self, *, timeout: typing.Optional[float] = None) -> bool:
     async def is_editable(self, *, timeout: typing.Optional[float] = None) -> bool:
         """Locator.is_editable
 
-        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable). If the target element is not an `<input>`,
+        `<textarea>`, `<select>`, `[contenteditable]` and does not have a role allowing `[aria-readonly]`, this method
+        throws an error.
 
         **NOTE** If you need to assert that an element is editable, prefer `locator_assertions.to_be_editable()` to
         avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
@@ -16637,7 +17240,7 @@ async def press(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.press
 
@@ -16700,7 +17303,7 @@ async def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         animations: typing.Optional[Literal["allow", "disabled"]] = None,
@@ -16708,7 +17311,7 @@ async def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """Locator.screenshot
 
@@ -16771,7 +17374,9 @@ async def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -16801,6 +17406,61 @@ async def screenshot(
             )
         )
 
+    async def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
+        """Locator.aria_snapshot
+
+        Captures the aria snapshot of the given element. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots) and
+        `locator_assertions.to_match_aria_snapshot()` for the corresponding assertion.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"link\").aria_snapshot()
+        ```
+
+        **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\"
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(timeout=timeout)
+        )
+
     async def scroll_into_view_if_needed(
         self, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -16834,7 +17494,7 @@ async def select_option(
         ] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Locator.select_option
 
@@ -16858,9 +17518,9 @@ async def select_option(
 
         ```html
         <select multiple>
-          <option value=\"red\">Red</div>
-          <option value=\"green\">Green</div>
-          <option value=\"blue\">Blue</div>
+          <option value=\"red\">Red</option>
+          <option value=\"green\">Green</option>
+          <option value=\"blue\">Blue</option>
         </select>
         ```
 
@@ -16915,7 +17575,7 @@ async def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Locator.select_text
 
@@ -16950,7 +17610,7 @@ async def set_input_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.set_input_files
 
@@ -17017,11 +17677,12 @@ async def tap(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.tap
 
-        Perform a tap gesture on the element matching the locator.
+        Perform a tap gesture on the element matching the locator. For examples of emulating other gestures by manually
+        dispatching touch events, see the [emulating legacy touch events](https://playwright.dev/python/docs/touch-events) page.
 
         **Details**
 
@@ -17056,7 +17717,9 @@ async def tap(
             Deprecated: This option has no effect.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -17101,7 +17764,7 @@ async def type(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.type
 
@@ -17138,7 +17801,7 @@ async def press_sequentially(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.press_sequentially
 
@@ -17192,7 +17855,7 @@ async def uncheck(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.uncheck
 
@@ -17295,7 +17958,7 @@ async def wait_for(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> None:
         """Locator.wait_for
 
@@ -17338,7 +18001,7 @@ async def set_checked(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.set_checked
 
@@ -17409,6 +18072,7 @@ async def highlight(self) -> None:
 
 
 class APIResponse(AsyncBase):
+
     @property
     def ok(self) -> bool:
         """APIResponse.ok
@@ -17533,6 +18197,7 @@ async def dispose(self) -> None:
 
 
 class APIRequestContext(AsyncBase):
+
     async def dispose(self, *, reason: typing.Optional[str] = None) -> None:
         """APIRequestContext.dispose
 
@@ -17565,7 +18230,7 @@ async def delete(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.delete
 
@@ -17646,7 +18311,7 @@ async def head(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.head
 
@@ -17727,7 +18392,7 @@ async def get(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.get
 
@@ -17820,7 +18485,7 @@ async def patch(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.patch
 
@@ -17901,7 +18566,7 @@ async def put(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.put
 
@@ -17982,7 +18647,7 @@ async def post(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.post
 
@@ -18095,7 +18760,7 @@ async def fetch(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.fetch
 
@@ -18115,7 +18780,7 @@ async def fetch(
         ```
 
         The common way to send file(s) in the body of a request is to upload them as form fields with `multipart/form-data`
-        encoding. Use `FormData` to construct request body and pass it to the request as `multipart` parameter:
+        encoding, by specifiying the `multipart` parameter:
 
         Parameters
         ----------
@@ -18178,7 +18843,10 @@ async def fetch(
         )
 
     async def storage_state(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
     ) -> StorageState:
         """APIRequestContext.storage_state
 
@@ -18190,19 +18858,24 @@ async def storage_state(
         path : Union[pathlib.Path, str, None]
             The file path to save the storage state to. If `path` is a relative path, then it is resolved relative to current
             working directory. If no path is provided, storage state is still returned, but won't be saved to the disk.
+        indexed_db : Union[bool, None]
+            Set to `true` to include IndexedDB in the storage state snapshot.
 
         Returns
         -------
         {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        return mapping.from_impl(await self._impl_obj.storage_state(path=path))
+        return mapping.from_impl(
+            await self._impl_obj.storage_state(path=path, indexedDB=indexed_db)
+        )
 
 
 mapping.register(APIRequestContextImpl, APIRequestContext)
 
 
 class APIRequest(AsyncBase):
+
     async def new_context(
         self,
         *,
@@ -18216,7 +18889,9 @@ async def new_context(
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
         ] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
     ) -> "APIRequestContext":
         """APIRequest.new_context
 
@@ -18262,11 +18937,21 @@ async def new_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        max_redirects : Union[int, None]
+            Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is
+            exceeded. Defaults to `20`. Pass `0` to not follow redirects. This can be overwritten for each request
+            individually.
+
         Returns
         -------
         APIRequestContext
@@ -18283,6 +18968,8 @@ async def new_context(
                 timeout=timeout,
                 storageState=storage_state,
                 clientCertificates=client_certificates,
+                failOnStatusCode=fail_on_status_code,
+                maxRedirects=max_redirects,
             )
         )
 
@@ -18291,11 +18978,12 @@ async def new_context(
 
 
 class PageAssertions(AsyncBase):
+
     async def to_have_title(
         self,
         title_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """PageAssertions.to_have_title
 
@@ -18330,7 +19018,7 @@ async def not_to_have_title(
         self,
         title_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """PageAssertions.not_to_have_title
 
@@ -18356,7 +19044,7 @@ async def to_have_url(
         url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
         *,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.to_have_url
 
@@ -18380,7 +19068,7 @@ async def to_have_url(
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         ignore_case : Union[bool, None]
             Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
-            expression flag if specified.
+            expression parameter if specified. A provided predicate ignores this flag.
         """
         __tracebackhide__ = True
 
@@ -18395,7 +19083,7 @@ async def not_to_have_url(
         url_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.not_to_have_url
 
@@ -18424,6 +19112,7 @@ async def not_to_have_url(
 
 
 class LocatorAssertions(AsyncBase):
+
     async def to_contain_text(
         self,
         expected: typing.Union[
@@ -18436,7 +19125,7 @@ async def to_contain_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_contain_text
 
@@ -18481,7 +19170,7 @@ async def to_contain_text(
         from playwright.async_api import expect
 
         # ✓ Contains the right items in the right order
-        await expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\", \"Text 4\"])
+        await expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\"])
 
         # ✖ Wrong order
         await expect(page.locator(\"ul > li\")).to_contain_text([\"Text 3\", \"Text 2\"])
@@ -18528,7 +19217,7 @@ async def not_to_contain_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.not_to_contain_text
 
@@ -18563,7 +19252,7 @@ async def to_have_attribute(
         value: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_attribute
 
@@ -18604,7 +19293,7 @@ async def not_to_have_attribute(
         value: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_attribute
 
@@ -18640,33 +19329,35 @@ async def to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_class
 
-        Ensures the `Locator` points to an element with given CSS classes. This needs to be a full match or using a relaxed
-        regular expression.
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes use `locator_assertions.to_contain_class()`.
 
         **Usage**
 
         ```html
-        <div class='selected row' id='component'></div>
+        <div class='middle selected row' id='component'></div>
         ```
 
         ```py
         from playwright.async_api import expect
 
         locator = page.locator(\"#component\")
-        await expect(locator).to_have_class(re.compile(r\"selected\"))
-        await expect(locator).to_have_class(\"selected row\")
+        await expect(locator).to_have_class(\"middle selected row\")
+        await expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
         ```
 
-        Note that if array is passed as an expected value, entire lists of elements can be asserted:
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
 
         ```py
         from playwright.async_api import expect
 
-        locator = page.locator(\"list > .component\")
+        locator = page.locator(\".list > .component\")
         await expect(locator).to_have_class([\"component\", \"component selected\", \"component\"])
         ```
 
@@ -18695,7 +19386,7 @@ async def not_to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_class
 
@@ -18716,6 +19407,92 @@ async def not_to_have_class(
             )
         )
 
+    async def to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_class
+
+        Ensures the `Locator` points to an element with given CSS classes. All classes from the asserted value, separated
+        by spaces, must be present in the
+        [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
+
+        **Usage**
+
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
+
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.locator(\"#component\")
+        await expect(locator).to_contain_class(\"middle selected row\")
+        await expect(locator).to_contain_class(\"selected\")
+        await expect(locator).to_contain_class(\"row middle\")
+        ```
+
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class lists. Each element's class attribute is matched against the corresponding class in the array:
+
+        ```html
+        <div class='list'>
+          <div class='component inactive'></div>
+          <div class='component active'></div>
+          <div class='component inactive'></div>
+        </div>
+        ```
+
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.locator(\".list > .component\")
+        await expect(locator).to_contain_class([\"inactive\", \"active\", \"inactive\"])
+        ```
+
+        Parameters
+        ----------
+        expected : Union[Sequence[str], str]
+            A string containing expected class names, separated by spaces, or a list of such strings to assert multiple
+            elements.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_contain_class(
+                expected=mapping.to_impl(expected), timeout=timeout
+            )
+        )
+
+    async def not_to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_class
+
+        The opposite of `locator_assertions.to_contain_class()`.
+
+        Parameters
+        ----------
+        expected : Union[Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_contain_class(
+                expected=mapping.to_impl(expected), timeout=timeout
+            )
+        )
+
     async def to_have_count(
         self, count: int, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -18770,7 +19547,7 @@ async def to_have_css(
         name: str,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_css
 
@@ -18805,7 +19582,7 @@ async def not_to_have_css(
         name: str,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_css
 
@@ -18832,7 +19609,7 @@ async def to_have_id(
         self,
         id: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_id
 
@@ -18864,7 +19641,7 @@ async def not_to_have_id(
         self,
         id: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_id
 
@@ -18945,7 +19722,7 @@ async def to_have_value(
         self,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_value
 
@@ -18979,7 +19756,7 @@ async def not_to_have_value(
         self,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_value
 
@@ -19006,7 +19783,7 @@ async def to_have_values(
             typing.Sequence[typing.Union[typing.Pattern[str], str]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_values
 
@@ -19057,7 +19834,7 @@ async def not_to_have_values(
             typing.Sequence[typing.Union[typing.Pattern[str], str]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_values
 
@@ -19090,7 +19867,7 @@ async def to_have_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_have_text
 
@@ -19181,7 +19958,7 @@ async def not_to_have_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_text
 
@@ -19214,7 +19991,7 @@ async def to_be_attached(
         self,
         *,
         attached: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_attached
 
@@ -19243,7 +20020,8 @@ async def to_be_checked(
         self,
         *,
         timeout: typing.Optional[float] = None,
-        checked: typing.Optional[bool] = None
+        checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_be_checked
 
@@ -19263,18 +20041,25 @@ async def to_be_checked(
         timeout : Union[float, None]
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
-            await self._impl_obj.to_be_checked(timeout=timeout, checked=checked)
+            await self._impl_obj.to_be_checked(
+                timeout=timeout, checked=checked, indeterminate=indeterminate
+            )
         )
 
     async def not_to_be_attached(
         self,
         *,
         attached: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_attached
 
@@ -19361,7 +20146,7 @@ async def to_be_editable(
         self,
         *,
         editable: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_editable
 
@@ -19392,7 +20177,7 @@ async def not_to_be_editable(
         self,
         *,
         editable: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_editable
 
@@ -19455,7 +20240,7 @@ async def to_be_enabled(
         self,
         *,
         enabled: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_enabled
 
@@ -19486,7 +20271,7 @@ async def not_to_be_enabled(
         self,
         *,
         enabled: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_enabled
 
@@ -19550,7 +20335,7 @@ async def to_be_visible(
         self,
         *,
         visible: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_visible
 
@@ -19591,7 +20376,7 @@ async def not_to_be_visible(
         self,
         *,
         visible: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_visible
 
@@ -19656,7 +20441,7 @@ async def to_be_in_viewport(
         self,
         *,
         ratio: typing.Optional[float] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_in_viewport
 
@@ -19695,7 +20480,7 @@ async def not_to_be_in_viewport(
         self,
         *,
         ratio: typing.Optional[float] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_in_viewport
 
@@ -19718,7 +20503,7 @@ async def to_have_accessible_description(
         description: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_accessible_description
 
@@ -19755,7 +20540,7 @@ async def not_to_have_accessible_description(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_accessible_description
 
@@ -19784,7 +20569,7 @@ async def to_have_accessible_name(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_accessible_name
 
@@ -19821,7 +20606,7 @@ async def not_to_have_accessible_name(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_accessible_name
 
@@ -19932,7 +20717,7 @@ async def to_have_role(
             "treeitem",
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_role
 
@@ -19961,6 +20746,72 @@ async def to_have_role(
             await self._impl_obj.to_have_role(role=role, timeout=timeout)
         )
 
+    async def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
+
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        await expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_error_message(
+                errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
+
+    async def not_to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
+
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_error_message(
+                errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
+
     async def not_to_have_role(
         self,
         role: Literal[
@@ -20048,7 +20899,7 @@ async def not_to_have_role(
             "treeitem",
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_role
 
@@ -20067,11 +20918,64 @@ async def not_to_have_role(
             await self._impl_obj.not_to_have_role(role=role, timeout=timeout)
         )
 
+    async def to_match_aria_snapshot(
+        self, expected: str, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        """LocatorAssertions.to_match_aria_snapshot
+
+        Asserts that the target element matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```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?\"
+        ''')
+        ```
+
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_match_aria_snapshot(
+                expected=expected, timeout=timeout
+            )
+        )
+
+    async def not_to_match_aria_snapshot(
+        self, expected: str, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        """LocatorAssertions.not_to_match_aria_snapshot
+
+        The opposite of `locator_assertions.to_match_aria_snapshot()`.
+
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_match_aria_snapshot(
+                expected=expected, timeout=timeout
+            )
+        )
+
 
 mapping.register(LocatorAssertionsImpl, LocatorAssertions)
 
 
 class APIResponseAssertions(AsyncBase):
+
     async def to_be_ok(self) -> None:
         """APIResponseAssertions.to_be_ok
 
diff --git a/playwright/sync_api/__init__.py b/playwright/sync_api/__init__.py
index e17c0e305..53dee2cad 100644
--- a/playwright/sync_api/__init__.py
+++ b/playwright/sync_api/__init__.py
@@ -30,7 +30,6 @@
 from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
 from playwright.sync_api._context_manager import PlaywrightContextManager
 from playwright.sync_api._generated import (
-    Accessibility,
     APIRequest,
     APIRequestContext,
     APIResponse,
@@ -60,7 +59,9 @@
     Selectors,
     Touchscreen,
     Video,
+    WebError,
     WebSocket,
+    WebSocketRoute,
     Worker,
 )
 
@@ -77,6 +78,7 @@
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
 SourceLocation = playwright._impl._api_structures.SourceLocation
 StorageState = playwright._impl._api_structures.StorageState
+StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
 ViewportSize = playwright._impl._api_structures.ViewportSize
 
 Error = playwright._impl._errors.Error
@@ -107,20 +109,19 @@ def set_options(self, timeout: Optional[float] = _unset) -> None:
             self._timeout = timeout
 
     @overload
-    def __call__(self, actual: Page, message: Optional[str] = None) -> PageAssertions:
-        ...
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
 
     @overload
     def __call__(
         self, actual: Locator, message: Optional[str] = None
-    ) -> LocatorAssertions:
-        ...
+    ) -> LocatorAssertions: ...
 
     @overload
     def __call__(
         self, actual: APIResponse, message: Optional[str] = None
-    ) -> APIResponseAssertions:
-        ...
+    ) -> APIResponseAssertions: ...
 
     def __call__(
         self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
@@ -147,7 +148,6 @@ def __call__(
 
 __all__ = [
     "expect",
-    "Accessibility",
     "APIRequest",
     "APIRequestContext",
     "APIResponse",
@@ -185,11 +185,14 @@ def __call__(
     "Selectors",
     "SourceLocation",
     "StorageState",
+    "StorageStateCookie",
     "sync_playwright",
     "TimeoutError",
     "Touchscreen",
     "Video",
     "ViewportSize",
+    "WebError",
     "WebSocket",
+    "WebSocketRoute",
     "Worker",
 ]
diff --git a/playwright/sync_api/_generated.py b/playwright/sync_api/_generated.py
index 69eb53b79..0df2087df 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -18,7 +18,6 @@
 import typing
 from typing import Literal
 
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
 from playwright._impl._api_structures import (
     ClientCertificate,
     Cookie,
@@ -37,6 +36,7 @@
     SetCookieParam,
     SourceLocation,
     StorageState,
+    TracingGroupLocation,
     ViewportSize,
 )
 from playwright._impl._assertions import (
@@ -69,6 +69,7 @@
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
 from playwright._impl._network import WebSocket as WebSocketImpl
+from playwright._impl._network import WebSocketRoute as WebSocketRouteImpl
 from playwright._impl._page import Page as PageImpl
 from playwright._impl._page import Worker as WorkerImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
@@ -85,6 +86,7 @@
 
 
 class Request(SyncBase):
+
     @property
     def url(self) -> str:
         """Request.url
@@ -111,6 +113,24 @@ def resource_type(self) -> str:
         """
         return mapping.from_maybe_impl(self._impl_obj.resource_type)
 
+    @property
+    def service_worker(self) -> typing.Optional["Worker"]:
+        """Request.service_worker
+
+        The Service `Worker` that is performing the request.
+
+        **Details**
+
+        This method is Chromium only. It's safe to call when using other browsers, but it will always be `null`.
+
+        Requests originated in a Service Worker do not have a `request.frame()` available.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.service_worker)
+
     @property
     def method(self) -> str:
         """Request.method
@@ -387,6 +407,7 @@ def header_value(self, name: str) -> typing.Optional[str]:
 
 
 class Response(SyncBase):
+
     @property
     def url(self) -> str:
         """Response.url
@@ -627,6 +648,7 @@ def json(self) -> typing.Any:
 
 
 class Route(SyncBase):
+
     @property
     def request(self) -> "Request":
         """Route.request
@@ -677,9 +699,9 @@ def fulfill(
         headers: typing.Optional[typing.Dict[str, str]] = None,
         body: typing.Optional[typing.Union[str, bytes]] = None,
         json: typing.Optional[typing.Any] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content_type: typing.Optional[str] = None,
-        response: typing.Optional["APIResponse"] = None
+        response: typing.Optional["APIResponse"] = None,
     ) -> None:
         """Route.fulfill
 
@@ -745,7 +767,7 @@ def fetch(
         post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
         max_redirects: typing.Optional[int] = None,
         max_retries: typing.Optional[int] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> "APIResponse":
         """Route.fetch
 
@@ -816,7 +838,7 @@ def fallback(
         url: typing.Optional[str] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
     ) -> None:
         """Route.fallback
 
@@ -909,7 +931,7 @@ def continue_(
         url: typing.Optional[str] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
     ) -> None:
         """Route.continue_
 
@@ -932,13 +954,19 @@ def handle(route, request):
 
         **Details**
 
-        Note that any overrides such as `url` or `headers` only apply to the request being routed. If this request results
-        in a redirect, overrides will not be applied to the new redirected request. If you want to propagate a header
-        through redirects, use the combination of `route.fetch()` and `route.fulfill()` instead.
+        The `headers` option applies to both the routed request and any redirects it initiates. However, `url`, `method`,
+        and `postData` only apply to the original request and are not carried over to redirected requests.
 
         `route.continue_()` will immediately send the request to the network, other matching handlers won't be
         invoked. Use `route.fallback()` If you want next matching handler in the chain to be invoked.
 
+        **NOTE** Some request headers are **forbidden** and cannot be overridden (for example, `Cookie`, `Host`,
+        `Content-Length` and others, see
+        [this MDN page](https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_request_header) for full list). If an
+        override is provided for a forbidden header, it will be ignored and the original request header will be used.
+
+        To set custom cookies, use `browser_context.add_cookies()`.
+
         Parameters
         ----------
         url : Union[str, None]
@@ -967,6 +995,7 @@ def handle(route, request):
 
 
 class WebSocket(SyncBase):
+
     @typing.overload
     def on(
         self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]
@@ -1054,7 +1083,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """WebSocket.expect_event
 
@@ -1087,7 +1116,7 @@ def wait_for_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """WebSocket.wait_for_event
 
@@ -1138,7 +1167,135 @@ def is_closed(self) -> bool:
 mapping.register(WebSocketImpl, WebSocket)
 
 
+class WebSocketRoute(SyncBase):
+
+    @property
+    def url(self) -> str:
+        """WebSocketRoute.url
+
+        URL of the WebSocket created in the page.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    def close(
+        self, *, code: typing.Optional[int] = None, reason: typing.Optional[str] = None
+    ) -> None:
+        """WebSocketRoute.close
+
+        Closes one side of the WebSocket connection.
+
+        Parameters
+        ----------
+        code : Union[int, None]
+            Optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code).
+        reason : Union[str, None]
+            Optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.close(code=code, reason=reason))
+        )
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        """WebSocketRoute.connect_to_server
+
+        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
+          `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 `web_socket_route.on_message()` is
+          called on the original `WebSocketRoute`.
+
+        See examples at the top for more details.
+
+        Returns
+        -------
+        WebSocketRoute
+        """
+
+        return mapping.from_impl(self._impl_obj.connect_to_server())
+
+    def send(self, message: typing.Union[str, bytes]) -> None:
+        """WebSocketRoute.send
+
+        Sends a message to the WebSocket. When called on the original WebSocket, sends the message to the page. When called
+        on the result of `web_socket_route.connect_to_server()`, sends the message to the server. See examples at the
+        top for more details.
+
+        Parameters
+        ----------
+        message : Union[bytes, str]
+            Message to send.
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.send(message=message))
+
+    def on_message(
+        self, handler: typing.Callable[[typing.Union[str, bytes]], typing.Any]
+    ) -> None:
+        """WebSocketRoute.on_message
+
+        This method allows to handle messages that are sent by the WebSocket, either from the page or from the server.
+
+        When called on the original WebSocket route, this method handles messages sent from the page. You can handle this
+        messages by responding to them with `web_socket_route.send()`, forwarding them to the server-side connection
+        returned by `web_socket_route.connect_to_server()` or do something else.
+
+        Once this method is called, messages are not automatically forwarded to the server or to the page - you should do
+        that manually by calling `web_socket_route.send()`. See examples at the top for more details.
+
+        Calling this method again will override the handler with a new one.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[bytes, str]], Any]
+            Function that will handle messages.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_message(handler=self._wrap_handler(handler))
+        )
+
+    def on_close(
+        self,
+        handler: typing.Callable[
+            [typing.Optional[int], typing.Optional[str]], typing.Any
+        ],
+    ) -> None:
+        """WebSocketRoute.on_close
+
+        Allows to handle [`WebSocket.close`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close).
+
+        By default, closing one side of the connection, either in the page or on the server, will close the other side.
+        However, when `web_socket_route.on_close()` handler is set up, the default forwarding of closure is disabled,
+        and handler should take care of it.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[int, None], Union[str, None]], Any]
+            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).
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_close(handler=self._wrap_handler(handler))
+        )
+
+
+mapping.register(WebSocketRouteImpl, WebSocketRoute)
+
+
 class Keyboard(SyncBase):
+
     def down(self, key: str) -> None:
         """Keyboard.down
 
@@ -1306,6 +1463,7 @@ def press(self, key: str, *, delay: typing.Optional[float] = None) -> None:
 
 
 class Mouse(SyncBase):
+
     def move(self, x: float, y: float, *, steps: typing.Optional[int] = None) -> None:
         """Mouse.move
 
@@ -1318,7 +1476,8 @@ def move(self, x: float, y: float, *, steps: typing.Optional[int] = None) -> Non
         y : float
             Y coordinate relative to the main frame's viewport in CSS pixels.
         steps : Union[int, None]
-            Defaults to 1. Sends intermediate `mousemove` events.
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -1329,7 +1488,7 @@ def down(
         self,
         *,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.down
 
@@ -1351,7 +1510,7 @@ def up(
         self,
         *,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.up
 
@@ -1376,7 +1535,7 @@ def click(
         *,
         delay: typing.Optional[float] = None,
         button: typing.Optional[Literal["left", "middle", "right"]] = None,
-        click_count: typing.Optional[int] = None
+        click_count: typing.Optional[int] = None,
     ) -> None:
         """Mouse.click
 
@@ -1410,7 +1569,7 @@ def dblclick(
         y: float,
         *,
         delay: typing.Optional[float] = None,
-        button: typing.Optional[Literal["left", "middle", "right"]] = None
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
     ) -> None:
         """Mouse.dblclick
 
@@ -1459,6 +1618,7 @@ def wheel(self, delta_x: float, delta_y: float) -> None:
 
 
 class Touchscreen(SyncBase):
+
     def tap(self, x: float, y: float) -> None:
         """Touchscreen.tap
 
@@ -1481,6 +1641,7 @@ def tap(self, x: float, y: float) -> None:
 
 
 class JSHandle(SyncBase):
+
     def evaluate(
         self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
@@ -1638,6 +1799,7 @@ def json_value(self) -> typing.Any:
 
 
 class ElementHandle(JSHandle):
+
     def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
@@ -1890,7 +2052,7 @@ def hover(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.hover
 
@@ -1952,7 +2114,8 @@ def click(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """ElementHandle.click
 
@@ -1995,6 +2158,9 @@ def click(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -2009,6 +2175,7 @@ def click(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -2025,7 +2192,8 @@ def dblclick(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """ElementHandle.dblclick
 
@@ -2065,6 +2233,9 @@ def dblclick(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -2078,6 +2249,7 @@ def dblclick(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -2093,7 +2265,7 @@ def select_option(
         ] = None,
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """ElementHandle.select_option
 
@@ -2170,7 +2342,7 @@ def tap(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.tap
 
@@ -2227,7 +2399,7 @@ def fill(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.fill
 
@@ -2267,7 +2439,7 @@ def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """ElementHandle.select_text
 
@@ -2326,7 +2498,7 @@ def set_input_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.set_input_files
 
@@ -2374,7 +2546,7 @@ def type(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.type
 
@@ -2413,7 +2585,7 @@ def press(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.press
 
@@ -2471,7 +2643,7 @@ def set_checked(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.set_checked
 
@@ -2527,7 +2699,7 @@ def check(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.check
 
@@ -2581,7 +2753,7 @@ def uncheck(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """ElementHandle.uncheck
 
@@ -2663,7 +2835,7 @@ def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         animations: typing.Optional[Literal["allow", "disabled"]] = None,
@@ -2671,7 +2843,7 @@ def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """ElementHandle.screenshot
 
@@ -2718,7 +2890,9 @@ def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -2890,7 +3064,7 @@ def wait_for_element_state(
             "disabled", "editable", "enabled", "hidden", "stable", "visible"
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """ElementHandle.wait_for_element_state
 
@@ -2932,7 +3106,7 @@ def wait_for_selector(
             Literal["attached", "detached", "hidden", "visible"]
         ] = None,
         timeout: typing.Optional[float] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Optional["ElementHandle"]:
         """ElementHandle.wait_for_selector
 
@@ -2991,74 +3165,8 @@ def wait_for_selector(
 mapping.register(ElementHandleImpl, ElementHandle)
 
 
-class Accessibility(SyncBase):
-    def snapshot(
-        self,
-        *,
-        interesting_only: typing.Optional[bool] = None,
-        root: typing.Optional["ElementHandle"] = None
-    ) -> typing.Optional[typing.Dict]:
-        """Accessibility.snapshot
-
-        Captures the current state of the accessibility tree. The returned object represents the root accessible node of
-        the page.
-
-        **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen
-        readers. Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to
-        `false`.
-
-        **Usage**
-
-        An example of dumping the entire accessibility tree:
-
-        ```py
-        snapshot = page.accessibility.snapshot()
-        print(snapshot)
-        ```
-
-        An example of logging the focused node's name:
-
-        ```py
-        def find_focused_node(node):
-            if node.get(\"focused\"):
-                return node
-            for child in (node.get(\"children\") or []):
-                found_node = find_focused_node(child)
-                if found_node:
-                    return found_node
-            return None
-
-        snapshot = page.accessibility.snapshot()
-        node = find_focused_node(snapshot)
-        if node:
-            print(node[\"name\"])
-        ```
-
-        Parameters
-        ----------
-        interesting_only : Union[bool, None]
-            Prune uninteresting nodes from the tree. Defaults to `true`.
-        root : Union[ElementHandle, None]
-            The root DOM element for the snapshot. Defaults to the whole page.
-
-        Returns
-        -------
-        Union[Dict, None]
-        """
-
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.snapshot(
-                    interestingOnly=interesting_only, root=mapping.to_impl(root)
-                )
-            )
-        )
-
-
-mapping.register(AccessibilityImpl, Accessibility)
-
-
 class FileChooser(SyncBase):
+
     @property
     def page(self) -> "Page":
         """FileChooser.page
@@ -3106,7 +3214,7 @@ def set_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """FileChooser.set_files
 
@@ -3139,6 +3247,7 @@ def set_files(
 
 
 class Frame(SyncBase):
+
     @property
     def page(self) -> "Page":
         """Frame.page
@@ -3210,7 +3319,7 @@ def goto(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        referer: typing.Optional[str] = None
+        referer: typing.Optional[str] = None,
     ) -> typing.Optional["Response"]:
         """Frame.goto
 
@@ -3277,7 +3386,7 @@ def expect_navigation(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Response"]:
         """Frame.expect_navigation
 
@@ -3337,7 +3446,7 @@ def wait_for_url(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.wait_for_url
 
@@ -3385,7 +3494,7 @@ def wait_for_load_state(
             Literal["domcontentloaded", "load", "networkidle"]
         ] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.wait_for_load_state
 
@@ -3623,7 +3732,7 @@ def wait_for_selector(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["ElementHandle"]:
         """Frame.wait_for_selector
 
@@ -3695,7 +3804,7 @@ def is_checked(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_checked
 
@@ -3731,7 +3840,7 @@ def is_disabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_disabled
 
@@ -3767,7 +3876,7 @@ def is_editable(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_editable
 
@@ -3803,7 +3912,7 @@ def is_enabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Frame.is_enabled
 
@@ -3834,13 +3943,7 @@ def is_enabled(
             )
         )
 
-    def is_hidden(
-        self,
-        selector: str,
-        *,
-        strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
-    ) -> bool:
+    def is_hidden(self, selector: str, *, strict: typing.Optional[bool] = None) -> bool:
         """Frame.is_hidden
 
         Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).  `selector` that
@@ -3854,8 +3957,6 @@ def is_hidden(
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
-        timeout : Union[float, None]
-            Deprecated: This option is ignored. `frame.is_hidden()` does not wait for the element to become hidden and returns immediately.
 
         Returns
         -------
@@ -3863,19 +3964,11 @@ def is_hidden(
         """
 
         return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.is_hidden(
-                    selector=selector, strict=strict, timeout=timeout
-                )
-            )
+            self._sync(self._impl_obj.is_hidden(selector=selector, strict=strict))
         )
 
     def is_visible(
-        self,
-        selector: str,
-        *,
-        strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        self, selector: str, *, strict: typing.Optional[bool] = None
     ) -> bool:
         """Frame.is_visible
 
@@ -3890,8 +3983,6 @@ def is_visible(
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
-        timeout : Union[float, None]
-            Deprecated: This option is ignored. `frame.is_visible()` does not wait for the element to become visible and returns immediately.
 
         Returns
         -------
@@ -3899,11 +3990,7 @@ def is_visible(
         """
 
         return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.is_visible(
-                    selector=selector, strict=strict, timeout=timeout
-                )
-            )
+            self._sync(self._impl_obj.is_visible(selector=selector, strict=strict))
         )
 
     def dispatch_event(
@@ -3913,7 +4000,7 @@ def dispatch_event(
         event_init: typing.Optional[typing.Dict] = None,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.dispatch_event
 
@@ -3985,7 +4072,7 @@ def eval_on_selector(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Any:
         """Frame.eval_on_selector
 
@@ -4095,7 +4182,7 @@ def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Frame.set_content
 
@@ -4145,9 +4232,9 @@ def add_script_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content: typing.Optional[str] = None,
-        type: typing.Optional[str] = None
+        type: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Frame.add_script_tag
 
@@ -4185,8 +4272,8 @@ def add_style_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content: typing.Optional[str] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Frame.add_style_tag
 
@@ -4231,7 +4318,7 @@ def click(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.click
 
@@ -4279,7 +4366,9 @@ def click(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4314,7 +4403,7 @@ def dblclick(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.dblclick
 
@@ -4360,7 +4449,9 @@ def dblclick(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4392,7 +4483,7 @@ def tap(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.tap
 
@@ -4433,7 +4524,9 @@ def tap(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -4459,7 +4552,7 @@ def fill(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Frame.fill
 
@@ -4511,10 +4604,10 @@ def locator(
         self,
         selector: str,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Frame.locator
 
@@ -4572,7 +4665,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_alt_text
 
@@ -4609,7 +4702,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_label
 
@@ -4650,7 +4743,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_placeholder
 
@@ -4779,10 +4872,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_role
 
@@ -4836,6 +4929,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -4929,7 +5023,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_text
 
@@ -4993,7 +5087,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Frame.get_by_title
 
@@ -5061,7 +5155,7 @@ def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.focus
 
@@ -5092,7 +5186,7 @@ def text_content(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Frame.text_content
 
@@ -5128,7 +5222,7 @@ def inner_text(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.inner_text
 
@@ -5164,7 +5258,7 @@ def inner_html(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.inner_html
 
@@ -5201,7 +5295,7 @@ def get_attribute(
         name: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Frame.get_attribute
 
@@ -5246,7 +5340,7 @@ def hover(
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.hover
 
@@ -5285,7 +5379,9 @@ def hover(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -5314,7 +5410,8 @@ def drag_and_drop(
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Frame.drag_and_drop
 
@@ -5346,6 +5443,9 @@ def drag_and_drop(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -5360,6 +5460,7 @@ def drag_and_drop(
                     strict=strict,
                     timeout=timeout,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -5377,7 +5478,7 @@ def select_option(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Frame.select_option
 
@@ -5456,7 +5557,7 @@ def input_value(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Frame.input_value
 
@@ -5504,7 +5605,7 @@ def set_input_files(
         *,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.set_input_files
 
@@ -5553,7 +5654,7 @@ def type(
         delay: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.type
 
@@ -5605,7 +5706,7 @@ def press(
         delay: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Frame.press
 
@@ -5673,7 +5774,7 @@ def check(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.check
 
@@ -5737,7 +5838,7 @@ def uncheck(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.uncheck
 
@@ -5816,7 +5917,7 @@ def wait_for_function(
         *,
         arg: typing.Optional[typing.Any] = None,
         timeout: typing.Optional[float] = None,
-        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
     ) -> "JSHandle":
         """Frame.wait_for_function
 
@@ -5902,7 +6003,7 @@ def set_checked(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Frame.set_checked
 
@@ -5965,6 +6066,7 @@ def set_checked(
 
 
 class FrameLocator(SyncBase):
+
     @property
     def first(self) -> "FrameLocator":
         """FrameLocator.first
@@ -6003,7 +6105,7 @@ def owner(self) -> "Locator":
         **Usage**
 
         ```py
-        frame_locator = page.frame_locator(\"iframe[name=\\\"embedded\\\"]\")
+        frame_locator = page.locator(\"iframe[name=\\\"embedded\\\"]\").content_frame
         # ...
         locator = frame_locator.owner
         expect(locator).to_be_visible()
@@ -6019,10 +6121,10 @@ def locator(
         self,
         selector_or_locator: typing.Union["Locator", str],
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """FrameLocator.locator
 
@@ -6077,7 +6179,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_alt_text
 
@@ -6114,7 +6216,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_label
 
@@ -6155,7 +6257,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_placeholder
 
@@ -6284,10 +6386,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_role
 
@@ -6341,6 +6443,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -6434,7 +6537,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_text
 
@@ -6498,7 +6601,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """FrameLocator.get_by_title
 
@@ -6572,20 +6675,43 @@ def nth(self, index: int) -> "FrameLocator":
 
 
 class Worker(SyncBase):
+
+    @typing.overload
     def on(
         self, event: Literal["close"], f: typing.Callable[["Worker"], "None"]
     ) -> None:
         """
         Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
         terminated."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
         return super().on(event=event, f=f)
 
+    @typing.overload
     def once(
         self, event: Literal["close"], f: typing.Callable[["Worker"], "None"]
     ) -> None:
         """
         Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
         terminated."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
         return super().once(event=event, f=f)
 
     @property
@@ -6665,29 +6791,71 @@ def evaluate_handle(
             )
         )
 
-
-mapping.register(WorkerImpl, Worker)
-
-
-class Selectors(SyncBase):
-    def register(
+    def expect_event(
         self,
-        name: str,
-        script: typing.Optional[str] = None,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content_script: typing.Optional[bool] = None
-    ) -> None:
-        """Selectors.register
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager:
+        """Worker.expect_event
 
-        Selectors must be registered before creating the page.
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
 
         **Usage**
 
-        An example of registering selector engine that queries elements based on a tag name:
-
         ```py
-        from playwright.sync_api import sync_playwright, Playwright
+        with worker.expect_event(\"console\") as event_info:
+            worker.evaluate(\"console.log(42)\")
+        message = event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            Maximum time to wait for in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The
+            default value can be changed by using the `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_event(
+                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+            ).future,
+        )
+
+
+mapping.register(WorkerImpl, Worker)
+
+
+class Selectors(SyncBase):
+
+    def register(
+        self,
+        name: str,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_script: typing.Optional[bool] = None,
+    ) -> None:
+        """Selectors.register
+
+        Selectors must be registered before creating the page.
+
+        **Usage**
+
+        An example of registering selector engine that queries elements based on a tag name:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
 
         def run(playwright: Playwright):
             tag_selector = \"\"\"
@@ -6765,10 +6933,11 @@ def set_test_id_attribute(self, attribute_name: str) -> None:
 
 
 class Clock(SyncBase):
+
     def install(
         self,
         *,
-        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
     ) -> None:
         """Clock.install
 
@@ -6837,6 +7006,18 @@ def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
         page.clock.pause_at(\"2020-02-02\")
         ```
 
+        For best results, install the clock before navigating the page and set it to a time slightly before the intended
+        test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck.
+        Once the page has fully loaded, you can safely use `clock.pause_at()` to pause the clock.
+
+        ```py
+        # Initialize clock with some time before the test time and let the page load
+        # naturally. `Date.now` will progress as the timers fire.
+        page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        page.goto(\"http://localhost:3333\")
+        page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
         Parameters
         ----------
         time : Union[datetime.datetime, float, str]
@@ -6879,6 +7060,9 @@ def set_fixed_time(self, time: typing.Union[float, str, datetime.datetime]) -> N
 
         Makes `Date.now` and `new Date()` return fixed fake time at all times, keeps all the timers running.
 
+        Use this method for simple scenarios where you only need to test with a predefined time. For more advanced
+        scenarios, use `clock.install()` instead. Read docs on [clock emulation](https://playwright.dev/python/docs/clock) to learn more.
+
         **Usage**
 
         ```py
@@ -6902,7 +7086,8 @@ def set_system_time(
     ) -> None:
         """Clock.set_system_time
 
-        Sets current system time but does not trigger any timers.
+        Sets system time, but does not trigger any timers. Use this to test how the web page reacts to a time shift, for
+        example switching from summer to winter time, or changing time zones.
 
         **Usage**
 
@@ -6927,17 +7112,36 @@ def set_system_time(
 
 
 class ConsoleMessage(SyncBase):
+
     @property
-    def type(self) -> str:
+    def type(
+        self,
+    ) -> typing.Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
         """ConsoleMessage.type
 
-        One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-        `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`,
-        `'profileEnd'`, `'count'`, `'timeEnd'`.
-
         Returns
         -------
-        str
+        Union["assert", "clear", "count", "debug", "dir", "dirxml", "endGroup", "error", "info", "log", "profile", "profileEnd", "startGroup", "startGroupCollapsed", "table", "time", "timeEnd", "trace", "warning"]
         """
         return mapping.from_maybe_impl(self._impl_obj.type)
 
@@ -6987,11 +7191,25 @@ def page(self) -> typing.Optional["Page"]:
         """
         return mapping.from_impl_nullable(self._impl_obj.page)
 
+    @property
+    def worker(self) -> typing.Optional["Worker"]:
+        """ConsoleMessage.worker
+
+        The web worker or service worker that produced this console message, if any. Note that console messages from web
+        workers also have non-null `console_message.page()`.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.worker)
+
 
 mapping.register(ConsoleMessageImpl, ConsoleMessage)
 
 
 class Dialog(SyncBase):
+
     @property
     def type(self) -> str:
         """Dialog.type
@@ -7068,6 +7286,7 @@ def dismiss(self) -> None:
 
 
 class Download(SyncBase):
+
     @property
     def page(self) -> "Page":
         """Download.page
@@ -7177,6 +7396,7 @@ def cancel(self) -> None:
 
 
 class Video(SyncBase):
+
     def path(self) -> pathlib.Path:
         """Video.path
 
@@ -7217,6 +7437,7 @@ def delete(self) -> None:
 
 
 class Page(SyncContextManager):
+
     @typing.overload
     def on(self, event: Literal["close"], f: typing.Callable[["Page"], "None"]) -> None:
         """
@@ -7653,16 +7874,6 @@ def once(
     def once(self, event: str, f: typing.Callable[..., None]) -> None:
         return super().once(event=event, f=f)
 
-    @property
-    def accessibility(self) -> "Accessibility":
-        """Page.accessibility
-
-        Returns
-        -------
-        Accessibility
-        """
-        return mapping.from_impl(self._impl_obj.accessibility)
-
     @property
     def keyboard(self) -> "Keyboard":
         """Page.keyboard
@@ -7820,7 +8031,7 @@ def frame(
         *,
         url: typing.Optional[
             typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Frame"]:
         """Page.frame
 
@@ -7883,7 +8094,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -7943,7 +8154,7 @@ def wait_for_selector(
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
         ] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Optional["ElementHandle"]:
         """Page.wait_for_selector
 
@@ -8015,7 +8226,7 @@ def is_checked(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_checked
 
@@ -8051,7 +8262,7 @@ def is_disabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_disabled
 
@@ -8087,7 +8298,7 @@ def is_editable(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_editable
 
@@ -8123,7 +8334,7 @@ def is_enabled(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_enabled
 
@@ -8159,7 +8370,7 @@ def is_hidden(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_hidden
 
@@ -8195,7 +8406,7 @@ def is_visible(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> bool:
         """Page.is_visible
 
@@ -8233,7 +8444,7 @@ def dispatch_event(
         event_init: typing.Optional[typing.Dict] = None,
         *,
         timeout: typing.Optional[float] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.dispatch_event
 
@@ -8419,7 +8630,7 @@ def eval_on_selector(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.Any:
         """Page.eval_on_selector
 
@@ -8510,9 +8721,9 @@ def add_script_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         content: typing.Optional[str] = None,
-        type: typing.Optional[str] = None
+        type: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Page.add_script_tag
 
@@ -8549,8 +8760,8 @@ def add_style_tag(
         self,
         *,
         url: typing.Optional[str] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
-        content: typing.Optional[str] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Page.add_style_tag
 
@@ -8644,7 +8855,7 @@ def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
+        handle: typing.Optional[bool] = None,
     ) -> None:
         """Page.expose_binding
 
@@ -8745,7 +8956,7 @@ def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Page.set_content
 
@@ -8787,7 +8998,7 @@ def goto(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        referer: typing.Optional[str] = None
+        referer: typing.Optional[str] = None,
     ) -> typing.Optional["Response"]:
         """Page.goto
 
@@ -8853,7 +9064,7 @@ def reload(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.reload
 
@@ -8892,7 +9103,7 @@ def wait_for_load_state(
             Literal["domcontentloaded", "load", "networkidle"]
         ] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.wait_for_load_state
 
@@ -8948,7 +9159,7 @@ def wait_for_url(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.wait_for_url
 
@@ -8995,7 +9206,7 @@ def wait_for_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """Page.wait_for_event
 
@@ -9036,7 +9247,7 @@ def go_back(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.go_back
 
@@ -9076,7 +9287,7 @@ def go_forward(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.go_forward
 
@@ -9110,6 +9321,28 @@ def go_forward(
             self._sync(self._impl_obj.go_forward(timeout=timeout, waitUntil=wait_until))
         )
 
+    def request_gc(self) -> None:
+        """Page.request_gc
+
+        Request the page to perform garbage collection. Note that there is no guarantee that all unreachable objects will
+        be collected.
+
+        This is useful to help detect memory leaks. For example, if your page has a large object `'suspect'` that might be
+        leaked, you can check that it does not leak by using a
+        [`WeakRef`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef).
+
+        ```py
+        # 1. In your page, save a WeakRef for the \"suspect\".
+        page.evaluate(\"globalThis.suspectWeakRef = new WeakRef(suspect)\")
+        # 2. Request garbage collection.
+        page.request_gc()
+        # 3. Check that weak ref does not deref to the original object.
+        assert page.evaluate(\"!globalThis.suspectWeakRef.deref()\")
+        ```
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.request_gc()))
+
     def emulate_media(
         self,
         *,
@@ -9120,7 +9353,8 @@ def emulate_media(
         reduced_motion: typing.Optional[
             Literal["no-preference", "null", "reduce"]
         ] = None,
-        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
     ) -> None:
         """Page.emulate_media
 
@@ -9154,7 +9388,6 @@ def emulate_media(
         # → True
         page.evaluate(\"matchMedia('(prefers-color-scheme: light)').matches\")
         # → False
-        page.evaluate(\"matchMedia('(prefers-color-scheme: no-preference)').matches\")
         ```
 
         Parameters
@@ -9163,12 +9396,14 @@ def emulate_media(
             Changes the CSS media type of the page. The only allowed values are `'Screen'`, `'Print'` and `'Null'`. Passing
             `'Null'` disables CSS media emulation.
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`.
-            Passing `'Null'` disables color scheme emulation.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. Passing `'Null'` disables color scheme emulation.
+            `'no-preference'` is deprecated.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. Passing
             `null` disables reduced motion emulation.
         forced_colors : Union["active", "none", "null", None]
+        contrast : Union["more", "no-preference", "null", None]
         """
 
         return mapping.from_maybe_impl(
@@ -9178,6 +9413,7 @@ def emulate_media(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                 )
             )
         )
@@ -9222,7 +9458,7 @@ def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> None:
         """Page.add_init_script
 
@@ -9267,7 +9503,7 @@ def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """Page.route
 
@@ -9280,7 +9516,7 @@ def route(
 
         **NOTE** `page.route()` will not intercept requests intercepted by Service Worker. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         **NOTE** `page.route()` will not intercept the first request of a popup page. Use
         `browser_context.route()` instead.
@@ -9327,8 +9563,8 @@ def handle_route(route: Route):
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a `baseURL` via the context
-            options was provided and the passed URL is a path, it gets merged via the
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
             handler function to route the request.
@@ -9377,10 +9613,55 @@ def unroute(
             )
         )
 
+    def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """Page.route_web_socket
+
+        This method allows to modify websocket connections that are made by the page.
+
+        Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this
+        method before navigating the page.
+
+        **Usage**
+
+        Below is an example of a simple mock that responds to a single message. See `WebSocketRoute` for more details and
+        examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"request\":
+            ws.send(\"response\")
+
+        def handler(ws: WebSocketRoute):
+          ws.on_message(lambda message: message_handler(ws, message))
+
+        page.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_web_socket(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
     def unroute_all(
         self,
         *,
-        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
     ) -> None:
         """Page.unroute_all
 
@@ -9405,11 +9686,11 @@ def route_from_har(
         self,
         har: typing.Union[pathlib.Path, str],
         *,
-        url: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         not_found: typing.Optional[Literal["abort", "fallback"]] = None,
         update: typing.Optional[bool] = None,
         update_content: typing.Optional[Literal["attach", "embed"]] = None,
-        update_mode: typing.Optional[Literal["full", "minimal"]] = None
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
     ) -> None:
         """Page.route_from_har
 
@@ -9418,7 +9699,7 @@ def route_from_har(
 
         Playwright will not serve requests intercepted by Service Worker from the HAR file. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         Parameters
         ----------
@@ -9463,7 +9744,7 @@ def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         full_page: typing.Optional[bool] = None,
@@ -9473,7 +9754,7 @@ def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """Page.screenshot
 
@@ -9518,7 +9799,9 @@ def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -9568,7 +9851,7 @@ def close(
         self,
         *,
         run_before_unload: typing.Optional[bool] = None,
-        reason: typing.Optional[str] = None
+        reason: typing.Optional[str] = None,
     ) -> None:
         """Page.close
 
@@ -9622,7 +9905,7 @@ def click(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         trial: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.click
 
@@ -9667,7 +9950,9 @@ def click(
             Deprecated: This option will default to `true` in the future.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         strict : Union[bool, None]
             When true, the call requires selector to resolve to a single element. If given selector resolves to more than one
             element, the call throws an exception.
@@ -9705,7 +9990,7 @@ def dblclick(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.dblclick
 
@@ -9750,7 +10035,9 @@ def dblclick(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -9782,7 +10069,7 @@ def tap(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.tap
 
@@ -9823,7 +10110,9 @@ def tap(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -9849,7 +10138,7 @@ def fill(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Page.fill
 
@@ -9901,10 +10190,10 @@ def locator(
         self,
         selector: str,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Page.locator
 
@@ -9960,7 +10249,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_alt_text
 
@@ -9997,7 +10286,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_label
 
@@ -10038,7 +10327,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_placeholder
 
@@ -10167,10 +10456,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_role
 
@@ -10224,6 +10513,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -10317,7 +10607,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_text
 
@@ -10381,7 +10671,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Page.get_by_title
 
@@ -10449,7 +10739,7 @@ def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.focus
 
@@ -10480,7 +10770,7 @@ def text_content(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Page.text_content
 
@@ -10516,7 +10806,7 @@ def inner_text(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.inner_text
 
@@ -10552,7 +10842,7 @@ def inner_html(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.inner_html
 
@@ -10589,7 +10879,7 @@ def get_attribute(
         name: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Optional[str]:
         """Page.get_attribute
 
@@ -10634,7 +10924,7 @@ def hover(
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.hover
 
@@ -10673,7 +10963,9 @@ def hover(
             element, the call throws an exception.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -10702,7 +10994,8 @@ def drag_and_drop(
         no_wait_after: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Page.drag_and_drop
 
@@ -10750,6 +11043,9 @@ def drag_and_drop(
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
             to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -10764,6 +11060,7 @@ def drag_and_drop(
                     timeout=timeout,
                     strict=strict,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -10781,7 +11078,7 @@ def select_option(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Page.select_option
 
@@ -10861,7 +11158,7 @@ def input_value(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> str:
         """Page.input_value
 
@@ -10909,7 +11206,7 @@ def set_input_files(
         *,
         timeout: typing.Optional[float] = None,
         strict: typing.Optional[bool] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Page.set_input_files
 
@@ -10959,7 +11256,7 @@ def type(
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.type
 
@@ -11011,7 +11308,7 @@ def press(
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        strict: typing.Optional[bool] = None
+        strict: typing.Optional[bool] = None,
     ) -> None:
         """Page.press
 
@@ -11095,7 +11392,7 @@ def check(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.check
 
@@ -11159,7 +11456,7 @@ def uncheck(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.uncheck
 
@@ -11245,7 +11542,7 @@ def wait_for_function(
         *,
         arg: typing.Optional[typing.Any] = None,
         timeout: typing.Optional[float] = None,
-        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
     ) -> "JSHandle":
         """Page.wait_for_function
 
@@ -11312,14 +11609,13 @@ def run(playwright: Playwright):
     def pause(self) -> None:
         """Page.pause
 
-        Pauses script execution. Playwright will stop executing the script and wait for the user to either press 'Resume'
-        button in the page overlay or to call `playwright.resume()` in the DevTools console.
+        Pauses script execution. Playwright will stop executing the script and wait for the user to either press the
+        'Resume' button in the page overlay or to call `playwright.resume()` in the DevTools console.
 
         User can inspect selectors or perform manual steps while paused. Resume will continue running the original script
         from the place it was paused.
 
-        **NOTE** This method requires Playwright to be started in a headed mode, with a falsy `headless` value in the
-        `browser_type.launch()`.
+        **NOTE** This method requires Playwright to be started in a headed mode, with a falsy `headless` option.
         """
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.pause()))
@@ -11339,16 +11635,14 @@ def pdf(
         height: typing.Optional[typing.Union[str, float]] = None,
         prefer_css_page_size: typing.Optional[bool] = None,
         margin: typing.Optional[PdfMargins] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         outline: typing.Optional[bool] = None,
-        tagged: typing.Optional[bool] = None
+        tagged: typing.Optional[bool] = None,
     ) -> bytes:
         """Page.pdf
 
         Returns the PDF buffer.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
-
         `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
         `page.emulate_media()` before calling `page.pdf()`:
 
@@ -11467,7 +11761,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """Page.expect_event
 
@@ -11507,7 +11801,7 @@ def expect_console_message(
         self,
         predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["ConsoleMessage"]:
         """Page.expect_console_message
 
@@ -11538,7 +11832,7 @@ def expect_download(
         self,
         predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Download"]:
         """Page.expect_download
 
@@ -11569,7 +11863,7 @@ def expect_file_chooser(
         self,
         predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["FileChooser"]:
         """Page.expect_file_chooser
 
@@ -11605,7 +11899,7 @@ def expect_navigation(
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
         ] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Response"]:
         """Page.expect_navigation
 
@@ -11664,7 +11958,7 @@ def expect_popup(
         self,
         predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Page"]:
         """Page.expect_popup
 
@@ -11697,7 +11991,7 @@ def expect_request(
             str, typing.Pattern[str], typing.Callable[["Request"], bool]
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Request"]:
         """Page.expect_request
 
@@ -11742,7 +12036,7 @@ def expect_request_finished(
         self,
         predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Request"]:
         """Page.expect_request_finished
 
@@ -11775,7 +12069,7 @@ def expect_response(
             str, typing.Pattern[str], typing.Callable[["Response"], bool]
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Response"]:
         """Page.expect_response
 
@@ -11822,7 +12116,7 @@ def expect_websocket(
         self,
         predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["WebSocket"]:
         """Page.expect_websocket
 
@@ -11853,7 +12147,7 @@ def expect_worker(
         self,
         predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Worker"]:
         """Page.expect_worker
 
@@ -11890,7 +12184,7 @@ def set_checked(
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
         strict: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Page.set_checked
 
@@ -11956,7 +12250,7 @@ def add_locator_handler(
         ],
         *,
         no_wait_after: typing.Optional[bool] = None,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """Page.add_locator_handler
 
@@ -11984,13 +12278,16 @@ def add_locator_handler(
 
         **NOTE** Running the handler will alter your page state mid-test. For example it will change the currently focused
         element and move the mouse. Make sure that actions that run after the handler are self-contained and do not rely on
-        the focus and mouse state being unchanged. <br /> <br /> For example, consider a test that calls
-        `locator.focus()` followed by `keyboard.press()`. If your handler clicks a button between these two
-        actions, the focused element most likely will be wrong, and key press will happen on the unexpected element. Use
-        `locator.press()` instead to avoid this problem. <br /> <br /> Another example is a series of mouse
-        actions, where `mouse.move()` is followed by `mouse.down()`. Again, when the handler runs between
-        these two actions, the mouse position will be wrong during the mouse down. Prefer self-contained actions like
-        `locator.click()` that do not rely on the state being unchanged by a handler.
+        the focus and mouse state being unchanged.
+
+        For example, consider a test that calls `locator.focus()` followed by `keyboard.press()`. If your
+        handler clicks a button between these two actions, the focused element most likely will be wrong, and key press
+        will happen on the unexpected element. Use `locator.press()` instead to avoid this problem.
+
+        Another example is a series of mouse actions, where `mouse.move()` is followed by `mouse.down()`.
+        Again, when the handler runs between these two actions, the mouse position will be wrong during the mouse down.
+        Prefer self-contained actions like `locator.click()` that do not rely on the state being unchanged by a
+        handler.
 
         **Usage**
 
@@ -11998,7 +12295,7 @@ def add_locator_handler(
 
         ```py
         # Setup the handler.
-        def handler():
+        async def handler():
           await page.get_by_role(\"button\", name=\"No thanks\").click()
         await page.add_locator_handler(page.get_by_text(\"Sign up to the newsletter\"), handler)
 
@@ -12011,7 +12308,7 @@ def handler():
 
         ```py
         # Setup the handler.
-        def handler():
+        async def handler():
           await page.get_by_role(\"button\", name=\"Remind me later\").click()
         await page.add_locator_handler(page.get_by_text(\"Confirm your security details\"), handler)
 
@@ -12026,7 +12323,7 @@ def handler():
 
         ```py
         # Setup the handler.
-        def handler():
+        async def handler():
           await page.evaluate(\"window.removeObstructionsForTestIfNeeded()\")
         await page.add_locator_handler(page.locator(\"body\"), handler, no_wait_after=True)
 
@@ -12039,7 +12336,7 @@ def handler():
         invocations by setting `times`:
 
         ```py
-        def handler(locator):
+        async def handler(locator):
           await locator.click()
         await page.add_locator_handler(page.get_by_label(\"Close\"), handler, times=1)
         ```
@@ -12085,11 +12382,55 @@ def remove_locator_handler(self, locator: "Locator") -> None:
             self._sync(self._impl_obj.remove_locator_handler(locator=locator._impl_obj))
         )
 
+    def requests(self) -> typing.List["Request"]:
+        """Page.requests
+
+        Returns up to (currently) 100 last network request from this page. See `page.on('request')` for more details.
+
+        Returned requests should be accessed immediately, otherwise they might be collected to prevent unbounded memory
+        growth as new requests come in. Once collected, retrieving most information about the request is impossible.
+
+        Note that requests reported through the `page.on('request')` request are not collected, so there is a trade off
+        between efficient memory usage with `page.requests()` and the amount of available information reported
+        through `page.on('request')`.
+
+        Returns
+        -------
+        List[Request]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.requests()))
+
+    def console_messages(self) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Returns
+        -------
+        List[ConsoleMessage]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.console_messages()))
+
+    def page_errors(self) -> typing.List["Error"]:
+        """Page.page_errors
+
+        Returns up to (currently) 200 last page errors from this page. See `page.on('page_error')` for more details.
+
+        Returns
+        -------
+        List[Error]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.page_errors()))
+
 
 mapping.register(PageImpl, Page)
 
 
 class WebError(SyncBase):
+
     @property
     def page(self) -> typing.Optional["Page"]:
         """WebError.page
@@ -12119,18 +12460,13 @@ def error(self) -> "Error":
 
 
 class BrowserContext(SyncContextManager):
+
     @typing.overload
     def on(
         self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
     ) -> None:
         """
-        **NOTE** Only works with Chromium browser's persistent context.
-
-        Emitted when new background page is created in the context.
-
-        ```py
-        background_page = context.wait_for_event(\"backgroundpage\")
-        ```"""
+        This event is not emitted."""
 
     @typing.overload
     def on(
@@ -12270,13 +12606,7 @@ def once(
         self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
     ) -> None:
         """
-        **NOTE** Only works with Chromium browser's persistent context.
-
-        Emitted when new background page is created in the context.
-
-        ```py
-        background_page = context.wait_for_event(\"backgroundpage\")
-        ```"""
+        This event is not emitted."""
 
     @typing.overload
     def once(
@@ -12429,7 +12759,8 @@ def pages(self) -> typing.List["Page"]:
     def browser(self) -> typing.Optional["Browser"]:
         """BrowserContext.browser
 
-        Returns the browser instance of the context. If it was launched as a persistent context null gets returned.
+        Gets the browser instance that owns the context. Returns `null` if the context is created outside of normal
+        browser, e.g. Android or Electron.
 
         Returns
         -------
@@ -12441,9 +12772,7 @@ def browser(self) -> typing.Optional["Browser"]:
     def background_pages(self) -> typing.List["Page"]:
         """BrowserContext.background_pages
 
-        **NOTE** Background pages are only supported on Chromium-based browsers.
-
-        All existing background pages in the context.
+        Returns an empty list.
 
         Returns
         -------
@@ -12535,7 +12864,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -12569,7 +12898,7 @@ def cookies(
 
         Returns
         -------
-        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}]
+        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"], partitionKey: Union[str, None]}]
         """
 
         return mapping.from_impl_list(
@@ -12590,7 +12919,7 @@ def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
 
         Parameters
         ----------
-        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None]}]
+        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None], partitionKey: Union[str, None]}]
         """
 
         return mapping.from_maybe_impl(
@@ -12600,9 +12929,9 @@ def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
     def clear_cookies(
         self,
         *,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        domain: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        path: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        domain: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        path: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
     ) -> None:
         """BrowserContext.clear_cookies
 
@@ -12645,9 +12974,13 @@ def grant_permissions(
         Parameters
         ----------
         permissions : Sequence[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
+            A list of permissions to grant.
+
+            **NOTE** Supported permissions differ between browsers, and even between different versions of the same browser.
+            Any permission may stop working after an update.
+
+            Here are some permissions that may be supported by some browsers:
             - `'accelerometer'`
-            - `'accessibility-events'`
             - `'ambient-light-sensor'`
             - `'background-sync'`
             - `'camera'`
@@ -12655,6 +12988,8 @@ def grant_permissions(
             - `'clipboard-write'`
             - `'geolocation'`
             - `'gyroscope'`
+            - `'local-fonts'`
+            - `'local-network-access'`
             - `'magnetometer'`
             - `'microphone'`
             - `'midi-sysex'` (system-exclusive midi)
@@ -12753,7 +13088,7 @@ def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> None:
         """BrowserContext.add_init_script
 
@@ -12795,7 +13130,7 @@ def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
+        handle: typing.Optional[bool] = None,
     ) -> None:
         """BrowserContext.expose_binding
 
@@ -12924,7 +13259,7 @@ def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
+        times: typing.Optional[int] = None,
     ) -> None:
         """BrowserContext.route
 
@@ -12933,7 +13268,7 @@ def route(
 
         **NOTE** `browser_context.route()` will not intercept requests intercepted by Service Worker. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         **Usage**
 
@@ -12981,8 +13316,8 @@ def handle_route(route: Route):
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing. When a `baseURL` via the context
-            options was provided and the passed URL is a path, it gets merged via the
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
             handler function to route the request.
@@ -13032,10 +13367,57 @@ def unroute(
             )
         )
 
+    def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """BrowserContext.route_web_socket
+
+        This method allows to modify websocket connections that are made by any page in the browser context.
+
+        Note that only `WebSocket`s created after this method was called will be routed. It is recommended to call this
+        method before creating any pages.
+
+        **Usage**
+
+        Below is an example of a simple handler that blocks some websocket messages. See `WebSocketRoute` for more details
+        and examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"to-be-blocked\":
+            return
+          ws.send(message)
+
+        def handler(ws: WebSocketRoute):
+          ws.route_send(lambda message: message_handler(ws, message))
+          ws.connect()
+
+        context.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_web_socket(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
     def unroute_all(
         self,
         *,
-        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
     ) -> None:
         """BrowserContext.unroute_all
 
@@ -13060,11 +13442,11 @@ def route_from_har(
         self,
         har: typing.Union[pathlib.Path, str],
         *,
-        url: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         not_found: typing.Optional[Literal["abort", "fallback"]] = None,
         update: typing.Optional[bool] = None,
         update_content: typing.Optional[Literal["attach", "embed"]] = None,
-        update_mode: typing.Optional[Literal["full", "minimal"]] = None
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
     ) -> None:
         """BrowserContext.route_from_har
 
@@ -13073,7 +13455,7 @@ def route_from_har(
 
         Playwright will not serve requests intercepted by Service Worker from the HAR file. See
         [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when
-        using request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+        using request interception by setting `serviceWorkers` to `'block'`.
 
         Parameters
         ----------
@@ -13118,7 +13500,7 @@ def expect_event(
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """BrowserContext.expect_event
 
@@ -13170,31 +13552,41 @@ def close(self, *, reason: typing.Optional[str] = None) -> None:
         return mapping.from_maybe_impl(self._sync(self._impl_obj.close(reason=reason)))
 
     def storage_state(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
     ) -> StorageState:
         """BrowserContext.storage_state
 
-        Returns storage state for this browser context, contains current cookies and local storage snapshot.
+        Returns storage state for this browser context, contains current cookies, local storage snapshot and IndexedDB
+        snapshot.
 
         Parameters
         ----------
         path : Union[pathlib.Path, str, None]
             The file path to save the storage state to. If `path` is a relative path, then it is resolved relative to current
             working directory. If no path is provided, storage state is still returned, but won't be saved to the disk.
+        indexed_db : Union[bool, None]
+            Set to `true` to include [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) in the storage
+            state snapshot. If your application uses IndexedDB to store authentication tokens, like Firebase Authentication,
+            enable this.
 
         Returns
         -------
         {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        return mapping.from_impl(self._sync(self._impl_obj.storage_state(path=path)))
+        return mapping.from_impl(
+            self._sync(self._impl_obj.storage_state(path=path, indexedDB=indexed_db))
+        )
 
     def wait_for_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """BrowserContext.wait_for_event
 
@@ -13233,7 +13625,7 @@ def expect_console_message(
         self,
         predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["ConsoleMessage"]:
         """BrowserContext.expect_console_message
 
@@ -13265,7 +13657,7 @@ def expect_page(
         self,
         predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager["Page"]:
         """BrowserContext.expect_page
 
@@ -13317,6 +13709,7 @@ def new_cdp_session(self, page: typing.Union["Page", "Frame"]) -> "CDPSession":
 
 
 class CDPSession(SyncBase):
+
     def send(
         self, method: str, params: typing.Optional[typing.Dict] = None
     ) -> typing.Dict:
@@ -13354,6 +13747,7 @@ def detach(self) -> None:
 
 
 class Browser(SyncContextManager):
+
     def on(
         self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
     ) -> None:
@@ -13458,12 +13852,13 @@ def new_context(
             Literal["no-preference", "null", "reduce"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         accept_downloads: typing.Optional[bool] = None,
         default_browser_type: typing.Optional[str] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
@@ -13472,11 +13867,11 @@ def new_context(
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """Browser.new_context
 
@@ -13552,9 +13947,9 @@ def new_context(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -13563,6 +13958,10 @@ def new_context(
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         accept_downloads : Union[bool, None]
             Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
@@ -13623,11 +14022,14 @@ def new_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         BrowserContext
@@ -13656,6 +14058,7 @@ def new_context(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                     acceptDownloads=accept_downloads,
                     defaultBrowserType=default_browser_type,
                     proxy=proxy,
@@ -13699,15 +14102,16 @@ def new_page(
             Literal["dark", "light", "no-preference", "null"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         reduced_motion: typing.Optional[
             Literal["no-preference", "null", "reduce"]
         ] = None,
         accept_downloads: typing.Optional[bool] = None,
         default_browser_type: typing.Optional[str] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
@@ -13716,11 +14120,11 @@ def new_page(
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "Page":
         """Browser.new_page
 
@@ -13780,13 +14184,17 @@ def new_page(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         forced_colors : Union["active", "none", "null", None]
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -13851,11 +14259,14 @@ def new_page(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         Page
@@ -13883,6 +14294,7 @@ def new_page(
                     hasTouch=has_touch,
                     colorScheme=color_scheme,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                     reducedMotion=reduced_motion,
                     acceptDownloads=accept_downloads,
                     defaultBrowserType=default_browser_type,
@@ -13912,9 +14324,9 @@ def close(self, *, reason: typing.Optional[str] = None) -> None:
         In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from
         the browser server.
 
-        **NOTE** This is similar to force quitting the browser. Therefore, you should call `browser_context.close()`
-        on any `BrowserContext`'s you explicitly created earlier with `browser.new_context()` **before** calling
-        `browser.close()`.
+        **NOTE** This is similar to force-quitting the browser. To close pages gracefully and ensure you receive page close
+        events, call `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
 
         The `Browser` object itself is considered to be disposed and cannot be used anymore.
 
@@ -13944,9 +14356,9 @@ def start_tracing(
         self,
         *,
         page: typing.Optional["Page"] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         screenshots: typing.Optional[bool] = None,
-        categories: typing.Optional[typing.Sequence[str]] = None
+        categories: typing.Optional[typing.Sequence[str]] = None,
     ) -> None:
         """Browser.start_tracing
 
@@ -14011,6 +14423,7 @@ def stop_tracing(self) -> bytes:
 
 
 class BrowserType(SyncBase):
+
     @property
     def name(self) -> str:
         """BrowserType.name
@@ -14038,7 +14451,7 @@ def executable_path(self) -> str:
     def launch(
         self,
         *,
-        executable_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         channel: typing.Optional[str] = None,
         args: typing.Optional[typing.Sequence[str]] = None,
         ignore_default_args: typing.Optional[
@@ -14050,15 +14463,14 @@ def launch(
         timeout: typing.Optional[float] = None,
         env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         headless: typing.Optional[bool] = None,
-        devtools: typing.Optional[bool] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        downloads_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         slow_mo: typing.Optional[float] = None,
-        traces_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         chromium_sandbox: typing.Optional[bool] = None,
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
-        ] = None
+        ] = None,
     ) -> "Browser":
         """BrowserType.launch
 
@@ -14096,9 +14508,12 @@ def launch(
             resolved relative to the current working directory. Note that Playwright only works with the bundled Chromium,
             Firefox or WebKit, use at your own risk.
         channel : Union[str, None]
-            Browser distribution channel.  Supported values are "chrome", "chrome-beta", "chrome-dev", "chrome-canary",
-            "msedge", "msedge-beta", "msedge-dev", "msedge-canary". Read more about using
-            [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
+
+            Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
+            "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
         args : Union[Sequence[str], None]
             **NOTE** Use custom browser args at your own risk, as some of them may break Playwright functionality.
 
@@ -14121,12 +14536,7 @@ def launch(
         headless : Union[bool, None]
             Whether to run browser in headless mode. More details for
             [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the
-            `devtools` option is `true`.
-        devtools : Union[bool, None]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the
-            `headless` option will be set `false`.
-            Deprecated: Use [debugging tools](../debug.md) instead.
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
             Network proxy settings.
         downloads_path : Union[pathlib.Path, str, None]
@@ -14144,6 +14554,9 @@ def launch(
             Firefox user preferences. Learn more about the Firefox user preferences at
             [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
 
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+
         Returns
         -------
         Browser
@@ -14162,7 +14575,6 @@ def launch(
                     timeout=timeout,
                     env=mapping.to_impl(env),
                     headless=headless,
-                    devtools=devtools,
                     proxy=proxy,
                     downloadsPath=downloads_path,
                     slowMo=slow_mo,
@@ -14178,7 +14590,7 @@ def launch_persistent_context(
         user_data_dir: typing.Union[str, pathlib.Path],
         *,
         channel: typing.Optional[str] = None,
-        executable_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         args: typing.Optional[typing.Sequence[str]] = None,
         ignore_default_args: typing.Optional[
             typing.Union[bool, typing.Sequence[str]]
@@ -14189,9 +14601,8 @@ def launch_persistent_context(
         timeout: typing.Optional[float] = None,
         env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         headless: typing.Optional[bool] = None,
-        devtools: typing.Optional[bool] = None,
         proxy: typing.Optional[ProxySettings] = None,
-        downloads_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         slow_mo: typing.Optional[float] = None,
         viewport: typing.Optional[ViewportSize] = None,
         screen: typing.Optional[ViewportSize] = None,
@@ -14217,25 +14628,26 @@ def launch_persistent_context(
             Literal["no-preference", "null", "reduce"]
         ] = None,
         forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
         accept_downloads: typing.Optional[bool] = None,
-        traces_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         chromium_sandbox: typing.Optional[bool] = None,
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
         ] = None,
-        record_har_path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_har_omit_content: typing.Optional[bool] = None,
-        record_video_dir: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         record_video_size: typing.Optional[ViewportSize] = None,
         base_url: typing.Optional[str] = None,
         strict_selectors: typing.Optional[bool] = None,
         service_workers: typing.Optional[Literal["allow", "block"]] = None,
         record_har_url_filter: typing.Optional[
-            typing.Union[str, typing.Pattern[str]]
+            typing.Union[typing.Pattern[str], str]
         ] = None,
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -14247,15 +14659,29 @@ def launch_persistent_context(
         Parameters
         ----------
         user_data_dir : Union[pathlib.Path, str]
-            Path to a User Data Directory, which stores browser session data like cookies and local storage. More details for
+            Path to a User Data Directory, which stores browser session data like cookies and local storage. Pass an empty
+            string to create a temporary directory.
+
+            More details for
             [Chromium](https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md#introduction) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Command_Line_Options#User_Profile). Note that Chromium's
-            user data directory is the **parent** directory of the "Profile Path" seen at `chrome://version`. Pass an empty
-            string to use a temporary directory instead.
+            [Firefox](https://wiki.mozilla.org/Firefox/CommandLineOptions#User_profile). Chromium's user data directory is the
+            **parent** directory of the "Profile Path" seen at `chrome://version`.
+
+            Note that browsers do not allow launching multiple instances with the same User Data Directory.
+
+            **NOTE** Chromium/Chrome: Due to recent Chrome policy changes, automating the default Chrome user profile is not
+            supported. Pointing `userDataDir` to Chrome's main "User Data" directory (the profile used for your regular
+            browsing) may result in pages not loading or the browser exiting. Create and use a separate directory (for example,
+            an empty folder) as your automation profile instead. See https://developer.chrome.com/blog/remote-debugging-port
+            for details.
+
         channel : Union[str, None]
-            Browser distribution channel.  Supported values are "chrome", "chrome-beta", "chrome-dev", "chrome-canary",
-            "msedge", "msedge-beta", "msedge-dev", "msedge-canary". Read more about using
-            [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
+
+            Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
+            "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
         executable_path : Union[pathlib.Path, str, None]
             Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is
             resolved relative to the current working directory. Note that Playwright only works with the bundled Chromium,
@@ -14282,12 +14708,7 @@ def launch_persistent_context(
         headless : Union[bool, None]
             Whether to run browser in headless mode. More details for
             [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
-            [Firefox](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode). Defaults to `true` unless the
-            `devtools` option is `true`.
-        devtools : Union[bool, None]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the
-            `headless` option will be set `false`.
-            Deprecated: Use [debugging tools](../debug.md) instead.
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
         proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
             Network proxy settings.
         downloads_path : Union[pathlib.Path, str, None]
@@ -14345,9 +14766,9 @@ def launch_persistent_context(
             Specifies if viewport supports touch events. Defaults to false. Learn more about
             [mobile emulation](../emulation.md#devices).
         color_scheme : Union["dark", "light", "no-preference", "null", None]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See
-            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
-            `'light'`.
+            Emulates [prefers-colors-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+            media feature, supported values are `'light'` and `'dark'`. See `page.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
         reduced_motion : Union["no-preference", "null", "reduce", None]
             Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
@@ -14356,6 +14777,10 @@ def launch_persistent_context(
             Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
             `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
             `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
         accept_downloads : Union[bool, None]
             Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
         traces_dir : Union[pathlib.Path, str, None]
@@ -14365,6 +14790,9 @@ def launch_persistent_context(
         firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
             Firefox user preferences. Learn more about the Firefox user preferences at
             [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
         record_har_path : Union[pathlib.Path, str, None]
             Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
             on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
@@ -14416,11 +14844,14 @@ def launch_persistent_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+
         Returns
         -------
         BrowserContext
@@ -14440,7 +14871,6 @@ def launch_persistent_context(
                     timeout=timeout,
                     env=mapping.to_impl(env),
                     headless=headless,
-                    devtools=devtools,
                     proxy=proxy,
                     downloadsPath=downloads_path,
                     slowMo=slow_mo,
@@ -14464,6 +14894,7 @@ def launch_persistent_context(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                     acceptDownloads=accept_downloads,
                     tracesDir=traces_dir,
                     chromiumSandbox=chromium_sandbox,
@@ -14489,7 +14920,8 @@ def connect_over_cdp(
         *,
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
-        headers: typing.Optional[typing.Dict[str, str]] = None
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        is_local: typing.Optional[bool] = None,
     ) -> "Browser":
         """BrowserType.connect_over_cdp
 
@@ -14499,6 +14931,10 @@ def connect_over_cdp(
 
         **NOTE** Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
 
+        **NOTE** This connection is significantly lower fidelity than the Playwright protocol connection via
+        `browser_type.connect()`. If you are experiencing issues or attempting to use advanced functionality, you
+        probably want to use `browser_type.connect()`.
+
         **Usage**
 
         ```py
@@ -14520,6 +14956,9 @@ def connect_over_cdp(
             on. Defaults to 0.
         headers : Union[Dict[str, str], None]
             Additional HTTP headers to be sent with connect request. Optional.
+        is_local : Union[bool, None]
+            Tells Playwright that it runs on the same host as the CDP server. It will enable certain optimizations that rely
+            upon the file system being the same between Playwright and the Browser.
 
         Returns
         -------
@@ -14533,6 +14972,7 @@ def connect_over_cdp(
                     timeout=timeout,
                     slowMo=slow_mo,
                     headers=mapping.to_impl(headers),
+                    isLocal=is_local,
                 )
             )
         )
@@ -14544,18 +14984,19 @@ def connect(
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        expose_network: typing.Optional[str] = None
+        expose_network: typing.Optional[str] = None,
     ) -> "Browser":
         """BrowserType.connect
 
-        This method attaches Playwright to an existing browser instance. When connecting to another browser launched via
-        `BrowserType.launchServer` in Node.js, the major and minor version needs to match the client version (1.2.3 → is
-        compatible with 1.2.x).
+        This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
+
+        **NOTE** The major and minor version of the Playwright instance that connects needs to match the version of
+        Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).
 
         Parameters
         ----------
         ws_endpoint : str
-            A browser websocket endpoint to connect to.
+            A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.
         timeout : Union[float, None]
             Maximum time in milliseconds to wait for the connection to be established. Defaults to `0` (no timeout).
         slow_mo : Union[float, None]
@@ -14600,6 +15041,7 @@ def connect(
 
 
 class Playwright(SyncBase):
+
     @property
     def devices(self) -> typing.Dict:
         """Playwright.devices
@@ -14691,6 +15133,7 @@ def request(self) -> "APIRequest":
         return mapping.from_impl(self._impl_obj.request)
 
     def __getitem__(self, value: str) -> "BrowserType":
+
         return mapping.from_impl(self._impl_obj.__getitem__(value=value))
 
     def stop(self) -> None:
@@ -14721,6 +15164,7 @@ def stop(self) -> None:
 
 
 class Tracing(SyncBase):
+
     def start(
         self,
         *,
@@ -14728,12 +15172,21 @@ def start(
         title: typing.Optional[str] = None,
         snapshots: typing.Optional[bool] = None,
         screenshots: typing.Optional[bool] = None,
-        sources: typing.Optional[bool] = None
+        sources: typing.Optional[bool] = None,
     ) -> None:
         """Tracing.start
 
         Start tracing.
 
+        **NOTE** You probably want to
+        [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead
+        of using `Tracing.start`.
+
+        The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions
+        (like `expect` calls). We recommend
+        [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace),
+        which includes those assertions and provides a more complete trace for debugging test failures.
+
         **Usage**
 
         ```py
@@ -14747,8 +15200,8 @@ def start(
         ----------
         name : Union[str, None]
             If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
-            `tracesDir` folder specified in `browser_type.launch()`. To specify the final trace zip file name, you need
-            to pass `path` option to `tracing.stop()` instead.
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop()` instead.
         title : Union[str, None]
             Trace name to be shown in the Trace Viewer.
         snapshots : Union[bool, None]
@@ -14806,8 +15259,8 @@ def start_chunk(
             Trace name to be shown in the Trace Viewer.
         name : Union[str, None]
             If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
-            `tracesDir` folder specified in `browser_type.launch()`. To specify the final trace zip file name, you need
-            to pass `path` option to `tracing.stop_chunk()` instead.
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop_chunk()` instead.
         """
 
         return mapping.from_maybe_impl(
@@ -14815,7 +15268,7 @@ def start_chunk(
         )
 
     def stop_chunk(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
     ) -> None:
         """Tracing.stop_chunk
 
@@ -14830,7 +15283,7 @@ def stop_chunk(
         return mapping.from_maybe_impl(self._sync(self._impl_obj.stop_chunk(path=path)))
 
     def stop(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
     ) -> None:
         """Tracing.stop
 
@@ -14844,11 +15297,54 @@ def stop(
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.stop(path=path)))
 
+    def group(
+        self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
+    ) -> None:
+        """Tracing.group
+
+        **NOTE** Use `test.step` instead when available.
+
+        Creates a new group within the trace, assigning any subsequent API calls to this group, until
+        `tracing.group_end()` is called. Groups can be nested and will be visible in the trace viewer.
+
+        **Usage**
+
+        ```py
+        # All actions between group and group_end
+        # will be shown in the trace viewer as a group.
+        await page.context.tracing.group(\"Open Playwright.dev > API\")
+        await page.goto(\"https://playwright.dev/\")
+        await page.get_by_role(\"link\", name=\"API\").click()
+        await page.context.tracing.group_end()
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Group name shown in the trace viewer.
+        location : Union[{file: str, line: Union[int, None], column: Union[int, None]}, None]
+            Specifies a custom location for the group to be shown in the trace viewer. Defaults to the location of the
+            `tracing.group()` call.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.group(name=name, location=location))
+        )
+
+    def group_end(self) -> None:
+        """Tracing.group_end
+
+        Closes the last group created by `tracing.group()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.group_end()))
+
 
 mapping.register(TracingImpl, Tracing)
 
 
 class Locator(SyncBase):
+
     @property
     def page(self) -> "Page":
         """Locator.page
@@ -14917,6 +15413,29 @@ def content_frame(self) -> "FrameLocator":
         """
         return mapping.from_impl(self._impl_obj.content_frame)
 
+    @property
+    def description(self) -> typing.Optional[str]:
+        """Locator.description
+
+        Returns locator description previously set with `locator.describe()`. Returns `null` if no custom
+        description has been set.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_role(\"button\").describe(\"Subscribe button\")
+        print(button.description())  # \"Subscribe button\"
+
+        input = page.get_by_role(\"textbox\")
+        print(input.description())  # None
+        ```
+
+        Returns
+        -------
+        Union[str, None]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.description)
+
     def bounding_box(
         self, *, timeout: typing.Optional[float] = None
     ) -> typing.Optional[FloatRect]:
@@ -14967,7 +15486,7 @@ def check(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.check
 
@@ -15037,7 +15556,8 @@ def click(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.click
 
@@ -15099,7 +15619,12 @@ def click(
             Deprecated: This option will default to `true` in the future.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -15114,6 +15639,7 @@ def click(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -15130,7 +15656,8 @@ def dblclick(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.dblclick
 
@@ -15173,7 +15700,12 @@ def dblclick(
             Deprecated: This option has no effect.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -15187,6 +15719,7 @@ def dblclick(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -15196,7 +15729,7 @@ def dispatch_event(
         type: str,
         event_init: typing.Optional[typing.Dict] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Locator.dispatch_event
 
@@ -15232,7 +15765,6 @@ def dispatch_event(
         You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
 
         ```py
-        # note you can only create data_transfer in chromium and firefox
         data_transfer = page.evaluate_handle(\"new DataTransfer()\")
         locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
         ```
@@ -15261,7 +15793,7 @@ def evaluate(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> typing.Any:
         """Locator.evaluate
 
@@ -15278,9 +15810,11 @@ def evaluate(
 
         **Usage**
 
+        Passing argument to `expression`:
+
         ```py
-        tweets = page.locator(\".tweet .retweets\")
-        assert tweets.evaluate(\"node => node.innerText\") == \"10 retweets\"
+        result = page.get_by_testid(\"myId\").evaluate(\"(element, [x, y]) => element.textContent + ' ' + x * y\", [7, 8])
+        print(result) # prints \"myId text 56\"
         ```
 
         Parameters
@@ -15291,8 +15825,8 @@ def evaluate(
         arg : Union[Any, None]
             Optional argument to pass to `expression`.
         timeout : Union[float, None]
-            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
         Returns
         -------
@@ -15356,7 +15890,7 @@ def evaluate_handle(
         expression: str,
         arg: typing.Optional[typing.Any] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> "JSHandle":
         """Locator.evaluate_handle
 
@@ -15385,8 +15919,8 @@ def evaluate_handle(
         arg : Union[Any, None]
             Optional argument to pass to `expression`.
         timeout : Union[float, None]
-            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
         Returns
         -------
@@ -15407,7 +15941,7 @@ def fill(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Locator.fill
 
@@ -15458,7 +15992,7 @@ def clear(
         *,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> None:
         """Locator.clear
 
@@ -15504,10 +16038,10 @@ def locator(
         self,
         selector_or_locator: typing.Union[str, "Locator"],
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
     ) -> "Locator":
         """Locator.locator
 
@@ -15562,7 +16096,7 @@ def get_by_alt_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_alt_text
 
@@ -15599,7 +16133,7 @@ def get_by_label(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_label
 
@@ -15640,7 +16174,7 @@ def get_by_placeholder(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_placeholder
 
@@ -15769,10 +16303,10 @@ def get_by_role(
         expanded: typing.Optional[bool] = None,
         include_hidden: typing.Optional[bool] = None,
         level: typing.Optional[int] = None,
-        name: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         pressed: typing.Optional[bool] = None,
         selected: typing.Optional[bool] = None,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_role
 
@@ -15826,6 +16360,7 @@ def get_by_role(
 
             **NOTE** Unlike most other attributes, `disabled` is inherited through the DOM hierarchy. Learn more about
             [`aria-disabled`](https://www.w3.org/TR/wai-aria-1.2/#aria-disabled).
+
         expanded : Union[bool, None]
             An attribute that is usually set by `aria-expanded`.
 
@@ -15919,7 +16454,7 @@ def get_by_text(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_text
 
@@ -15983,7 +16518,7 @@ def get_by_title(
         self,
         text: typing.Union[str, typing.Pattern[str]],
         *,
-        exact: typing.Optional[bool] = None
+        exact: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.get_by_title
 
@@ -16100,13 +16635,39 @@ def nth(self, index: int) -> "Locator":
 
         return mapping.from_impl(self._impl_obj.nth(index=index))
 
+    def describe(self, description: str) -> "Locator":
+        """Locator.describe
+
+        Describes the locator, description is used in the trace viewer and reports. Returns the locator pointing to the
+        same element.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_test_id(\"btn-sub\").describe(\"Subscribe button\")
+        button.click()
+        ```
+
+        Parameters
+        ----------
+        description : str
+            Locator description.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.describe(description=description))
+
     def filter(
         self,
         *,
-        has_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
-        has_not_text: typing.Optional[typing.Union[str, typing.Pattern[str]]] = None,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
         has: typing.Optional["Locator"] = None,
-        has_not: typing.Optional["Locator"] = None
+        has_not: typing.Optional["Locator"] = None,
+        visible: typing.Optional[bool] = None,
     ) -> "Locator":
         """Locator.filter
 
@@ -16147,6 +16708,8 @@ def filter(
             outer one. For example, `article` that does not have `div` matches `<article><span>Playwright</span></article>`.
 
             Note that outer and inner locators must belong to the same frame. Inner locator must not contain `FrameLocator`s.
+        visible : Union[bool, None]
+            Only matches visible or invisible elements.
 
         Returns
         -------
@@ -16159,23 +16722,31 @@ def filter(
                 hasNotText=has_not_text,
                 has=has._impl_obj if has else None,
                 hasNot=has_not._impl_obj if has_not else None,
+                visible=visible,
             )
         )
 
     def or_(self, locator: "Locator") -> "Locator":
         """Locator.or_
 
-        Creates a locator that matches either of the two locators.
+        Creates a locator matching all elements that match one or both of the two locators.
+
+        Note that when both locators match something, the resulting locator will have multiple matches, potentially causing
+        a [locator strictness](https://playwright.dev/python/docs/locators#strictness) violation.
 
         **Usage**
 
         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.
 
+        **NOTE** If both \"New email\" button and security dialog appear on screen, the \"or\" locator will match both of them,
+        possibly throwing the [\"strict mode violation\" error](https://playwright.dev/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
         ```py
         new_email = page.get_by_role(\"button\", name=\"New\")
         dialog = page.get_by_text(\"Confirm security settings\")
-        expect(new_email.or_(dialog)).to_be_visible()
+        expect(new_email.or_(dialog).first).to_be_visible()
         if (dialog.is_visible()):
           page.get_by_role(\"button\", name=\"Dismiss\").click()
         new_email.click()
@@ -16203,7 +16774,7 @@ def and_(self, locator: "Locator") -> "Locator":
         The following example finds a button with a specific title.
 
         ```py
-        button = page.get_by_role(\"button\").and_(page.getByTitle(\"Subscribe\"))
+        button = page.get_by_role(\"button\").and_(page.get_by_title(\"Subscribe\"))
         ```
 
         Parameters
@@ -16255,9 +16826,13 @@ def all(self) -> typing.List["Locator"]:
         elements.
 
         **NOTE** `locator.all()` does not wait for elements to match the locator, and instead immediately returns
-        whatever is present in the page.  When the list of elements changes dynamically, `locator.all()` will
-        produce unpredictable and flaky results.  When the list of elements is stable, but loaded dynamically, wait for the
-        full list to finish loading before calling `locator.all()`.
+        whatever is present in the page.
+
+        When the list of elements changes dynamically, `locator.all()` will produce unpredictable and flaky
+        results.
+
+        When the list of elements is stable, but loaded dynamically, wait for the full list to finish loading before
+        calling `locator.all()`.
 
         **Usage**
 
@@ -16303,7 +16878,8 @@ def drag_to(
         timeout: typing.Optional[float] = None,
         trial: typing.Optional[bool] = None,
         source_position: typing.Optional[Position] = None,
-        target_position: typing.Optional[Position] = None
+        target_position: typing.Optional[Position] = None,
+        steps: typing.Optional[int] = None,
     ) -> None:
         """Locator.drag_to
 
@@ -16350,6 +16926,9 @@ def drag_to(
         target_position : Union[{x: float, y: float}, None]
             Drops on the target element at this point relative to the top-left corner of the element's padding box. If not
             specified, some visible point of the element is used.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
         return mapping.from_maybe_impl(
@@ -16362,6 +16941,7 @@ def drag_to(
                     trial=trial,
                     sourcePosition=source_position,
                     targetPosition=target_position,
+                    steps=steps,
                 )
             )
         )
@@ -16403,7 +16983,7 @@ def hover(
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
         force: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.hover
 
@@ -16446,7 +17026,9 @@ def hover(
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -16602,7 +17184,9 @@ def is_disabled(self, *, timeout: typing.Optional[float] = None) -> bool:
     def is_editable(self, *, timeout: typing.Optional[float] = None) -> bool:
         """Locator.is_editable
 
-        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable). If the target element is not an `<input>`,
+        `<textarea>`, `<select>`, `[contenteditable]` and does not have a role allowing `[aria-readonly]`, this method
+        throws an error.
 
         **NOTE** If you need to assert that an element is editable, prefer `locator_assertions.to_be_editable()` to
         avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
@@ -16719,7 +17303,7 @@ def press(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.press
 
@@ -16784,7 +17368,7 @@ def screenshot(
         *,
         timeout: typing.Optional[float] = None,
         type: typing.Optional[Literal["jpeg", "png"]] = None,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
         quality: typing.Optional[int] = None,
         omit_background: typing.Optional[bool] = None,
         animations: typing.Optional[Literal["allow", "disabled"]] = None,
@@ -16792,7 +17376,7 @@ def screenshot(
         scale: typing.Optional[Literal["css", "device"]] = None,
         mask: typing.Optional[typing.Sequence["Locator"]] = None,
         mask_color: typing.Optional[str] = None,
-        style: typing.Optional[str] = None
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """Locator.screenshot
 
@@ -16855,7 +17439,9 @@ def screenshot(
             Defaults to `"device"`.
         mask : Union[Sequence[Locator], None]
             Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
-            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box.
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
         mask_color : Union[str, None]
             Specify the color of the overlay box for masked elements, in
             [CSS color format](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). Default color is pink `#FF00FF`.
@@ -16887,6 +17473,61 @@ def screenshot(
             )
         )
 
+    def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
+        """Locator.aria_snapshot
+
+        Captures the aria snapshot of the given element. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots) and
+        `locator_assertions.to_match_aria_snapshot()` for the corresponding assertion.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"link\").aria_snapshot()
+        ```
+
+        **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\"
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.aria_snapshot(timeout=timeout))
+        )
+
     def scroll_into_view_if_needed(
         self, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -16920,7 +17561,7 @@ def select_option(
         ] = None,
         timeout: typing.Optional[float] = None,
         no_wait_after: typing.Optional[bool] = None,
-        force: typing.Optional[bool] = None
+        force: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """Locator.select_option
 
@@ -16944,9 +17585,9 @@ def select_option(
 
         ```html
         <select multiple>
-          <option value=\"red\">Red</div>
-          <option value=\"green\">Green</div>
-          <option value=\"blue\">Blue</div>
+          <option value=\"red\">Red</option>
+          <option value=\"green\">Green</option>
+          <option value=\"blue\">Blue</option>
         </select>
         ```
 
@@ -17003,7 +17644,7 @@ def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Locator.select_text
 
@@ -17038,7 +17679,7 @@ def set_input_files(
         ],
         *,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.set_input_files
 
@@ -17109,11 +17750,12 @@ def tap(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.tap
 
-        Perform a tap gesture on the element matching the locator.
+        Perform a tap gesture on the element matching the locator. For examples of emulating other gestures by manually
+        dispatching touch events, see the [emulating legacy touch events](https://playwright.dev/python/docs/touch-events) page.
 
         **Details**
 
@@ -17148,7 +17790,9 @@ def tap(
             Deprecated: This option has no effect.
         trial : Union[bool, None]
             When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
-            to `false`. Useful to wait until the element is ready for the action without performing it.
+            to `false`. Useful to wait until the element is ready for the action without performing it. Note that keyboard
+            `modifiers` will be pressed regardless of `trial` to allow testing elements which are only visible when those keys
+            are pressed.
         """
 
         return mapping.from_maybe_impl(
@@ -17195,7 +17839,7 @@ def type(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.type
 
@@ -17234,7 +17878,7 @@ def press_sequentially(
         *,
         delay: typing.Optional[float] = None,
         timeout: typing.Optional[float] = None,
-        no_wait_after: typing.Optional[bool] = None
+        no_wait_after: typing.Optional[bool] = None,
     ) -> None:
         """Locator.press_sequentially
 
@@ -17290,7 +17934,7 @@ def uncheck(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.uncheck
 
@@ -17395,7 +18039,7 @@ def wait_for(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> None:
         """Locator.wait_for
 
@@ -17438,7 +18082,7 @@ def set_checked(
         timeout: typing.Optional[float] = None,
         force: typing.Optional[bool] = None,
         no_wait_after: typing.Optional[bool] = None,
-        trial: typing.Optional[bool] = None
+        trial: typing.Optional[bool] = None,
     ) -> None:
         """Locator.set_checked
 
@@ -17511,6 +18155,7 @@ def highlight(self) -> None:
 
 
 class APIResponse(SyncBase):
+
     @property
     def ok(self) -> bool:
         """APIResponse.ok
@@ -17635,6 +18280,7 @@ def dispose(self) -> None:
 
 
 class APIRequestContext(SyncBase):
+
     def dispose(self, *, reason: typing.Optional[str] = None) -> None:
         """APIRequestContext.dispose
 
@@ -17669,7 +18315,7 @@ def delete(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.delete
 
@@ -17752,7 +18398,7 @@ def head(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.head
 
@@ -17835,7 +18481,7 @@ def get(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.get
 
@@ -17930,7 +18576,7 @@ def patch(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.patch
 
@@ -18013,7 +18659,7 @@ def put(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.put
 
@@ -18096,7 +18742,7 @@ def post(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.post
 
@@ -18211,7 +18857,7 @@ def fetch(
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
         max_redirects: typing.Optional[int] = None,
-        max_retries: typing.Optional[int] = None
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.fetch
 
@@ -18223,7 +18869,7 @@ def fetch(
         JSON objects can be passed directly to the request:
 
         The common way to send file(s) in the body of a request is to upload them as form fields with `multipart/form-data`
-        encoding. Use `FormData` to construct request body and pass it to the request as `multipart` parameter:
+        encoding, by specifiying the `multipart` parameter:
 
         ```python
         api_request_context.fetch(
@@ -18300,7 +18946,10 @@ def fetch(
         )
 
     def storage_state(
-        self, *, path: typing.Optional[typing.Union[str, pathlib.Path]] = None
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
     ) -> StorageState:
         """APIRequestContext.storage_state
 
@@ -18312,19 +18961,24 @@ def storage_state(
         path : Union[pathlib.Path, str, None]
             The file path to save the storage state to. If `path` is a relative path, then it is resolved relative to current
             working directory. If no path is provided, storage state is still returned, but won't be saved to the disk.
+        indexed_db : Union[bool, None]
+            Set to `true` to include IndexedDB in the storage state snapshot.
 
         Returns
         -------
         {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        return mapping.from_impl(self._sync(self._impl_obj.storage_state(path=path)))
+        return mapping.from_impl(
+            self._sync(self._impl_obj.storage_state(path=path, indexedDB=indexed_db))
+        )
 
 
 mapping.register(APIRequestContextImpl, APIRequestContext)
 
 
 class APIRequest(SyncBase):
+
     def new_context(
         self,
         *,
@@ -18338,7 +18992,9 @@ def new_context(
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
         ] = None,
-        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
     ) -> "APIRequestContext":
         """APIRequest.new_context
 
@@ -18384,11 +19040,21 @@ def new_context(
             `passphrase` property should be provided if the certificate is encrypted. The `origin` property should be provided
             with an exact match to the request origin that the certificate is valid for.
 
-            **NOTE** Using Client Certificates in combination with Proxy Servers is not supported.
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
 
             **NOTE** When using WebKit on macOS, accessing `localhost` will not pick up client certificates. You can make it
             work by replacing `localhost` with `local.playwright`.
 
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        max_redirects : Union[int, None]
+            Maximum number of request redirects that will be followed automatically. An error will be thrown if the number is
+            exceeded. Defaults to `20`. Pass `0` to not follow redirects. This can be overwritten for each request
+            individually.
+
         Returns
         -------
         APIRequestContext
@@ -18406,6 +19072,8 @@ def new_context(
                     timeout=timeout,
                     storageState=storage_state,
                     clientCertificates=client_certificates,
+                    failOnStatusCode=fail_on_status_code,
+                    maxRedirects=max_redirects,
                 )
             )
         )
@@ -18415,11 +19083,12 @@ def new_context(
 
 
 class PageAssertions(SyncBase):
+
     def to_have_title(
         self,
         title_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """PageAssertions.to_have_title
 
@@ -18456,7 +19125,7 @@ def not_to_have_title(
         self,
         title_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """PageAssertions.not_to_have_title
 
@@ -18484,7 +19153,7 @@ def to_have_url(
         url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
         *,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.to_have_url
 
@@ -18508,7 +19177,7 @@ def to_have_url(
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         ignore_case : Union[bool, None]
             Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
-            expression flag if specified.
+            expression parameter if specified. A provided predicate ignores this flag.
         """
         __tracebackhide__ = True
 
@@ -18525,7 +19194,7 @@ def not_to_have_url(
         url_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.not_to_have_url
 
@@ -18556,6 +19225,7 @@ def not_to_have_url(
 
 
 class LocatorAssertions(SyncBase):
+
     def to_contain_text(
         self,
         expected: typing.Union[
@@ -18568,7 +19238,7 @@ def to_contain_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_contain_text
 
@@ -18613,7 +19283,7 @@ def to_contain_text(
         from playwright.sync_api import expect
 
         # ✓ Contains the right items in the right order
-        expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\", \"Text 4\"])
+        expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\"])
 
         # ✖ Wrong order
         expect(page.locator(\"ul > li\")).to_contain_text([\"Text 3\", \"Text 2\"])
@@ -18662,7 +19332,7 @@ def not_to_contain_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.not_to_contain_text
 
@@ -18699,7 +19369,7 @@ def to_have_attribute(
         value: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_attribute
 
@@ -18742,7 +19412,7 @@ def not_to_have_attribute(
         value: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_attribute
 
@@ -18780,33 +19450,35 @@ def to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_class
 
-        Ensures the `Locator` points to an element with given CSS classes. This needs to be a full match or using a relaxed
-        regular expression.
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes use `locator_assertions.to_contain_class()`.
 
         **Usage**
 
         ```html
-        <div class='selected row' id='component'></div>
+        <div class='middle selected row' id='component'></div>
         ```
 
         ```py
         from playwright.sync_api import expect
 
         locator = page.locator(\"#component\")
-        expect(locator).to_have_class(re.compile(r\"selected\"))
-        expect(locator).to_have_class(\"selected row\")
+        expect(locator).to_have_class(\"middle selected row\")
+        expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
         ```
 
-        Note that if array is passed as an expected value, entire lists of elements can be asserted:
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
 
         ```py
         from playwright.sync_api import expect
 
-        locator = page.locator(\"list > .component\")
+        locator = page.locator(\".list > .component\")
         expect(locator).to_have_class([\"component\", \"component selected\", \"component\"])
         ```
 
@@ -18837,7 +19509,7 @@ def not_to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_class
 
@@ -18860,6 +19532,96 @@ def not_to_have_class(
             )
         )
 
+    def to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_class
+
+        Ensures the `Locator` points to an element with given CSS classes. All classes from the asserted value, separated
+        by spaces, must be present in the
+        [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
+
+        **Usage**
+
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.locator(\"#component\")
+        expect(locator).to_contain_class(\"middle selected row\")
+        expect(locator).to_contain_class(\"selected\")
+        expect(locator).to_contain_class(\"row middle\")
+        ```
+
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class lists. Each element's class attribute is matched against the corresponding class in the array:
+
+        ```html
+        <div class='list'>
+          <div class='component inactive'></div>
+          <div class='component active'></div>
+          <div class='component inactive'></div>
+        </div>
+        ```
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.locator(\".list > .component\")
+        await expect(locator).to_contain_class([\"inactive\", \"active\", \"inactive\"])
+        ```
+
+        Parameters
+        ----------
+        expected : Union[Sequence[str], str]
+            A string containing expected class names, separated by spaces, or a list of such strings to assert multiple
+            elements.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_contain_class(
+                    expected=mapping.to_impl(expected), timeout=timeout
+                )
+            )
+        )
+
+    def not_to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_class
+
+        The opposite of `locator_assertions.to_contain_class()`.
+
+        Parameters
+        ----------
+        expected : Union[Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_contain_class(
+                    expected=mapping.to_impl(expected), timeout=timeout
+                )
+            )
+        )
+
     def to_have_count(
         self, count: int, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -18914,7 +19676,7 @@ def to_have_css(
         name: str,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_css
 
@@ -18951,7 +19713,7 @@ def not_to_have_css(
         name: str,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_css
 
@@ -18978,7 +19740,7 @@ def to_have_id(
         self,
         id: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_id
 
@@ -19010,7 +19772,7 @@ def not_to_have_id(
         self,
         id: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_id
 
@@ -19095,7 +19857,7 @@ def to_have_value(
         self,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_value
 
@@ -19129,7 +19891,7 @@ def not_to_have_value(
         self,
         value: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_value
 
@@ -19156,7 +19918,7 @@ def to_have_values(
             typing.Sequence[typing.Union[typing.Pattern[str], str]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_values
 
@@ -19209,7 +19971,7 @@ def not_to_have_values(
             typing.Sequence[typing.Union[typing.Pattern[str], str]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_values
 
@@ -19244,7 +20006,7 @@ def to_have_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_have_text
 
@@ -19337,7 +20099,7 @@ def not_to_have_text(
         *,
         use_inner_text: typing.Optional[bool] = None,
         timeout: typing.Optional[float] = None,
-        ignore_case: typing.Optional[bool] = None
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_text
 
@@ -19372,7 +20134,7 @@ def to_be_attached(
         self,
         *,
         attached: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_attached
 
@@ -19403,7 +20165,8 @@ def to_be_checked(
         self,
         *,
         timeout: typing.Optional[float] = None,
-        checked: typing.Optional[bool] = None
+        checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_be_checked
 
@@ -19423,18 +20186,27 @@ def to_be_checked(
         timeout : Union[float, None]
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.to_be_checked(timeout=timeout, checked=checked))
+            self._sync(
+                self._impl_obj.to_be_checked(
+                    timeout=timeout, checked=checked, indeterminate=indeterminate
+                )
+            )
         )
 
     def not_to_be_attached(
         self,
         *,
         attached: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_attached
 
@@ -19519,7 +20291,7 @@ def to_be_editable(
         self,
         *,
         editable: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_editable
 
@@ -19552,7 +20324,7 @@ def not_to_be_editable(
         self,
         *,
         editable: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_editable
 
@@ -19617,7 +20389,7 @@ def to_be_enabled(
         self,
         *,
         enabled: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_enabled
 
@@ -19648,7 +20420,7 @@ def not_to_be_enabled(
         self,
         *,
         enabled: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_enabled
 
@@ -19714,7 +20486,7 @@ def to_be_visible(
         self,
         *,
         visible: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_visible
 
@@ -19755,7 +20527,7 @@ def not_to_be_visible(
         self,
         *,
         visible: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_visible
 
@@ -19820,7 +20592,7 @@ def to_be_in_viewport(
         self,
         *,
         ratio: typing.Optional[float] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_be_in_viewport
 
@@ -19859,7 +20631,7 @@ def not_to_be_in_viewport(
         self,
         *,
         ratio: typing.Optional[float] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_be_in_viewport
 
@@ -19884,7 +20656,7 @@ def to_have_accessible_description(
         description: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_accessible_description
 
@@ -19923,7 +20695,7 @@ def not_to_have_accessible_description(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_accessible_description
 
@@ -19954,7 +20726,7 @@ def to_have_accessible_name(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_accessible_name
 
@@ -19993,7 +20765,7 @@ def not_to_have_accessible_name(
         name: typing.Union[str, typing.Pattern[str]],
         *,
         ignore_case: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_accessible_name
 
@@ -20106,7 +20878,7 @@ def to_have_role(
             "treeitem",
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.to_have_role
 
@@ -20135,6 +20907,76 @@ def to_have_role(
             self._sync(self._impl_obj.to_have_role(role=role, timeout=timeout))
         )
 
+    def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
+
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_accessible_error_message(
+                    errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def not_to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
+
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_accessible_error_message(
+                    errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
     def not_to_have_role(
         self,
         role: Literal[
@@ -20222,7 +21064,7 @@ def not_to_have_role(
             "treeitem",
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_role
 
@@ -20241,11 +21083,68 @@ def not_to_have_role(
             self._sync(self._impl_obj.not_to_have_role(role=role, timeout=timeout))
         )
 
+    def to_match_aria_snapshot(
+        self, expected: str, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        """LocatorAssertions.to_match_aria_snapshot
+
+        Asserts that the target element matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```py
+        page.goto(\"https://demo.playwright.dev/todomvc/\")
+        expect(page.locator('body')).to_match_aria_snapshot('''
+          - heading \"todos\"
+          - textbox \"What needs to be done?\"
+        ''')
+        ```
+
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_match_aria_snapshot(
+                    expected=expected, timeout=timeout
+                )
+            )
+        )
+
+    def not_to_match_aria_snapshot(
+        self, expected: str, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        """LocatorAssertions.not_to_match_aria_snapshot
+
+        The opposite of `locator_assertions.to_match_aria_snapshot()`.
+
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_match_aria_snapshot(
+                    expected=expected, timeout=timeout
+                )
+            )
+        )
+
 
 mapping.register(LocatorAssertionsImpl, LocatorAssertions)
 
 
 class APIResponseAssertions(SyncBase):
+
     def to_be_ok(self) -> None:
         """APIResponseAssertions.to_be_ok
 
diff --git a/pyproject.toml b/pyproject.toml
index 34504380f..1ff674eab 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,57 @@
 [build-system]
-requires = ["setuptools==68.2.2", "setuptools-scm==8.1.0", "wheel==0.42.0", "auditwheel==5.4.0"]
+requires = ["setuptools==80.9.0", "setuptools-scm==8.3.1", "wheel==0.45.1", "auditwheel==6.2.0"]
 build-backend = "setuptools.build_meta"
 
+[project]
+name = "playwright"
+description = "A high-level API to automate web browsers"
+authors = [
+    {name = "Microsoft Corporation"}
+]
+readme = "README.md"
+license = "Apache-2.0"
+dynamic = ["version"]
+requires-python = ">=3.9"
+# Please when changing dependencies run the following commands to update requirements.txt:
+# - pip install uv==0.5.4
+# - uv pip compile pyproject.toml -o requirements.txt
+dependencies = [
+    "pyee>=13,<14",
+    "greenlet>=3.1.1,<4.0.0"
+]
+classifiers = [
+    "Topic :: Software Development :: Testing",
+    "Topic :: Internet :: WWW/HTTP :: Browsers",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+homepage = "https://github.com/Microsoft/playwright-python"
+"Release notes" = "https://github.com/microsoft/playwright-python/releases"
+
+[project.scripts]
+playwright = "playwright.__main__:main"
+
+[project.entry-points.pyinstaller40]
+hook-dirs = "playwright._impl.__pyinstaller:get_hook_dirs"
+
+[tool.setuptools]
+packages = [
+    "playwright",
+    "playwright.async_api",
+    "playwright.sync_api",
+    "playwright._impl",
+    "playwright._impl.__pyinstaller",
+]
+include-package-data = true
+
 [tool.setuptools_scm]
 version_file = "playwright/_repo_version.py"
 
@@ -15,10 +65,12 @@ markers = [
 ]
 junit_family = "xunit2"
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
 
 [tool.mypy]
 ignore_missing_imports = true
-python_version = "3.8"
+python_version = "3.9"
 warn_unused_ignores = false
 warn_redundant_casts = true
 warn_unused_configs = true
@@ -35,10 +87,12 @@ profile = "black"
 
 [tool.pyright]
 include = ["playwright", "tests", "scripts"]
-pythonVersion = "3.8"
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", "./build"]
+pythonVersion = "3.9"
 reportMissingImports = false
 reportTypedDictNotRequiredAccess = false
 reportCallInDefaultInitializer = true
 reportOptionalSubscript = false
 reportUnboundVariable = false
 strictParameterNoneValue = false
+reportIncompatibleVariableOverride = false
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 000000000..75d362fe8
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,8 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+greenlet==3.2.4
+    # via playwright (pyproject.toml)
+pyee==13.0.0
+    # via playwright (pyproject.toml)
+typing-extensions==4.14.1
+    # via pyee
diff --git a/scripts/documentation_provider.py b/scripts/documentation_provider.py
index 82e3f4bb6..a842a1aad 100644
--- a/scripts/documentation_provider.py
+++ b/scripts/documentation_provider.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import json
+import pathlib
 import re
 import subprocess
 from sys import stderr
@@ -96,9 +97,9 @@ def _add_link(self, kind: str, clazz: str, member: str, alias: str) -> None:
         new_name = to_snake_case(alias)
         if kind == "event":
             new_name = new_name.lower()
-            self.links[
-                f"[`event: {clazz}.{member}`]"
-            ] = f"`{var_name}.on('{new_name}')`"
+            self.links[f"[`event: {clazz}.{member}`]"] = (
+                f"`{var_name}.on('{new_name}')`"
+            )
         elif kind == "property":
             self.links[f"[`property: {clazz}.{member}`]"] = f"`{var_name}.{new_name}`"
         else:
@@ -132,7 +133,11 @@ def print_entry(
         doc_is_property = (
             not method.get("async") and not len(method["args"]) and "type" in method
         )
-        if method["name"].startswith("is_") or method["name"].startswith("as_"):
+        if (
+            method["name"].startswith("is_")
+            or method["name"].startswith("as_")
+            or method["name"] == "connect_to_server"
+        ):
             doc_is_property = False
         if doc_is_property != is_property:
             self.errors.add(f"Method vs property mismatch: {fqname}")
@@ -355,6 +360,8 @@ def serialize_python_type(self, value: Any, direction: str) -> str:
         match = re.match(r"^<class '((?:pathlib\.)?\w+)'>$", str_value)
         if match:
             return match.group(1)
+        if str_value == str(pathlib.Path):
+            return "pathlib.Path"
         match = re.match(
             r"playwright._impl._event_context_manager.EventContextManagerImpl\[playwright._impl.[^.]+.(.*)\]",
             str_value,
@@ -485,7 +492,7 @@ def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
             return "int"
         if type_name.lower() == "string":
             return "str"
-        if type_name == "any" or type_name == "Serializable":
+        if type_name == "any" or type_name == "unknown" or type_name == "Serializable":
             return "Any"
         if type_name == "Object":
             return "Dict"
diff --git a/scripts/example_async.py b/scripts/example_async.py
new file mode 100644
index 000000000..9fe5b6b11
--- /dev/null
+++ b/scripts/example_async.py
@@ -0,0 +1,30 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+
+from playwright.async_api import async_playwright
+
+
+async def main() -> None:
+    async with async_playwright() as p:
+        for browser_type in [p.chromium, p.firefox, p.webkit]:
+            browser = await browser_type.launch()
+            page = await browser.new_page()
+            assert await page.evaluate("() => 11 * 11") == 121
+            await browser.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/scripts/example_sync.py b/scripts/example_sync.py
new file mode 100644
index 000000000..0c65a5f07
--- /dev/null
+++ b/scripts/example_sync.py
@@ -0,0 +1,28 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import sync_playwright
+
+
+def main() -> None:
+    with sync_playwright() as p:
+        for browser_type in [p.chromium, p.firefox, p.webkit]:
+            browser = browser_type.launch()
+            page = browser.new_page()
+            assert page.evaluate("() => 11 * 11") == 121
+            browser.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/expected_api_mismatch.txt b/scripts/expected_api_mismatch.txt
index c101bba16..f47493440 100644
--- a/scripts/expected_api_mismatch.txt
+++ b/scripts/expected_api_mismatch.txt
@@ -4,9 +4,6 @@
 Parameter not documented: Browser.new_context(default_browser_type=)
 Parameter not documented: Browser.new_page(default_browser_type=)
 
-# We don't expand the type of the return value here.
-Parameter type mismatch in Accessibility.snapshot(return=): documented as Union[{role: str, name: str, value: Union[float, str], description: str, keyshortcuts: str, roledescription: str, valuetext: str, disabled: bool, expanded: bool, focused: bool, modal: bool, multiline: bool, multiselectable: bool, readonly: bool, required: bool, selected: bool, checked: Union["mixed", bool], pressed: Union["mixed", bool], level: int, valuemin: float, valuemax: float, autocomplete: str, haspopup: str, invalid: str, orientation: str, children: List[Dict]}, None], code has Union[Dict, None]
-
 # One vs two arguments in the callback, Python explicitly unions.
 Parameter type mismatch in BrowserContext.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
 Parameter type mismatch in BrowserContext.unroute(handler=): documented as Union[Callable[[Route, Request], Union[Any, Any]], None], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
@@ -15,3 +12,8 @@ Parameter type mismatch in Page.unroute(handler=): documented as Union[Callable[
 
 # One vs two arguments in the callback, Python explicitly unions.
 Parameter type mismatch in Page.add_locator_handler(handler=): documented as Callable[[Locator], Any], code has Union[Callable[[Locator], Any], Callable[[], Any]]
+
+Parameter type mismatch in BrowserContext.route_web_socket(handler=): documented as Callable[[WebSocketRoute], Union[Any, Any]], code has Callable[[WebSocketRoute], Any]
+Parameter type mismatch in Page.route_web_socket(handler=): documented as Callable[[WebSocketRoute], Union[Any, Any]], code has Callable[[WebSocketRoute], Any]
+Parameter type mismatch in WebSocketRoute.on_close(handler=): documented as Callable[[Union[int, undefined]], Union[Any, Any]], code has Callable[[Union[int, None], Union[str, None]], Any]
+Parameter type mismatch in WebSocketRoute.on_message(handler=): documented as Callable[[str], Union[Any, Any]], code has Callable[[Union[bytes, str]], Any]
diff --git a/scripts/generate_api.py b/scripts/generate_api.py
index 7966dbc25..3d2f45156 100644
--- a/scripts/generate_api.py
+++ b/scripts/generate_api.py
@@ -18,7 +18,6 @@
 from typing import Any, Dict, List, Match, Optional, Union, cast, get_args, get_origin
 from typing import get_type_hints as typing_get_type_hints
 
-from playwright._impl._accessibility import Accessibility
 from playwright._impl._assertions import (
     APIResponseAssertions,
     LocatorAssertions,
@@ -40,7 +39,13 @@
 from playwright._impl._input import Keyboard, Mouse, Touchscreen
 from playwright._impl._js_handle import JSHandle, Serializable
 from playwright._impl._locator import FrameLocator, Locator
-from playwright._impl._network import Request, Response, Route, WebSocket
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocket,
+    WebSocketRoute,
+)
 from playwright._impl._page import Page, Worker
 from playwright._impl._playwright import Playwright
 from playwright._impl._selectors import Selectors
@@ -51,6 +56,7 @@
 
 def process_type(value: Any, param: bool = False) -> str:
     value = str(value)
+    value = re.sub("pathlib._local.Path", "pathlib.Path", value)
     value = re.sub(r"<class '([^']+)'>", r"\1", value)
     value = re.sub(r"NoneType", "None", value)
     value = re.sub(r"playwright\._impl\._api_structures.([\w]+)", r"\1", value)
@@ -218,8 +224,7 @@ def return_value(value: Any) -> List[str]:
 from typing import Literal
 
 
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
-from playwright._impl._api_structures import Cookie, SetCookieParam, FloatRect, FilePayload, Geolocation, HttpCredentials, PdfMargins, Position, ProxySettings, ResourceTiming, SourceLocation, StorageState, ClientCertificate, ViewportSize, RemoteAddr, SecurityDetails, RequestSizes, NameValue
+from playwright._impl._api_structures import Cookie, SetCookieParam, FloatRect, FilePayload, Geolocation, HttpCredentials, PdfMargins, Position, ProxySettings, ResourceTiming, SourceLocation, StorageState, ClientCertificate, ViewportSize, RemoteAddr, SecurityDetails, RequestSizes, NameValue, TracingGroupLocation
 from playwright._impl._browser import Browser as BrowserImpl
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
@@ -233,7 +238,7 @@ def return_value(value: Any) -> List[str]:
 from playwright._impl._frame import Frame as FrameImpl
 from playwright._impl._input import Keyboard as KeyboardImpl, Mouse as MouseImpl, Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
-from playwright._impl._network import Request as RequestImpl, Response as ResponseImpl, Route as RouteImpl, WebSocket as WebSocketImpl
+from playwright._impl._network import Request as RequestImpl, Response as ResponseImpl, Route as RouteImpl, WebSocket as WebSocketImpl, WebSocketRoute as WebSocketRouteImpl
 from playwright._impl._page import Page as PageImpl, Worker as WorkerImpl
 from playwright._impl._web_error import WebError as WebErrorImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
@@ -252,12 +257,12 @@ def return_value(value: Any) -> List[str]:
     Response,
     Route,
     WebSocket,
+    WebSocketRoute,
     Keyboard,
     Mouse,
     Touchscreen,
     JSHandle,
     ElementHandle,
-    Accessibility,
     FileChooser,
     Frame,
     FrameLocator,
diff --git a/setup.cfg b/setup.cfg
index 5594a677b..35d6f7007 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -3,3 +3,5 @@ ignore =
     E501
     W503
     E302
+    # Conflicts with black https://github.com/PyCQA/flake8/issues/1921
+    E704
diff --git a/setup.py b/setup.py
index df6613283..5a8229db1 100644
--- a/setup.py
+++ b/setup.py
@@ -19,18 +19,73 @@
 import subprocess
 import sys
 import zipfile
-from pathlib import Path
-from typing import Dict, List
+from typing import Dict
 
-from setuptools import setup
+driver_version = "1.58.0"
+
+base_wheel_bundles = [
+    {
+        "wheel": "macosx_10_13_x86_64.whl",
+        "machine": "x86_64",
+        "platform": "darwin",
+        "zip_name": "mac",
+    },
+    {
+        "wheel": "macosx_11_0_universal2.whl",
+        "machine": "x86_64",
+        "platform": "darwin",
+        "zip_name": "mac",
+    },
+    {
+        "wheel": "macosx_11_0_arm64.whl",
+        "machine": "arm64",
+        "platform": "darwin",
+        "zip_name": "mac-arm64",
+    },
+    {
+        "wheel": "manylinux1_x86_64.whl",
+        "machine": "x86_64",
+        "platform": "linux",
+        "zip_name": "linux",
+    },
+    {
+        "wheel": "manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
+        "machine": "aarch64",
+        "platform": "linux",
+        "zip_name": "linux-arm64",
+    },
+    {
+        "wheel": "win32.whl",
+        "machine": "i386",
+        "platform": "win32",
+        "zip_name": "win32_x64",
+    },
+    {
+        "wheel": "win_amd64.whl",
+        "machine": "amd64",
+        "platform": "win32",
+        "zip_name": "win32_x64",
+    },
+    {
+        "wheel": "win_arm64.whl",
+        "machine": "arm64",
+        "platform": "win32",
+        "zip_name": "win32_arm64",
+    },
+]
+
+if len(sys.argv) == 2 and sys.argv[1] == "--list-wheels":
+    for bundle in base_wheel_bundles:
+        print(bundle["wheel"])
+    exit(0)
+
+from setuptools import setup  # noqa: E402
 
 try:
     from auditwheel.wheeltools import InWheel
 except ImportError:
     InWheel = None
-from wheel.bdist_wheel import bdist_wheel as BDistWheelCommand
-
-driver_version = "1.47.0-beta-1726138322000"
+from wheel.bdist_wheel import bdist_wheel as BDistWheelCommand  # noqa: E402
 
 
 def extractall(zip: zipfile.ZipFile, path: str) -> None:
@@ -44,9 +99,10 @@ def extractall(zip: zipfile.ZipFile, path: str) -> None:
 
 def download_driver(zip_name: str) -> None:
     zip_file = f"playwright-{driver_version}-{zip_name}.zip"
-    if os.path.exists("driver/" + zip_file):
+    destination_path = "driver/" + zip_file
+    if os.path.exists(destination_path):
         return
-    url = "https://playwright.azureedge.net/builds/driver/"
+    url = "https://cdn.playwright.dev/builds/driver/"
     if (
         "-alpha" in driver_version
         or "-beta" in driver_version
@@ -54,130 +110,79 @@ def download_driver(zip_name: str) -> None:
     ):
         url = url + "next/"
     url = url + zip_file
+    temp_destination_path = destination_path + ".tmp"
     print(f"Fetching {url}")
     # Don't replace this with urllib - Python won't have certificates to do SSL on all platforms.
-    subprocess.check_call(["curl", url, "-o", "driver/" + zip_file])
+    subprocess.check_call(["curl", url, "-o", temp_destination_path])
+    os.rename(temp_destination_path, destination_path)
 
 
 class PlaywrightBDistWheelCommand(BDistWheelCommand):
-    user_options = BDistWheelCommand.user_options + [
-        ("all", "a", "create wheels for all platforms")
-    ]
-    boolean_options = BDistWheelCommand.boolean_options + ["all"]
-
-    def initialize_options(self) -> None:
-        super().initialize_options()
-        self.all = False
-
     def run(self) -> None:
-        shutil.rmtree("build", ignore_errors=True)
-        shutil.rmtree("dist", ignore_errors=True)
-        shutil.rmtree("playwright.egg-info", ignore_errors=True)
         super().run()
         os.makedirs("driver", exist_ok=True)
         os.makedirs("playwright/driver", exist_ok=True)
-        base_wheel_bundles: List[Dict[str, str]] = [
-            {
-                "wheel": "macosx_10_13_x86_64.whl",
-                "machine": "x86_64",
-                "platform": "darwin",
-                "zip_name": "mac",
-            },
-            {
-                "wheel": "macosx_11_0_universal2.whl",
-                "machine": "x86_64",
-                "platform": "darwin",
-                "zip_name": "mac",
-            },
-            {
-                "wheel": "macosx_11_0_arm64.whl",
-                "machine": "arm64",
-                "platform": "darwin",
-                "zip_name": "mac-arm64",
-            },
-            {
-                "wheel": "manylinux1_x86_64.whl",
-                "machine": "x86_64",
-                "platform": "linux",
-                "zip_name": "linux",
-            },
-            {
-                "wheel": "manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
-                "machine": "aarch64",
-                "platform": "linux",
-                "zip_name": "linux-arm64",
-            },
-            {
-                "wheel": "win32.whl",
-                "machine": "i386",
-                "platform": "win32",
-                "zip_name": "win32_x64",
-            },
-            {
-                "wheel": "win_amd64.whl",
-                "machine": "amd64",
-                "platform": "win32",
-                "zip_name": "win32_x64",
-            },
-        ]
-        self._download_and_extract_local_driver(base_wheel_bundles)
-
-        wheels = base_wheel_bundles
-        if not self.all:
-            # Limit to 1, since for MacOS e.g. we have multiple wheels for the same platform and architecture and Conda expects 1.
-            wheels = list(
+        self._download_and_extract_local_driver()
+
+        wheel = None
+        if os.getenv("PLAYWRIGHT_TARGET_WHEEL", None):
+            wheel = list(
+                filter(
+                    lambda wheel: wheel["wheel"]
+                    == os.getenv("PLAYWRIGHT_TARGET_WHEEL"),
+                    base_wheel_bundles,
+                )
+            )[0]
+        else:
+            wheel = list(
                 filter(
                     lambda wheel: wheel["platform"] == sys.platform
                     and wheel["machine"] == platform.machine().lower(),
                     base_wheel_bundles,
                 )
-            )[:1]
-        self._build_wheels(wheels)
+            )[0]
+        assert wheel
+        self._build_wheel(wheel)
 
-    def _build_wheels(
+    def _build_wheel(
         self,
-        wheels: List[Dict[str, str]],
+        wheel_bundle: Dict[str, str],
     ) -> None:
+        assert self.dist_dir
         base_wheel_location: str = glob.glob(os.path.join(self.dist_dir, "*.whl"))[0]
         without_platform = base_wheel_location[:-7]
-        for wheel_bundle in wheels:
-            download_driver(wheel_bundle["zip_name"])
-            zip_file = (
-                f"driver/playwright-{driver_version}-{wheel_bundle['zip_name']}.zip"
+        download_driver(wheel_bundle["zip_name"])
+        zip_file = f"driver/playwright-{driver_version}-{wheel_bundle['zip_name']}.zip"
+        with zipfile.ZipFile(zip_file, "r") as zip:
+            extractall(zip, f"driver/{wheel_bundle['zip_name']}")
+        wheel_location = without_platform + wheel_bundle["wheel"]
+        shutil.copy(base_wheel_location, wheel_location)
+        with zipfile.ZipFile(
+            wheel_location, mode="a", compression=zipfile.ZIP_DEFLATED
+        ) as zip:
+            driver_root = os.path.abspath(f"driver/{wheel_bundle['zip_name']}")
+            for dir_path, _, files in os.walk(driver_root):
+                for file in files:
+                    from_path = os.path.join(dir_path, file)
+                    to_path = os.path.relpath(from_path, driver_root)
+                    zip.write(from_path, f"playwright/driver/{to_path}")
+            zip.writestr(
+                "playwright/driver/README.md",
+                f"{wheel_bundle['wheel']} driver package",
             )
-            with zipfile.ZipFile(zip_file, "r") as zip:
-                extractall(zip, f"driver/{wheel_bundle['zip_name']}")
-            wheel_location = without_platform + wheel_bundle["wheel"]
-            shutil.copy(base_wheel_location, wheel_location)
-            with zipfile.ZipFile(wheel_location, "a") as zip:
-                driver_root = os.path.abspath(f"driver/{wheel_bundle['zip_name']}")
-                for dir_path, _, files in os.walk(driver_root):
-                    for file in files:
-                        from_path = os.path.join(dir_path, file)
-                        to_path = os.path.relpath(from_path, driver_root)
-                        zip.write(from_path, f"playwright/driver/{to_path}")
-                zip.writestr(
-                    "playwright/driver/README.md",
-                    f"{wheel_bundle['wheel']} driver package",
-                )
         os.remove(base_wheel_location)
-        if InWheel:
-            for whlfile in glob.glob(os.path.join(self.dist_dir, "*.whl")):
-                os.makedirs("wheelhouse", exist_ok=True)
-                with InWheel(
-                    in_wheel=whlfile,
-                    out_wheel=os.path.join("wheelhouse", os.path.basename(whlfile)),
-                ):
+        for whlfile in glob.glob(os.path.join(self.dist_dir, "*.whl")):
+            os.makedirs("wheelhouse", exist_ok=True)
+            if InWheel:
+                wheelhouse_whl = os.path.join("wheelhouse", os.path.basename(whlfile))
+                shutil.move(whlfile, wheelhouse_whl)
+                with InWheel(in_wheel=wheelhouse_whl, out_wheel=whlfile):
                     print(f"Updating RECORD file of {whlfile}")
-            shutil.rmtree(self.dist_dir)
-            print("Copying new wheels")
-            shutil.move("wheelhouse", self.dist_dir)
-        else:
-            print("auditwheel not installed, not updating RECORD file")
+        print("Copying new wheels")
+        shutil.rmtree("wheelhouse")
 
     def _download_and_extract_local_driver(
         self,
-        wheels: List[Dict[str, str]],
     ) -> None:
         zip_names_for_current_system = set(
             map(
@@ -185,7 +190,7 @@ def _download_and_extract_local_driver(
                 filter(
                     lambda wheel: wheel["machine"] == platform.machine().lower()
                     and wheel["platform"] == sys.platform,
-                    wheels,
+                    base_wheel_bundles,
                 ),
             )
         )
@@ -198,50 +203,5 @@ def _download_and_extract_local_driver(
 
 
 setup(
-    name="playwright",
-    author="Microsoft Corporation",
-    author_email="",
-    description="A high-level API to automate web browsers",
-    long_description=Path("README.md").read_text(encoding="utf-8"),
-    long_description_content_type="text/markdown",
-    license="Apache-2.0",
-    url="https://github.com/Microsoft/playwright-python",
-    project_urls={
-        "Release notes": "https://github.com/microsoft/playwright-python/releases",
-    },
-    packages=[
-        "playwright",
-        "playwright.async_api",
-        "playwright.sync_api",
-        "playwright._impl",
-        "playwright._impl.__pyinstaller",
-    ],
-    include_package_data=True,
-    install_requires=[
-        "greenlet==3.0.3",
-        "pyee==12.0.0",
-    ],
-    # TODO: Can be removed once we migrate to pypa/build or pypa/installer.
-    setup_requires=["setuptools-scm==8.1.0", "wheel==0.42.0"],
-    classifiers=[
-        "Topic :: Software Development :: Testing",
-        "Topic :: Internet :: WWW/HTTP :: Browsers",
-        "Intended Audience :: Developers",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.8",
     cmdclass={"bdist_wheel": PlaywrightBDistWheelCommand},
-    entry_points={
-        "console_scripts": [
-            "playwright=playwright.__main__:main",
-        ],
-        "pyinstaller40": ["hook-dirs=playwright._impl.__pyinstaller:get_hook_dirs"],
-    },
 )
diff --git a/tests/assets/client-certificates/README.md b/tests/assets/client-certificates/README.md
index b0ee78e70..2c73bd92f 100644
--- a/tests/assets/client-certificates/README.md
+++ b/tests/assets/client-certificates/README.md
@@ -1,60 +1,7 @@
 # Client Certificate test-certificates
 
-## Server
+Regenerate all certificates by running:
 
-```bash
-openssl req \
-	-x509 \
-	-newkey rsa:4096 \
-	-keyout server/server_key.pem \
-	-out server/server_cert.pem \
-	-nodes \
-	-days 365 \
-	-subj "/CN=localhost/O=Client\ Certificate\ Demo" \
-	-addext "subjectAltName=DNS:localhost,DNS:local.playwright"
 ```
-
-## Trusted client-certificate (server signed/valid)
-
-```
-mkdir -p client/trusted
-# generate server-signed (valid) certifcate
-openssl req \
-	-newkey rsa:4096 \
-	-keyout client/trusted/key.pem \
-	-out client/trusted/csr.pem \
-	-nodes \
-	-days 365 \
-	-subj "/CN=Alice"
-
-# sign with server_cert.pem
-openssl x509 \
-	-req \
-	-in client/trusted/csr.pem \
-	-CA server/server_cert.pem \
-	-CAkey server/server_key.pem \
-	-out client/trusted/cert.pem \
-	-set_serial 01 \
-	-days 365
-```
-
-## Self-signed certificate (invalid)
-
-```
-mkdir -p client/self-signed
-openssl req \
-	-newkey rsa:4096 \
-	-keyout client/self-signed/key.pem \
-	-out client/self-signed/csr.pem \
-	-nodes \
-	-days 365 \
-	-subj "/CN=Bob"
-
-# sign with self-signed/key.pem
-openssl x509 \
-	-req \
-	-in client/self-signed/csr.pem \
-	-signkey client/self-signed/key.pem \
-	-out client/self-signed/cert.pem \
-	-days 365
+bash generate.sh
 ```
diff --git a/tests/assets/client-certificates/client/localhost/localhost.csr b/tests/assets/client-certificates/client/localhost/localhost.csr
new file mode 100644
index 000000000..cbf60ba43
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.csr
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEizCCAnMCAQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MIICIjANBgkqhkiG9w0B
+AQEFAAOCAg8AMIICCgKCAgEAuxTIfOTWJzsLSYT/RXu6eUYe95oFA0gMM6pdQAws
+U08ufU8S68UzBIAb6zdwDqM6LD5FqLrwaTsUW73dKefb003EgA19L3sZTHSwnSv9
+g9+rnKw/8EA+1thFo7h3EfdWkO/nuxnPfEnHu5oxMk/mCu+hdjfgh01mxc00PIO/
+wioxZtuhzKNIUu+qQAj70Dwbkzy3Zb1QAnj+02AUYnrVTYhusmP4pjrfYgAWU1x4
+WN+XTSI27LnQHE8t8OxuICFwqEEPcJg4pCFNQgmO0gcRDbd4U7JgQ0xMXZ9na9k0
+f1GOgtjKsz5IIDrAwLnrIOEXiIYlNaQ/v28BrlWytaOHGFKmDxAbGXHz1WuftmR1
+vYQivC5fkXU3+QKWoGPZaLIhA7/ZOMSVgoo+Rv+mS6Mze/6LphatUMcI1oYX4ZBY
+FrsVsAeAO/FPZDcwVct0bdPCRRFBQpgl6DxMyItHMexNHwURi4YHwhYiBBe+Njc1
+tTh6dniA11MUVC5WmKME7CxgXxHVXE4MYcf/w1x4sOnxHneb1bCa8jOPELRc6byR
+8mk23fbBP42EPkrgpCtLhbHgskLKobLFav43xaIiYFn744U7rbINI+5RfJ8BH5Kw
+CB5RlAsymPxwDNcPXyyyeHEEUAQmtnJPrGPSGMN/QODgCWRXEvY556NGx0D5riu7
+MXkCAwEAAaAyMDAGCSqGSIb3DQEJDjEjMCEwHwYDVR0RBBgwFoIJbG9jYWxob3N0
+ggkxMjcuMC4wLjEwDQYJKoZIhvcNAQELBQADggIBAEYqpx28FFRHqXfyumTkkFb/
+hrlUD9qKUYSdjpsPLFRUYiLofNlYhCtEFEuHyLkNHqLO5Z6E7yOpm/HvdXY0eBQy
+tK0verggKXy8MnpLVtsFOf4DgenTwFRG3NbNk2/KynwiAwJ0iwOdDfAmwrzYFLeR
+uXysPE0lGJu277akuo/PDg3QEY44iDJgI4rqtY25sR8J23M9Roa5qN4bdaXl6l10
+UJhdugTG90gRFmmUVLLRa21A3j4m7pvWHu7zYJN7ylS/NQ6ZEnpNno7Ie6MLzrm6
+h8MOSoxtmrXi0e3aYf7PC3u3YLAjyUzHicgMdXk8SjtUXi6l3U5hU+6WBeOKKmwa
+vi+FUpRfnutkWpinNqikmMw0Sqy+bpXwbwgm2oD6driiMneBCT37gW/IyUPWVxzg
+dVgeQIt3i8SMwnGUrzfVo/gqjq4qFBpzS3h9jPPrMYQN2LQdmyo13R9UH26cLGE1
+cgVmqUKa11kX8353wfA36JuW5yGv2yaK4V1kwFISznMvk5AGdOHONdZOrN4sLIIY
+7Npqp5AO1KdoYcNVptCA4n6mN/30fTmA/W1ajsKcfIn5RlmvdgpooKoEgaU/X9RL
+d2ydIpijWbQqm+nF9skpO4jIFPfuQj6mMXCPWtsvbpHCoo0iMHHWfVFcpvsXGYN2
+6ji5z3opVapp1m5uTmcA
+-----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/localhost/localhost.ext b/tests/assets/client-certificates/client/localhost/localhost.ext
new file mode 100644
index 000000000..d4d022726
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.ext
@@ -0,0 +1 @@
+subjectAltName=DNS:localhost,DNS:127.0.0.1
diff --git a/tests/assets/client-certificates/client/localhost/localhost.key b/tests/assets/client-certificates/client/localhost/localhost.key
new file mode 100644
index 000000000..7f6adba53
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.key
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/client/localhost/localhost.pem b/tests/assets/client-certificates/client/localhost/localhost.pem
new file mode 100644
index 000000000..5c1a67505
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.pem
@@ -0,0 +1,30 @@
+-----BEGIN CERTIFICATE-----
+MIIFKDCCAxCgAwIBAgIBATANBgkqhkiG9w0BAQsFADA2MRIwEAYDVQQDDAlsb2Nh
+bGhvc3QxIDAeBgNVBAoMF0NsaWVudCBDZXJ0aWZpY2F0ZSBEZW1vMB4XDTI1MDcy
+MTE1NTYxOVoXDTM1MDcxOTE1NTYxOVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIC
+IjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuxTIfOTWJzsLSYT/RXu6eUYe
+95oFA0gMM6pdQAwsU08ufU8S68UzBIAb6zdwDqM6LD5FqLrwaTsUW73dKefb003E
+gA19L3sZTHSwnSv9g9+rnKw/8EA+1thFo7h3EfdWkO/nuxnPfEnHu5oxMk/mCu+h
+djfgh01mxc00PIO/wioxZtuhzKNIUu+qQAj70Dwbkzy3Zb1QAnj+02AUYnrVTYhu
+smP4pjrfYgAWU1x4WN+XTSI27LnQHE8t8OxuICFwqEEPcJg4pCFNQgmO0gcRDbd4
+U7JgQ0xMXZ9na9k0f1GOgtjKsz5IIDrAwLnrIOEXiIYlNaQ/v28BrlWytaOHGFKm
+DxAbGXHz1WuftmR1vYQivC5fkXU3+QKWoGPZaLIhA7/ZOMSVgoo+Rv+mS6Mze/6L
+phatUMcI1oYX4ZBYFrsVsAeAO/FPZDcwVct0bdPCRRFBQpgl6DxMyItHMexNHwUR
+i4YHwhYiBBe+Njc1tTh6dniA11MUVC5WmKME7CxgXxHVXE4MYcf/w1x4sOnxHneb
+1bCa8jOPELRc6byR8mk23fbBP42EPkrgpCtLhbHgskLKobLFav43xaIiYFn744U7
+rbINI+5RfJ8BH5KwCB5RlAsymPxwDNcPXyyyeHEEUAQmtnJPrGPSGMN/QODgCWRX
+EvY556NGx0D5riu7MXkCAwEAAaNjMGEwHwYDVR0RBBgwFoIJbG9jYWxob3N0ggkx
+MjcuMC4wLjEwHQYDVR0OBBYEFIE6kbIR0PlzaJuZg52JqXuFFQHBMB8GA1UdIwQY
+MBaAFPHaEfjJoIftSkHTb8mwme27LtifMA0GCSqGSIb3DQEBCwUAA4ICAQB7E57H
+19qUD4DjLxJGAVpDphD8mZg9aR7bUd6laXZ12VQnn3+OrF+6JjJ2TIr8ssRkkzc6
+rMhRqob+DxeB94JqlFQDmwP37wJXnuTtuGj71NHQal15b5ZB28fFdwWgUlYECWyg
+sYeMK5HMnNDziniRnjPoKU6f8urmUW2G8N2SOufnRar/StY/8u24IFh/vDTVJKWB
+a22pVk/PIx6JcErfMx0OJdoIUZd/C9DT/a7t+Pt+t3EPVNM2fcjs9aMcg6tlU6Tp
+YwHMzkFQYmcrp2QEhwy23z2E+wnLbeHTULDsHVOLudUGDcSgkW48bPNTOtZTysQ+
+P4mJf+Ju2HC/EwuVrOa14uuay9c+hC1Q1gsGbLZB8NE6jOX5QYN2a7iiUEdCdufo
+wWIXEC+2dJiEji3ehwJp0q4jK15X0IOIfxLH4PholORH659DdCfpm7YAjoaPE9nr
+28MMd9Lj6zWmfyeb5p0IUDpkreL2huxjXHJkmSm4dcxDxLqsP6KSPlhrPvjAVUqw
+5M/jUarDAHaPLNlwqcqWODb891FIyRmc6YHtSRGujMyfJ8LRS2f9rHeyM3m2jMHf
+8EahOgyQ8nvSs/a42VS97IHkGl6qufK7ZUq/VMhQRb+KbaIDN5TLtNwEQ1I40Bm9
+UOoSX/uP1PstOZvf9gnYto8sf75B+PxO692uYw==
+-----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/self-signed/cert.pem b/tests/assets/client-certificates/client/self-signed/cert.pem
index 3c0771794..d14ac95b2 100644
--- a/tests/assets/client-certificates/client/self-signed/cert.pem
+++ b/tests/assets/client-certificates/client/self-signed/cert.pem
@@ -1,28 +1,28 @@
 -----BEGIN CERTIFICATE-----
-MIIEyzCCArOgAwIBAgIUYps4gh4MqFYg8zqQhHYL7zYfbLkwDQYJKoZIhvcNAQEL
-BQAwDjEMMAoGA1UEAwwDQm9iMB4XDTI0MDcxOTEyNDc0MFoXDTI1MDcxOTEyNDc0
+MIIEyzCCArOgAwIBAgIUUo60oaPj20QM6oeGSn+2CT5j7GYwDQYJKoZIhvcNAQEL
+BQAwDjEMMAoGA1UEAwwDQm9iMB4XDTI1MDcyMTE1NTYyMFoXDTM1MDcxOTE1NTYy
 MFowDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC
-AgEA179eTsqcc1c3AOQHzCZEyYLPta2CCAscUFqcEZ9vWvjW0uzOv9TDlB33Unov
-jch4CElZOBhzTadVsbmnYKpxwyVU89WCuQKvedz4k1vu7S1YryfNbmS8PWbnQ4ds
-9NB7SgJNHZILvx9DXuWeFEyzRIo1984z4HheBzrkf791LqpYKaKziANUo8h8t0dm
-TX/boOz8cEnQNwtTC0ZX3aD0obG/UAhr/22ZGPo/E659fh4ptyYX2LrIUHGy+Eux
-nJ9Y4cTqa88Ee6K6AkDiT/AoNQNxE4X++jqLuie8j/ZYpI1Oll38GwKVOyy1msRL
-toGmISNwkMIQDGABrJlxgpP4QQAQ+08v9srzXOlkdxdr7OCP81r+ccBXiSQEe7BA
-kdJ8l98l5dprJ++GJ+SZcV4+/iGR0dKU2IdAG5HiKZIFn6ch9Ux+UMqeGaYCpkHr
-TiietHwcXgtVBlE0jFmB/HspmI/O0abK+grMmueaH7XtTI8YHnw0mUpL8+yp7mfA
-7zFusgFgyiBPXeD/NQgg8vja67k++d1VGoXm2xr+5WPQCSbgQoMkkOBMLHWJTefd
-6F4Z5M+oI0VwYbf6eQW246wJgpCHSPR0Vdijd6MAGRWKUuLfDsA9+12iGbKvwJ2e
-nJlStft2V2LZcjBfdIMbigW1aSVNN5w6m6YVrQPry3WPkWcCAwEAAaMhMB8wHQYD
-VR0OBBYEFPxKWTFQJSg4HD2qjxL0dnXX/z4qMA0GCSqGSIb3DQEBCwUAA4ICAQBz
-4H1d5eGRU9bekUvi7LbZ5CP/I6w6PL/9AlXqO3BZKxplK7fYGHd3uqyDorJEsvjV
-hxwvFlEnS0JIU3nRzhJU/h4Yaivf1WLRFwGZ4TPBjX9KFU27exFWD3rppazkWybJ
-i4WuEdP3TJMdKLcNTtXWUDroDOgPlS66u6oZ+mUyUROil+B+fgQgVDhjRc5fvRgZ
-Lng8wuejCo3ExQyxkwn2G5guyIimgHmOQghPtLO5xlc67Z4GPUZ1m4tC+BCiFO4D
-YIXl3QiIpmU7Pss39LLKMGXXAgLRqyMzqE52lsznu18v5vDLfTaRH4u/wjzULhXz
-SrV1IUJmhgEXta4EeDmPH0itgKtkbwjgCOD7drrFrJq/EnvIaJ5cpxiI1pFmYD8g
-VVD7/KT/CyT1Uz1dI8QaP/JX8XEgtMJaSkPfjPErIViN9rh9ECCNLgFyv7Y0Plar
-A6YlvdyV1Rta/BHndf5Hqz9QWNhbFCMQRGVQNEcoKwpFyjAE9SXoKJvFIK/w5WXu
-qKzIYA26QXE3p734Xu1n8QiFJIyltVHbyUlD0k06194t5a2WK+/eDeReIsk0QOI8
-FGqhyPZ7YjR5tSZTmgljtViqBO5AA23QOVFqtjOUrjXP5pTbPJel99Z/FTkqSwvB
-Rt4OX7HfuokWQDTT0TMn5jVtJyi54cH7f9MmsNJ23g==
+AgEAzQMXYOZz3ILrbF9qpDng2pw2wJf1UFopehwaYyu7riWJ9+ADrhSnCSFBM3Sc
+MBc/8dIR6etWwci8QwJ/MtvIU0yx4llq+53G+19Bc1teC6q/b4QCRDIcTGxOZoR+
+jfYZVjPODEyJ5y5MZIo34ZP4bu+JnpT4W7+uojm3jOoyNPqXMcc70uAhfSKG+Jfr
+wZKteA4T5VKFytVcWgh4v03z8zTYeW3kD4lCsongBz6yu2dn3D6XMROnxiPwi+IR
+QqX1pwnJ0UA3CTeOHEw1jA3koxWIIg44PWaPaCj9Udrhf4ew00XLPWVZP8T5rVf8
+yUfecWQCR7FueJFqoLhPMMFi17rYmGZUvw3/YkXBjay4Q9e+G2WS3Xk8u+I1sCuV
+BJNBRv9DqtMC9D/N9NI8GkLrXwZmk82SXG+cQ0TSkNUHYI/03YKoqsn5H8PsG7Tc
++Y2Ca6TaCWims7lvOg7U0E6lu2h5NGcdWHFPJ9qfe+xho/yfYYwGqEKanGAu1kd5
+SbIaX6/YiM5/Pp/96MeRNrB9kLzDnZTNuGtdCawVFgbkWmfX2Z6/a0d6SvZGDzBx
+xTVZRB0my01E1FP53MS8YRH98HUjGEwNRVq2e1W+aXldKppgZ85GZD3l2YTeuI0i
+PJCDUzQiaWzFtWc8s13YQ1HLCOyOXF7QqMyNCiLGb4xQ56kCAwEAAaMhMB8wHQYD
+VR0OBBYEFMqdCDxkZm8HxNI4MLLveAVTdH7UMA0GCSqGSIb3DQEBCwUAA4ICAQAB
+MKd3WEJ8zI51FuyeTcMq6L1zk2vmKTFg6T7HZJhNZoD1AYvvsKJ8mrqeSwhxqjlE
+0H2FGLY+Z8Fw3+TE1QuvTuz3gwRI+yzBEyqi/fEGCGrhOVcWaXGgLCtWG+BA4Su8
+HenK97/n3OnXUnBozRPZMH02IaLrOiEGbpaabXKCCabpm5U1oGq437e3SeAeIL7U
+WxuHhHBx0yo9j7ACaCL6mz8xpk8NaRZpPy22MTlrPKwbOK2eYf3Jy5fHa/f6edTs
+KqZewI7t4oe/OqKdjyTgGYkjTE3Xcmo2T/fmcAeEP3HJX267kCzBi5J3McwonWxD
+N8zz9qKSf5YGQy140eEOTjjESwlPz6zfrTW92YdCIr63k9UCDL2HGQTRSxB6g4BQ
+loVzKS9/BKhulGqvSGvEoj6D+qG/PgFlBtJoE71X+vSIxvdbnOVmOi/l+NGNuP1Z
+nwnDtZWp4BKshhSKvqeOI+EyNMQ4FL20S4w8T+LR873jKrbd2MEuAsJiygWh+/ZJ
+haHTEhFxvH/a4i8gb/SGZlFB6oyPJ+XM5kZo4fcp7PnzxhYrIaEpPq+AR/3657hm
+AajXpS5lTCkNJc85QeHHj/0geDsOvfK4XUj2lgaJ0gXpgsoxnSCSq6Xox6ZqAVON
+0ra1KkGBTQH+5DxJ2Gp1UBaucrLYZTfXuJ8fPYeeNQ==
 -----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/self-signed/csr.pem b/tests/assets/client-certificates/client/self-signed/csr.pem
index 4c99e1349..283dd45a6 100644
--- a/tests/assets/client-certificates/client/self-signed/csr.pem
+++ b/tests/assets/client-certificates/client/self-signed/csr.pem
@@ -1,26 +1,26 @@
 -----BEGIN CERTIFICATE REQUEST-----
 MIIEUzCCAjsCAQAwDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOC
-Ag8AMIICCgKCAgEA179eTsqcc1c3AOQHzCZEyYLPta2CCAscUFqcEZ9vWvjW0uzO
-v9TDlB33Unovjch4CElZOBhzTadVsbmnYKpxwyVU89WCuQKvedz4k1vu7S1YryfN
-bmS8PWbnQ4ds9NB7SgJNHZILvx9DXuWeFEyzRIo1984z4HheBzrkf791LqpYKaKz
-iANUo8h8t0dmTX/boOz8cEnQNwtTC0ZX3aD0obG/UAhr/22ZGPo/E659fh4ptyYX
-2LrIUHGy+EuxnJ9Y4cTqa88Ee6K6AkDiT/AoNQNxE4X++jqLuie8j/ZYpI1Oll38
-GwKVOyy1msRLtoGmISNwkMIQDGABrJlxgpP4QQAQ+08v9srzXOlkdxdr7OCP81r+
-ccBXiSQEe7BAkdJ8l98l5dprJ++GJ+SZcV4+/iGR0dKU2IdAG5HiKZIFn6ch9Ux+
-UMqeGaYCpkHrTiietHwcXgtVBlE0jFmB/HspmI/O0abK+grMmueaH7XtTI8YHnw0
-mUpL8+yp7mfA7zFusgFgyiBPXeD/NQgg8vja67k++d1VGoXm2xr+5WPQCSbgQoMk
-kOBMLHWJTefd6F4Z5M+oI0VwYbf6eQW246wJgpCHSPR0Vdijd6MAGRWKUuLfDsA9
-+12iGbKvwJ2enJlStft2V2LZcjBfdIMbigW1aSVNN5w6m6YVrQPry3WPkWcCAwEA
-AaAAMA0GCSqGSIb3DQEBCwUAA4ICAQCb07d2IjUy1PeHCj/2k/z9FrZSo6K3c8y6
-b/u/MZ0AXPKLPDSo7UYpOJ8Z2cBiJ8jQapjTSEL8POUYqcvCmP55R6u68KmvINHo
-+Ly7pP+xPrbA4Q0WmPnz37hQn+I1he0GuEQyjZZqUln9zwp67TsWNKxKtCH+1j8M
-Ltzx6kuHCdPtDUtv291yhVRqvbjiDs+gzdQYNJtAkUbHwHFxu8oZhg8QZGyXYMN8
-TGoQ1LTezFZXJtX69K7WnrDGrjsgB6EMvwkqAFSYNH0LFvI0xo13OOgXr9mrwohA
-76uZtjXL9B15EqrMce6mdUZi46QJuQ2avTi57Lz+fqvsBYdQO89VcFSmqu2nfspN
-QZDrooyjHrlls8MpoBd8fde9oT4uA4/d9SJtuHUnjgGN7Qr7eTruWXL8wVMwFnvL
-igWE4detO9y2gpRLq6uEqzWYMGtN9PXJCGU8C8m9E2EBUKMrT/bpNbboatLcgRrW
-acj0BRVqoVzk1sRq7Sa6ejywqgARvIhTehg6DqdMdcENCPQ7rxDRu5PSDM8/mwIj
-0KYl8d2PlECB4ofRyLcy17BZzjP6hSnkGzcFk0/bChZOSIRnwvKbvfXnB45hhPk8
-XwT/6UNSwC2STP3gtOmLqrWj+OE0gy0AkDMvP3UnQVGMUvgfYg+N4ROCVtlqzxe9
-W65c05Mm1g==
+Ag8AMIICCgKCAgEAzQMXYOZz3ILrbF9qpDng2pw2wJf1UFopehwaYyu7riWJ9+AD
+rhSnCSFBM3ScMBc/8dIR6etWwci8QwJ/MtvIU0yx4llq+53G+19Bc1teC6q/b4QC
+RDIcTGxOZoR+jfYZVjPODEyJ5y5MZIo34ZP4bu+JnpT4W7+uojm3jOoyNPqXMcc7
+0uAhfSKG+JfrwZKteA4T5VKFytVcWgh4v03z8zTYeW3kD4lCsongBz6yu2dn3D6X
+MROnxiPwi+IRQqX1pwnJ0UA3CTeOHEw1jA3koxWIIg44PWaPaCj9Udrhf4ew00XL
+PWVZP8T5rVf8yUfecWQCR7FueJFqoLhPMMFi17rYmGZUvw3/YkXBjay4Q9e+G2WS
+3Xk8u+I1sCuVBJNBRv9DqtMC9D/N9NI8GkLrXwZmk82SXG+cQ0TSkNUHYI/03YKo
+qsn5H8PsG7Tc+Y2Ca6TaCWims7lvOg7U0E6lu2h5NGcdWHFPJ9qfe+xho/yfYYwG
+qEKanGAu1kd5SbIaX6/YiM5/Pp/96MeRNrB9kLzDnZTNuGtdCawVFgbkWmfX2Z6/
+a0d6SvZGDzBxxTVZRB0my01E1FP53MS8YRH98HUjGEwNRVq2e1W+aXldKppgZ85G
+ZD3l2YTeuI0iPJCDUzQiaWzFtWc8s13YQ1HLCOyOXF7QqMyNCiLGb4xQ56kCAwEA
+AaAAMA0GCSqGSIb3DQEBCwUAA4ICAQAn/ZI7IkBUEfhZHefwtF+QHCyxSEKvqwHq
+fSqKVdarBPz8Ik8m3icj8R/DcS3y5jgzx3x8bXQoDpgsAQgeb825NRv2wAQAGoH1
+8vh204lTyjqzrgtK7eQeQDc7fjeigIkxQsAK9zk4BaFUWp0wEC0RLVAgvlQTl7vu
+n1jSSrhK8tvGy62/cIxZfwD0bAMHlW4m1A4fUuSGWQX2KldgA8tnmT6wx0If/nKb
+VB68AMbyMHUeb32v9wEvx2nHlwMjqNFeg7vYyJXOfBdDILUl+OTBoQY1X+jSx5iM
+txTzmA8Hcgx0Fq+BnbQuZCLqFpNWEfenAtQtaAFuJwMiKCf6kgbqkDVShJkmt+vC
+j3dcsVMZDsdMk4qRpiJhaTQOYmsMGCj4uoDpFGjwPoUwlDkjYgHAAsm9uCkshc+m
+WZO7I6Z3Tbi3XskJvAMc3dTWjtc6nApEtr/mn8LcETfOp7RRSfjllj6ijWUrVwUy
+BpzU9C/zLTkhFX0DVDCIV+jEefF8JPfzSKLgXyRbInTz1/6/sKXtswXW0NjzqLMI
+C9ggMBhOiDv9KJn3G/mY4CqIfo9KMzF+++4t+wdXTir8DWNlMUAn1vlBwxZAgKCM
+GonVExBU0VIGCpyTRLkesEHnPMgybP6gLzP3++54x288OS5JwuPPtkDcsBHUjTq8
+HxTJvUul/Q==
 -----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/self-signed/key.pem b/tests/assets/client-certificates/client/self-signed/key.pem
index 70d5e3dd0..c3ddd1a91 100644
--- a/tests/assets/client-certificates/client/self-signed/key.pem
+++ b/tests/assets/client-certificates/client/self-signed/key.pem
@@ -1,52 +1,52 @@
 -----BEGIN PRIVATE KEY-----
-MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQDXv15OypxzVzcA
-5AfMJkTJgs+1rYIICxxQWpwRn29a+NbS7M6/1MOUHfdSei+NyHgISVk4GHNNp1Wx
-uadgqnHDJVTz1YK5Aq953PiTW+7tLVivJ81uZLw9ZudDh2z00HtKAk0dkgu/H0Ne
-5Z4UTLNEijX3zjPgeF4HOuR/v3UuqlgporOIA1SjyHy3R2ZNf9ug7PxwSdA3C1ML
-RlfdoPShsb9QCGv/bZkY+j8Trn1+Him3JhfYushQcbL4S7Gcn1jhxOprzwR7oroC
-QOJP8Cg1A3EThf76Oou6J7yP9likjU6WXfwbApU7LLWaxEu2gaYhI3CQwhAMYAGs
-mXGCk/hBABD7Ty/2yvNc6WR3F2vs4I/zWv5xwFeJJAR7sECR0nyX3yXl2msn74Yn
-5JlxXj7+IZHR0pTYh0AbkeIpkgWfpyH1TH5Qyp4ZpgKmQetOKJ60fBxeC1UGUTSM
-WYH8eymYj87Rpsr6Csya55ofte1MjxgefDSZSkvz7KnuZ8DvMW6yAWDKIE9d4P81
-CCDy+NrruT753VUahebbGv7lY9AJJuBCgySQ4EwsdYlN593oXhnkz6gjRXBht/p5
-BbbjrAmCkIdI9HRV2KN3owAZFYpS4t8OwD37XaIZsq/AnZ6cmVK1+3ZXYtlyMF90
-gxuKBbVpJU03nDqbphWtA+vLdY+RZwIDAQABAoICAETxu6J0LuDQ+xvGwxMjG5JF
-wjitlMMbQdYPzpX3HC+3G3dWA4/b3xAjL1jlAPNPH8SOI/vAHICxO7pKuMk0Tpxs
-/qPZFCgpSogn7CuzEjwq5I88qfJgMKNyke7LhS8KvItfBuOvOx+9Ttsxh323MQZz
-IGHrPDq8XFf1IvYL6deaygesHbEWV2Lre6daIsAbXsUjVlxPykD81nHg7c0+VU6i
-rZ9WwaRjkqwftC6G8UVvQCdt/erdbYv/eZDNJ5oEdfPX6I3BHw6fZs+3ilq/RSoD
-yovRozS1ptc7QY/DynnzSizVJe4/ug6p7/LgTc2pyrwGRj+MNHKv73kHo/V1cbxF
-fBJCpxlfcGcEP27BkENiTKyRQEF1bjStw+UUKygrRXLm3MDtAVX8TrDERta4LAeW
-XvPiJbSOwWk2yYCs62RyKl+T1no7alIvc6SUy8rvKKm+AihjaTsxTeACC1cBc41m
-5HMz1dqdUWcB5jbnPsV+27dNK1/zIC+e0OXtoSXvS+IbQXo/awHJyXv5ClgldbB9
-hESFTYz/uI6ftuTM6coHQfASLgmnq0fOd1gyqO6Jr9ZSvxcPNheGpyzN3I3o5i2j
-LTYJdX3AoI5rQ5d7/GS2qIwWf0q8rxQnq1/34ABWD0umSa9tenCXkl7FIB4drwPB
-4n7n+SL7rhmv0vFKIjepAoIBAQD19MuggpKRHicmNH2EzPOyahttuhnB7Le7j6FC
-afuYUBFNcxww+L34GMRhmQZrGIYmuQ3QV4RjYh2bowEEX+F5R1V90iBtYQL1P73a
-jYtTfaJn0t62EBSC//w2rtaRJPgGhbXbnyid64J0ujRFCelej8FRJdBV342ctRAL
-0RazxQ/KcTRl9pncALxGhnSsBElZlDtZd/dWnWBDZ/fg/C97VV9ZQLcpyGvL516i
-GpB8BQsHiIe9Jt5flZvcKB7z/KItGzPB4WK6dpV8t/FeQiUpZXkQlqO03XaZT4NP
-AEGH3rKIRMpP7TORYFhbYrZwov3kzLaggax2wGPTkfMFNlTjAoIBAQDgjsYfShkz
-6Dl1UTYBrDMy9pakJbC6qmd0KOKX+4XH/Dc1mOzR8NGgoY7xWXFUlozgntKKnJda
-M6GfOt/dxc0Sq7moYzA7Jv4+9hNdU3jX5YrqAbcaSFj6k4yauO2BKCBahQo8qseY
-a3N5f0gp+5ftTMvOTwGw3JRJFJq0/DvKWAYLIaJ0Oo77zGs0vxa1Aqob10MloXt5
-DMwjazWujntTzTJY1vsfsBHa8OEObMwiftqnmn6L4Qprd3AzQkaNlZEsvERyLfFq
-1pu4EsDJJGdVfpZYfo+6vTglLXFBLEUQmh4/018Mw4O4pGgCVMj/wict/gTViQGC
-qSj+IOThsTytAoIBAHu3L3nEU/8EwMJ54q0a/nW+458U3gHqlRyWCZJDhxc9Jwbj
-IMoNRFj39Ef3VgAmrMvrh2RFsUTgRG5V1pwhsmNzmzAXstHx2zALaO73BZ7wcfFx
-Yy8G9ZpTMsU6upj1lICLX0diTmbo4IzgYIxdiPJUsvOjZqDbOvsZJEIdYSL5u5Cj
-0qx7FzdPc2SyGxuvaEnTwuqk6le5/4LIWCnmD+gksDpP0BIHSxmcfsBhRk3rp3mZ
-llVxqKdBtM1PrQojCFxR833RZfzOyzCZwaIc+V5SOUw7yYqfXxmMokrpoQy72ueq
-Wm1LrgWxBaCqDYSop7cftbkUoPB2o3/3SNtVUesCggEAReqOKy3R/QRf53QaoZiw
-9DwsmP0XMndd8J/ONU3d0G9p7SkpCxC05BOJQwH7NEAPqtwoZ3nr8ezDdKVLEGzG
-tfp7ur7vRGuWm5nYW6Viqa3Re5x/GxLNiW8pRv8vC5inwidMEamGraE++eQ0XsXz
-/rF7f0fAGgYDsWFV7eXe49hWQV7+iru0yxdRhcG9WyxyNGrogC3wGLdwU9LMiwXX
-xjbMZzbAR5R1arq3B9u+Dzt57tc+cWTm7qDocT1AZFLeOZSApyBA22foYf6MwdOw
-zMC2JOV68MR7V6/3ZDhZZJrnsi2omXvCZlnh/F/TmTYlJr/BV47pxnnOxpkNSmv5
-nQKCAQBRqrsUVO7NOgR1sVX7YDaekQiJKS6Vq/7y2gR4FoLm/MMzNZQgGo9afmKg
-F2hSv6tuoqc33Wm0FnoSEMaI8ky0qgA5kwXvhfQ6pDf/2zASFBwjwhTyJziDlhum
-iwWe1F7lNaVNpxAXzJBaBTWvHznuM42cGv5bbPBSRuIRniGsyn/zYMrISWgL+h/Q
-fsQ2rfPSqollPw+IUPN0mX+1zg6PFxaR4HM9UrRX7cnRKG20GIDPodsUl8IMg+SO
-M5YG/UqDD10hfeEutvQIvl0oJraBWT34cqUZLVpUwJzf1be7zl9MzHGcym/ni7lX
-dg6m3MAyZ1IXjHlogOdmGvnq07/w
+MIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQDNAxdg5nPcguts
+X2qkOeDanDbAl/VQWil6HBpjK7uuJYn34AOuFKcJIUEzdJwwFz/x0hHp61bByLxD
+An8y28hTTLHiWWr7ncb7X0FzW14Lqr9vhAJEMhxMbE5mhH6N9hlWM84MTInnLkxk
+ijfhk/hu74melPhbv66iObeM6jI0+pcxxzvS4CF9Iob4l+vBkq14DhPlUoXK1Vxa
+CHi/TfPzNNh5beQPiUKyieAHPrK7Z2fcPpcxE6fGI/CL4hFCpfWnCcnRQDcJN44c
+TDWMDeSjFYgiDjg9Zo9oKP1R2uF/h7DTRcs9ZVk/xPmtV/zJR95xZAJHsW54kWqg
+uE8wwWLXutiYZlS/Df9iRcGNrLhD174bZZLdeTy74jWwK5UEk0FG/0Oq0wL0P830
+0jwaQutfBmaTzZJcb5xDRNKQ1Qdgj/Tdgqiqyfkfw+wbtNz5jYJrpNoJaKazuW86
+DtTQTqW7aHk0Zx1YcU8n2p977GGj/J9hjAaoQpqcYC7WR3lJshpfr9iIzn8+n/3o
+x5E2sH2QvMOdlM24a10JrBUWBuRaZ9fZnr9rR3pK9kYPMHHFNVlEHSbLTUTUU/nc
+xLxhEf3wdSMYTA1FWrZ7Vb5peV0qmmBnzkZkPeXZhN64jSI8kINTNCJpbMW1Zzyz
+XdhDUcsI7I5cXtCozI0KIsZvjFDnqQIDAQABAoICAAN6aFLBqijNNFEM/95MKJVQ
+5eln0pbDxtUeZbC1yNv8IU56J5nUGh7gqG5m7bDvrgssXxcuwdStEwuYft+2JJyM
+Li7qyTK+YyY34CCExfBQ++k4jkDJsFr4Ee7xk8OVD6o7nATvpf3M9mkUwryyIdqA
++B7fhGSrGHuCWuu6O/KT502GBazu1kadF7jfO/XXZxfEtl/zQdeWfdf9sY2+VPOU
++5C41XARijcE+Y7p6IafKx8MlUxU+ulUygOXiOcucV/dfcXt7tkaTxAKF3T6Nd0x
+8/Ku9tOM2kVAP8b8HYwIOW7mLdvrbKOVNA61sdFY5axbD+JXP2pufiZ+pgJL36FF
+SDQIW5M3aH7CSa1i3i4MP49jWomhTNwseVrXsDuGCKVqgIR5LZwpS4VOHLAILkCh
+cIEDnoMS9YPuQdENIIxKyZGGHaeJ+LRb4w+szvtmu55Kp+N7AubPfoypPrx7a8LN
+8/0/w731DS6nTICYXXzzGoB3cefb3nsBNaH1+edffPTZOYlFZ9ElFjIs/xvWCSy4
+qYwQ1cW4DslIiVD62wm8Df2yr/5J6znfU01RXQ4GWfmDNFBdYsQO/8JEy6UZEvCy
+tFZ1gseD9K69O4XZSEKRKIvv8+1Y/CwD0ppIOYCIycTKn87GXFmsjbuj8tghmHp4
+TUi3EUvrw8mQMi5QBa5BAoIBAQD8JzdNy4ietoT8UUWqBT+ZSURPWeQN1esbncYU
+b9viBIznnjjFFr5JdYa5k3rxM+bTRq47NRt+r0HOvyJWUFJcI6tbgmGtW+rmM2kB
+hq6ekTJleLz+/cjNSjWD14avNORPz/ozZMlcz52NEl31pdniuDbueeNgyh+CkJtH
+BS8s8mMVZ+3NtafZ1ilGn/RP+n21C1J8Kcxd/1srtfcpybzAQiSYul2DlKVPGvqO
+XpLyt42/cyc7a3MyXtms2XhJ62fDK24Qptp6KJNTzqdtY+KP/iOW0SUgxf+JpC87
+W2NJW7tqyyaebn7KO1lGs9y03KzwaLZvy2RaBfjQnxS8uXzpAoIBAQDQI8QHNtr5
+nHYSzLZJMhJkP641wQWo4ODfkWxtEMqTyOXrVw3L8HMdA03Nmf9jnCv5awYYA3j0
+PmSL3PdM36d3VsAyyxMBN4HrH2Z94oTnoKmDfXjB3prhPYgO6aosSvE8rw1N055o
+757p9vAA5w9apBBLNdcm3cjUm2ZKeocL4wnFjOW63CtcFEouE4R7C32rauEu9Bdg
+dAXciBmOrHtihJUQrpMfyfN2fVSLbO4SoFy7ZHq5YKFk4MzNIp/cENwRIqdcLvOz
+o++RSbwptRtkd/HZCFSh/4gEPRLe/k5gGErS9ZqpeSMfV++IdBMqC0Sx3UpyXuue
+FOhIvnLpJlzBAoIBAGjcDh2mBLyr/oXHbocUA6zFUUkGgtZWHZ2wcQ1Sr0hAyDAS
+Fl2v5ZY677oA4OGpydYW0KICpdp7G4zU43ytjnKOytYVVHV5gigVPRfLYJbEnwaf
+vUj1VSo6MCMR4ArAnimqvcvdn/eex1BBUR20yPWF0iI+QhagN5ZeeJSCTWoNqrLe
+M4CWiKUIcMXUAw+3hctiV/0WjMySQuHcnFqecIYre3igF/9+M3jAKW5HWijhuGrj
+gm8tcgyCcVd2YJWs9cuuJel62eRvN0Vk7S+KmE91SmuPsjb84BXnV1UB3jpFkZ0J
+upesL8H+CFRku+Xi13Bqu2OmW6csUJrBbShGovECggEBAKGk9SupJXyvT1+gTn0f
+/vqOHiyvAEc8hkf6t5sobDtDzZPs4tEcpznEBBuF2rqwYdJtlKj3oWsGPa4FaKXy
+GCvtWozX+6V5R1Oj6kQftJnyw1NUEYF28Q+2asEyJTAK77jyNkHX9HGIjwEi/xek
+Wt9JBUJzyOjtW3gKS/HRoKnRpBghKZTqQl5bf5SzIbMxpGKJOeLuPG1zDc5MgJS2
+TYigcOgovCf2/jZqdUtmyKn8kqgSC+GGMzGWCFfT6RTOnypLoHBOIoPD8F0ER7aY
+aXKoWFH2T0wUmLy59brrA1FL7GhTx86QPn+sGmH9y5hecfY0ZwnVv+TgVdmQ1stN
+OMECggEBAOXDX319Dmo0ydAPYyngK4/slOetGaJmz8looU8a2R2+Ko/VMTZDmJhf
+P0vS74g3U7sukRjmYzUY1mPj27CDURvk1ENam9KPOQ59ws/TaHaJ7tobjUXVQ93/
+OREkrlCuqbEqJJzQ01mCWIbmDnGvJwD87rW6YwmI9Rs+kjZxNLj+IW4CqpY36q9A
+HwaUZLXc2q0W1CqLmFYF5HotvSFIAYHWuClEmM2NI9+0VItarBz6AwCnVXwKbJLC
+irXlllX+63uloTDR5W1ymy2hTUrhE1jgh9DR4106QSVDiEWqme/BAWmUoyuN/zms
+v3/WVVAXEcIowL3T4jzJ0RLdf1qE8Bc=
 -----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/client/trusted/cert-legacy.pfx b/tests/assets/client-certificates/client/trusted/cert-legacy.pfx
new file mode 100644
index 000000000..9f06aa35c
Binary files /dev/null and b/tests/assets/client-certificates/client/trusted/cert-legacy.pfx differ
diff --git a/tests/assets/client-certificates/client/trusted/cert.pem b/tests/assets/client-certificates/client/trusted/cert.pem
index 76d1e1a54..3430d063c 100644
--- a/tests/assets/client-certificates/client/trusted/cert.pem
+++ b/tests/assets/client-certificates/client/trusted/cert.pem
@@ -1,29 +1,29 @@
 -----BEGIN CERTIFICATE-----
 MIIFAzCCAuugAwIBAgIBATANBgkqhkiG9w0BAQsFADA2MRIwEAYDVQQDDAlsb2Nh
-bGhvc3QxIDAeBgNVBAoMF0NsaWVudCBDZXJ0aWZpY2F0ZSBEZW1vMB4XDTI0MDcx
-OTEyNDczN1oXDTI1MDcxOTEyNDczN1owEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0G
-CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCac3+4rNmH4/N1s4HqR2X168tgS/aA
-6sHW5at8mWRnq54Nm11RvnK55jHQYVAdBgJy5M07w0wakp8inxzlY95wqxBimYG6
-3Un/1p7mX9FkB4LNISCc6j/s/Ufv85MXPbn0S5rm9UcQO9cINJb1RP1YgDDLN5cx
-Mz6X4nyofN8H6Lhvh4JDdBw4DfDEFERkVfF+bkZ7YW4XHEChgzm3RxCF0eeGzIXG
-rkkK9AsSdJAhOvTlHPFCQKXTYZhsL5+3Ma4RnWnDWvLTHx6KzoU+twTM2mYhhQuQ
-gQpnmDHxGge8kGeHGtfdgAjtVJTE57xF/shP0JU+tuIV8NNhQ/vEmhL0Wa093/Ev
-pTVp0EUEuDh9ORRH5K5M4bKJyU4XX5noiht6yOn00uaoJcWduUAWsU+cDSvDTMw8
-1opWWm0QIAV3G2yuRSkumHAKqvQLeyeyiKz+OEhyEiZ7EZNExPD0TSpApSTU6aCT
-UAvPYGQ59VjsMHTuJ9r4wKIYaDvfL+t72vg2vTQma5cTOBJfIdxH9blFTjEnToH3
-LX8t0XndQ2RkiRnIze2p2jUShxo/lWCjCw+2Iaw0A0fNUK1BbOrFRPq1u7AnEuMJ
-t7HF50MloItM97R9vofDwgDIzlX/PzlVRcn1WCo8Fr/0EXxPPreX0YDIp1ANQ8fS
-v7bKb2vQIxWuCQIDAQABo0IwQDAdBgNVHQ4EFgQUVJVRJJ2k/Z4r0M1AXe6agyD4
-uCwwHwYDVR0jBBgwFoAUEHtrxWCk96Ehr60E0HBuwLk2i+IwDQYJKoZIhvcNAQEL
-BQADggIBAGEvSkxhxRKmlvKG8wCXop2OaUUAOG16+T96vd+aFYaJNlfGoPvqv4Lw
-qaHztVktnRrJ//fpNWOsdxkE1uPU4uyGjl2KbyH81JvkE6A3OX0P4B01n8lcimY2
-j3oje6KjORUouYVsypD1VcwfWJgsE3U2Txv5srD8BoemVWgWbWjfyim4kk8C5zlf
-tWEazVAaI4MWecqtU4P5gIEomCI7MG9ebxYp5oQhRxeOndOYdUbSzAkZj50gXFA1
-+TNkvuhTFlJF0F7qIFVJSJTmJ+6E5B4ddbkyUYwbOdO+P8mz5N5mSljE+EiIQTxo
-AwbG8cSivMy/jI3h048tCUONAJzcSWCF4k1r9Qr6xbyW2ud2GmKiFCEYJkYTsMWV
-fM/RujTHlGvJ2+bQK5HiNyW0tO9znW9kaoxolu1YBvTh2492v3agK7nALyGGgdo1
-/nN/ikgkQiyaCpZwFeooJv1YFU5aDhR9RjIIJ9UbJ8FdAv8Xd00E3viunLTvqqXK
-RVMokw+tFQTEzjKofKWYArPDjB9LUbN+vQbumKalis3+NlJ3WolYPrCg55tqt1o3
-zXi+xv7120cJFouilRFwrafNFV6F+pRMkMmiWopMnoVJPVXcoqyJRcsmO62uslhg
-BLFgAH4H/14drYrgWIMz0no78RInEz0z507zwLkWk5d9W9pJ/4Rf
+bGhvc3QxIDAeBgNVBAoMF0NsaWVudCBDZXJ0aWZpY2F0ZSBEZW1vMB4XDTI1MDcy
+MTE1NTYxOFoXDTM1MDcxOTE1NTYxOFowEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0G
+CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC4ggn74iAHLgOWOiOvB2CPe+Hr7W6S
+TYJLZOoqPdh7mv7QGm8cYxfD+26p13aEaW4/qn45losWdEPPy2ZiVIF+kcOP0R4A
+qsB0w9UHT4WSzCWtDqs8ywDMJ6tHge0++8S1bTpdutn/m8DPnKtkD9RQUzLFmGDO
++mB08Xu+egTzJvURbHXRJ27E+CXUXLEHbAJd8EKjJiQYXhcj4lzUXOUg+xkpPAGe
+1dgQ6BDkv3xq/81S9NTIT5YriHEm6egi9AFJLZbbZtCpRQm1MDMq7zfD7oL6ECLG
+rJ/aaxLEM49gMdw2SscYHotVxX2OMAKgN/ytB18L/mIQ4pOWp3HJQ+nks9Zu1V8c
+g7Pz5pWwjqoncbyUaBi3vGsitAot3cyLXbN9hH8zQB8QqGyNLvqQnCJOBlYxOPA8
+M8NQGDThWKspcix0LhkmnYsWWt3+KEGEpFRcJCEthm/DAd1GImP7/dg1/btT/zOs
+IIkIoCyBwznuR4M4XoNTbIBsiTnO/6PjOdTrjLVX7vMueTjdbCgK3VeOuwetbZ7a
+Z/hvMJCjJ4wuM3l2ZyfEQlP4gJLJS3Fw2PRsySZJl9JyEzwTqYVosDF5SF8uw0HI
+cFaliZCqBbgYfOiQzjIX/GiHZdor1ZrhAbO/MpSxuxGzxF7Em4n+4p816NnC9S2J
+bHRetkM9P1adHwIDAQABo0IwQDAdBgNVHQ4EFgQUXhGloOgfXb0tY7HZZGil/d11
+bcwwHwYDVR0jBBgwFoAU8doR+Mmgh+1KQdNvybCZ7bsu2J8wDQYJKoZIhvcNAQEL
+BQADggIBADNVu8YodDjB0474ztGSjV8WO0x984WQpGG6VPIt9xnnswNM8aOZVMNC
+AS12BjgviutSBUbL40xYNlytnqP0KtlgZSNpPVTGMAOoGttbgV7w46+hyBgV4hYs
+PsYrxMU1/4hTW/aGnNXpWJ4VwOESknSqUudzfy1mNVaEuPoL97SCvPrlKPU6El1a
+Wmove/QTKsbsjWaahqE59uClQ6CBcWbxpN5CLyIVM4c/UrsoXdwRewgXl19YFRzR
+l6LXBPid4UPQqdE6XIxgsNpoTDwAyxSRMPydlulJD5sSTaXHB7h63DsT9mEydjR3
+jPjhNZL5ADtDes3/UhfpXDbb8MudXdbdsHNswEl5ewAOdRXAuoaJuQ2TOnhz+cO0
+oaq9X3YaWjl8SwdvZrLIHLG3jEAQYEXDR+dEtT6vs7HmReMrYhGGoCEVrjSZAaeO
+9bQoSe0m8xbuSV19e5A+LZv3bcPcVOe91x/wnjVb98KRQcSQXCBE3yT5Oav/OLKZ
+TrdRkKe1yyPMHJiicn3pffdXuG6mIJC8HgYhvJEX/wkWf1BiyRd44dD1cgI1Ttt1
+pQoapJCmjA0XHtr15o4TW6hmnrmOOYTOVCCug8h1bWscBedMgdR5Qm+umbUiuC3N
+N6mxD49Sc40NCeDboX87rDiObhOXAAFsiE9o39z/tPToVa3TsJsA
 -----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/trusted/cert.pfx b/tests/assets/client-certificates/client/trusted/cert.pfx
new file mode 100644
index 000000000..391dea7b8
Binary files /dev/null and b/tests/assets/client-certificates/client/trusted/cert.pfx differ
diff --git a/tests/assets/client-certificates/client/trusted/csr.pem b/tests/assets/client-certificates/client/trusted/csr.pem
index 8ead6da3d..fc930ea7c 100644
--- a/tests/assets/client-certificates/client/trusted/csr.pem
+++ b/tests/assets/client-certificates/client/trusted/csr.pem
@@ -1,26 +1,26 @@
 -----BEGIN CERTIFICATE REQUEST-----
 MIIEVTCCAj0CAQAwEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0GCSqGSIb3DQEBAQUA
-A4ICDwAwggIKAoICAQCac3+4rNmH4/N1s4HqR2X168tgS/aA6sHW5at8mWRnq54N
-m11RvnK55jHQYVAdBgJy5M07w0wakp8inxzlY95wqxBimYG63Un/1p7mX9FkB4LN
-ISCc6j/s/Ufv85MXPbn0S5rm9UcQO9cINJb1RP1YgDDLN5cxMz6X4nyofN8H6Lhv
-h4JDdBw4DfDEFERkVfF+bkZ7YW4XHEChgzm3RxCF0eeGzIXGrkkK9AsSdJAhOvTl
-HPFCQKXTYZhsL5+3Ma4RnWnDWvLTHx6KzoU+twTM2mYhhQuQgQpnmDHxGge8kGeH
-GtfdgAjtVJTE57xF/shP0JU+tuIV8NNhQ/vEmhL0Wa093/EvpTVp0EUEuDh9ORRH
-5K5M4bKJyU4XX5noiht6yOn00uaoJcWduUAWsU+cDSvDTMw81opWWm0QIAV3G2yu
-RSkumHAKqvQLeyeyiKz+OEhyEiZ7EZNExPD0TSpApSTU6aCTUAvPYGQ59VjsMHTu
-J9r4wKIYaDvfL+t72vg2vTQma5cTOBJfIdxH9blFTjEnToH3LX8t0XndQ2RkiRnI
-ze2p2jUShxo/lWCjCw+2Iaw0A0fNUK1BbOrFRPq1u7AnEuMJt7HF50MloItM97R9
-vofDwgDIzlX/PzlVRcn1WCo8Fr/0EXxPPreX0YDIp1ANQ8fSv7bKb2vQIxWuCQID
-AQABoAAwDQYJKoZIhvcNAQELBQADggIBAGgf3EC8WL3RGmuGA+d/4wd1jNfrfU6n
-xjnDwdEEX0TQZGGPjh5xvoCK76yZPkO6+z0IYSepEmWBS27HJKl7nuoOvS7MjQyJ
-C+3Bdk3ToCeQjmNBlRBKsUw5ftTU902oMl5BptHGj1KGjYBLAkPdXb44wXSVKJ8q
-ihFhWlovsva6GDoUorksU3vOwijdlGzTANQHJGFncgrRud9ATavpGS3KVxR73R3A
-aBbu3Qw+QIfu8Qx5eBJp8CbMrpAmjfuq17STvqr5bC10Fnn4NegrnHOQG9JcK02+
-5Bn3+9X/n1mue7aohIdErLEiDMSqMOwFfrJeaH6YM1G4QkWyqGugtmHsWOUf0nlU
-nkH1krvfw9rb6b+03c4A6GSeHnbX5ufFDSf5gaR6Wy7c0jBnoxVbtBLH2zXlrd0k
-iRQG7C6XZzGMS7hb7GL7+bkRy9kWjmDL7z7Fp+EgzKhNmzuWII3E9X9va33HoQ/Q
-UdK3JVToxRQg6XRKOxL9+U/+8i6U8lxObLWkWh2cypZqbz5qJxa+2u5JYO/KEoHZ
-G963UX7XWezR98vZuTc1XHGZtBDMrjjDd7Kmb4/i/xBPeWwseeGtzFy9z2pnEnkL
-uKE4C8wUNpzUUlsn4LneZXObIoErE7FqAAlVFujVe7iaJBmXoUXZR36drbfiaODK
-vwAGyrYHaOlR
+A4ICDwAwggIKAoICAQC4ggn74iAHLgOWOiOvB2CPe+Hr7W6STYJLZOoqPdh7mv7Q
+Gm8cYxfD+26p13aEaW4/qn45losWdEPPy2ZiVIF+kcOP0R4AqsB0w9UHT4WSzCWt
+Dqs8ywDMJ6tHge0++8S1bTpdutn/m8DPnKtkD9RQUzLFmGDO+mB08Xu+egTzJvUR
+bHXRJ27E+CXUXLEHbAJd8EKjJiQYXhcj4lzUXOUg+xkpPAGe1dgQ6BDkv3xq/81S
+9NTIT5YriHEm6egi9AFJLZbbZtCpRQm1MDMq7zfD7oL6ECLGrJ/aaxLEM49gMdw2
+SscYHotVxX2OMAKgN/ytB18L/mIQ4pOWp3HJQ+nks9Zu1V8cg7Pz5pWwjqoncbyU
+aBi3vGsitAot3cyLXbN9hH8zQB8QqGyNLvqQnCJOBlYxOPA8M8NQGDThWKspcix0
+LhkmnYsWWt3+KEGEpFRcJCEthm/DAd1GImP7/dg1/btT/zOsIIkIoCyBwznuR4M4
+XoNTbIBsiTnO/6PjOdTrjLVX7vMueTjdbCgK3VeOuwetbZ7aZ/hvMJCjJ4wuM3l2
+ZyfEQlP4gJLJS3Fw2PRsySZJl9JyEzwTqYVosDF5SF8uw0HIcFaliZCqBbgYfOiQ
+zjIX/GiHZdor1ZrhAbO/MpSxuxGzxF7Em4n+4p816NnC9S2JbHRetkM9P1adHwID
+AQABoAAwDQYJKoZIhvcNAQELBQADggIBACpScaAoLAs9DuTcI5Y4dbHf7LwF4Zxx
+UgPNzE1HB1Pr6NaHRiOWrlCtDEB5UwHrr0oZuRTqSEGg3Pe5Z2QtPG/sdFgfm4BP
+29o6qo0CXiEVBwU7/K0/lL2/0a7uSbD0Tkw9d6Bgik7/Z5rzXZIi2vtUcrOtHskP
+C+Z9w3vH9a+RnUeo52mCnRi4SaiSEnD5jvhmgaI9iF+k5pYBiMrKRj5W/F1QCkf4
+7OuSK97xN0eG/I4Oxgzi/qt51ySCYZbqoh7dIpwi/a4UsK8kdzDDI1M3J7bU07cO
+CJRfr0EETqCQw/gAKoag3tRFNvWQB6Z9G3Ev5jeaCLpcc32NlpN5xH3VW8A0Zb81
+dn5BXkPSxjwJaD0a3cLFkfgrasoe7ZMmHrVpQDw+9USuGCYXMPzNZLEeTFbrRkUn
+sqi30e28E1H69zVWj+OKzCWEH/azVlfaoVbwM+njUJDe5V09KvFtI7aZYmvLxbUX
+4ifoRUVoKedyKnueVmoIG57lF2VzeEhX5YjCngxIg+YuE99HkMQAZSlS6uJcVM92
+tsC/+pYECBk8ukenbxmKXROl3u4p2M1iCSL/8EOVROuyjnuzCXJZOpNptdpX4ZgL
+kHP1erq7/U8ZU8HviUsfMoisagx8dA8uj/4fk0jfNxOJqlZL9eJhpgBfYHqmAz3h
+m+PQVw96eeoK
 -----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/trusted/key.pem b/tests/assets/client-certificates/client/trusted/key.pem
index d60201e5a..a11cdc8a7 100644
--- a/tests/assets/client-certificates/client/trusted/key.pem
+++ b/tests/assets/client-certificates/client/trusted/key.pem
@@ -1,52 +1,52 @@
 -----BEGIN PRIVATE KEY-----
-MIIJRAIBADANBgkqhkiG9w0BAQEFAASCCS4wggkqAgEAAoICAQCac3+4rNmH4/N1
-s4HqR2X168tgS/aA6sHW5at8mWRnq54Nm11RvnK55jHQYVAdBgJy5M07w0wakp8i
-nxzlY95wqxBimYG63Un/1p7mX9FkB4LNISCc6j/s/Ufv85MXPbn0S5rm9UcQO9cI
-NJb1RP1YgDDLN5cxMz6X4nyofN8H6Lhvh4JDdBw4DfDEFERkVfF+bkZ7YW4XHECh
-gzm3RxCF0eeGzIXGrkkK9AsSdJAhOvTlHPFCQKXTYZhsL5+3Ma4RnWnDWvLTHx6K
-zoU+twTM2mYhhQuQgQpnmDHxGge8kGeHGtfdgAjtVJTE57xF/shP0JU+tuIV8NNh
-Q/vEmhL0Wa093/EvpTVp0EUEuDh9ORRH5K5M4bKJyU4XX5noiht6yOn00uaoJcWd
-uUAWsU+cDSvDTMw81opWWm0QIAV3G2yuRSkumHAKqvQLeyeyiKz+OEhyEiZ7EZNE
-xPD0TSpApSTU6aCTUAvPYGQ59VjsMHTuJ9r4wKIYaDvfL+t72vg2vTQma5cTOBJf
-IdxH9blFTjEnToH3LX8t0XndQ2RkiRnIze2p2jUShxo/lWCjCw+2Iaw0A0fNUK1B
-bOrFRPq1u7AnEuMJt7HF50MloItM97R9vofDwgDIzlX/PzlVRcn1WCo8Fr/0EXxP
-PreX0YDIp1ANQ8fSv7bKb2vQIxWuCQIDAQABAoICAAyXg/8rYGS6ydt7sgjGn2Jo
-QeFs8ADcoscBXHTBELV/AVi8pOQIMdREFyWU+XIUTljNnInVxzuXXo/1BucQuE7Z
-M3HGcBQq/GB2P+gqQaj1D83neIAyfNm2YIoIgqJvbtyi2VMhBhUlu8c4emIuqLTx
-Zoj61EG3ms/JMD6QR6Keb4LwOkeDjNVpFYr22AiSFSkolmhyrgYGUKKaTzdI/Ojc
-DxMnU3S6OsxAzzJG/IUpCFQxgt3S5XIRT9rqGwxVaYqYGcpKfOeHbvcEFUriouqM
-l6z96s5yJsYBW3j7lUvjPf1+y8CMMq4eqi5PckMGnZAcQj6lrFL7mlAgucLyiL7w
-o30seXvzoEQXlHxi/tnoZMWaBbntA6TV8t0ap7TMADPPSrXhXt+GIQt6tDTdYd8y
-9VxGAQA0s6FhdURVp0zYtTGrsFTLyHZjC0TFxsvOdRrQL3XbsQxPUCH86Z3hQt9d
-drgxPDJJo/4UUYOX7MAyE3H7zW7qSQ8tNSXPHewff0ItpcrUvBxa8cD95DGB3kws
-0Ns1ulGqOLMPZM3/MUYlDk0PEK1ClBqC1B78mkMpJe5qTYBaFg7S540X4E5Nrq5V
-5VK4QTsBGm9Xks4///psGwmstCVZAZDCyMbW3NOFtzOxsVqi027xknl7UEtfwNFf
-c8tp0CaxZhW8/YTXUtnxAoIBAQDSR/Ux4tfDp84Tyf5N8JaxY1iYA1sor4SQnoSE
-r0/J2UXQpZjNpCT/fOjBT19jJCWQUxUf3M6PE0i40VMcJgtQE9alTTz3iCCUokv+
-IcVxrS+7rdvQGPItoIIZDSKGlAJHoIsMnqGAHpks588ptgPC/FEiNX2nae2CrGRS
-jVcPOLA+St6qGEwPyaSKXjERwSQ9bHLIuKbMDs2+YpPOSp9iLKaW11UQYxF3Uxti
-pVRq5bbqlKFOxxp4PaTZRusWpdWJ1kmpmEpZg6PiUQVeOoOy+hCbLq3KW1aaTc3x
-UcYrbA2hW5vP0u4x4QNPayd8MNEsGHBClObOtD64Vz3lsMFdAoIBAQC8CBoP6Tzy
-1uGNmAOc9ipQwAcTAzPnOH+ouKBwB/5ji/RPrwGCOqjbapmriKtYxW2JOqbTzbze
-+WvGwgfoPo16FZocDMrD90lQdFmfcgnHFZgXZe2k8zr3YTvXdkCCRkthrl9tKN94
-IuNL5K4wMIiPy08B7+dMxnKP4E8C8czzcyrXpdfy/gfu7UQGETYswjmLL1vOr1OE
-WaalbJn/5GDzKKLkcx+Xr4zgHzbyCXb/K+LvawGk0MQMTtbRkphNC2yNejNjQd8F
-wmccFK4LG9JqdjVhKiDiYIKe5ocWDcZ28sBuKyFxOthOywP6tnALIjQgXamsLIZj
-GhCG3g3dAfidAoIBAQDQM7EhgKHztl1DmLczgmgiIORiNsh2gzp1Wo6JNW+Bwp/u
-k1e1HLYJRSrL5APlDLAosypyTtUyMnzJiXCJqV2AHvRi3RPlXqIrqHonmFZ/VGOz
-ptPCukBnTsohdbDeoQOU2e9zQklTqngtTyP9/5q/38WRYncUYLxqqrf2SL2Pc6iF
-NOo8biw5YYSJ//MDykFQk+Ueuj1kQ7AQtlf0ZExlDyKurWwq+nwbsmymAl6QLPws
-TZddgaPCs/5Zp28zEGVawZJT2labRMzqUyBGiRdHCXORwukON9uKkki7jCTzb1wb
-jLG8VvPC7TCy3LzOqSMiTtwwAHB671o+eRrvJlB9AoIBAQCb2J85Vtj0cZPLFxbP
-jtytxytV386yM4rjnfskQAviGErrjKLUfKgeDHHH0eQrFJ/gIOPLI3gK23Iv7/w7
-yzTZ3nO4EgYxfJGghH8P/6YJA2Xm5s2cbRkPluDRiaqYD4lFMhDX2gu2eDwqWCTj
-viZCAIHAmkX8xXKIu6LhTubPVUJKMKQXO+P5bWB3IubjHCwzp5IRchHn3aKY87WE
-eZa9k43HiX/C6nb6AAU7gQrHHmnehLN9FqeXh/TXCQkAuppDfOiAuUUPcfyiMqW6
-gVnacZV2rkNJPjKlX27RoaNATZ2e8lKqldpZHD11HKcrIzNPLDKIiPLtytmt3vhg
-mNSlAoIBAQDMN3FoQfV+Tlky5xt87ImsajdIhf7JI35hq6Zb4+vwR7/vofbzoomS
-+fuivH1+1skQIuEn41G4uwZps9NPRm5sWrjOo869DYPn5Nm8qTGqv/GD28OQQClB
-3/vcwrn5limm3pbQg+z+67fFmorSyLHcZ+ky60lWeE9uXCsVjt7eH6B+Rhs9Jafg
-MbWRZ1C3Gezb1J42XVZ8hczn6r+qmWFTbSY4RzNBqd83motWXIgtybJIV4LB4t06
-JkVNCotSicw0vtZk95AfjQksemAq2fFzJfASxtw8IE/WHW4jtvfZ9PPWDt9U83ll
-Y+eu85cike5J4vnz8uG04yt7rXjIrUav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 -----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/generate.sh b/tests/assets/client-certificates/generate.sh
new file mode 100755
index 000000000..f835f5f32
--- /dev/null
+++ b/tests/assets/client-certificates/generate.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Client Certificate test-certificates
+
+cd "$(dirname "$0")"
+
+## Server
+
+openssl req \
+	-x509 \
+	-newkey rsa:4096 \
+	-keyout server/server_key.pem \
+	-out server/server_cert.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=localhost/O=Client\ Certificate\ Demo" \
+	-addext "subjectAltName=DNS:localhost,DNS:local.playwright"
+
+## Trusted client-certificate (server signed/valid)
+
+mkdir -p client/trusted
+# generate server-signed (valid) certificate
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/trusted/key.pem \
+	-out client/trusted/csr.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=Alice"
+
+# sign with server_cert.pem
+openssl x509 \
+	-req \
+	-in client/trusted/csr.pem \
+	-CA server/server_cert.pem \
+	-CAkey server/server_key.pem \
+	-out client/trusted/cert.pem \
+	-set_serial 01 \
+	-days 3650
+# create pfx
+openssl pkcs12 -export -out client/trusted/cert.pfx -inkey client/trusted/key.pem -in client/trusted/cert.pem -passout pass:secure
+
+## Trusted certificate for localhost (server signed/valid)
+
+mkdir -p client/localhost
+
+# generate server-signed (valid) certificate
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/localhost/localhost.key \
+	-out client/localhost/localhost.csr \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=localhost" \
+  -addext "subjectAltName=DNS:localhost,DNS:127.0.0.1"
+
+# put extensions
+echo "subjectAltName=DNS:localhost,DNS:127.0.0.1" > client/localhost/localhost.ext
+
+# sign with server_cert.pem
+openssl x509 \
+	-req \
+	-in client/localhost/localhost.csr \
+	-CA server/server_cert.pem \
+	-CAkey server/server_key.pem \
+	-set_serial 01 \
+	-out client/localhost/localhost.pem \
+	-days 3650 \
+  -extfile client/localhost/localhost.ext
+
+## Self-signed certificate (invalid)
+
+mkdir -p client/self-signed
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/self-signed/key.pem \
+	-out client/self-signed/csr.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=Bob"
+
+# sign with self-signed/key.pem
+openssl x509 \
+	-req \
+	-in client/self-signed/csr.pem \
+	-signkey client/self-signed/key.pem \
+	-out client/self-signed/cert.pem \
+	-days 3650
diff --git a/tests/assets/client-certificates/server/server_cert.pem b/tests/assets/client-certificates/server/server_cert.pem
index 52d8f5314..18ee3d805 100644
--- a/tests/assets/client-certificates/server/server_cert.pem
+++ b/tests/assets/client-certificates/server/server_cert.pem
@@ -1,32 +1,32 @@
 -----BEGIN CERTIFICATE-----
-MIIFdTCCA12gAwIBAgIUNPWupe2xcu8YYG1ozoqk9viqDJswDQYJKoZIhvcNAQEL
+MIIFdTCCA12gAwIBAgIUFhAlW/DnHoHOFg2CXKBAvwYN4BIwDQYJKoZIhvcNAQEL
 BQAwNjESMBAGA1UEAwwJbG9jYWxob3N0MSAwHgYDVQQKDBdDbGllbnQgQ2VydGlm
-aWNhdGUgRGVtbzAeFw0yNDA3MTkxMjQ3MzNaFw0yNTA3MTkxMjQ3MzNaMDYxEjAQ
+aWNhdGUgRGVtbzAeFw0yNTA3MjExNTU2MThaFw0zNTA3MTkxNTU2MThaMDYxEjAQ
 BgNVBAMMCWxvY2FsaG9zdDEgMB4GA1UECgwXQ2xpZW50IENlcnRpZmljYXRlIERl
-bW8wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC+K5JWhlfvI47ZL/Az
-L0xnOl+cMelr2BqH+7XS8187SbvluhFfFkq/7V7rwgsHI64sn8pgRCOnqKWV6jtb
-651dGzn7Nby6InmyOQzF4VwfSVWQ6BYXgXuryS9Gm0gi8sOL1Ji/jV49n1gzLyIx
-LNhd7NG2DCCedTHJnxyz4xq8MWhI/qI85iWJqcHhxkDb8wtH1Vd6nd/ZRVDbjgTv
-PH3EDK7JqmnYG9+x4Jz0yEhvV7jL3gNu2mIyttvm7oRna9oHgaKFUJt4BCfPbT5U
-3ipvcq29hdD5/5QIDzTWcExTnklolg5xpFext1+3KPSppESxcfBBNoL3h1B8ZcZa
-lEMC/IoFUIDJQj5gmSn4okwMWIxgf+AL0609MKEqQ2FavOsvBmhHcQsqLk4MO/v0
-NGFv1/xGe4tUkX4han6ykf1+sqzupJT5qnUONmvghb2SpIt83o4j4KHVzZwk8JK0
-N6hN7JEjXQwSKCh3b0FFg+kPAe12d6BBcsNzEYmt2C1KNPbXMX84zIkgPN01XMg6
-kdCdjP6DH7CK+brW9qQufOqYpd3eNhJyeBm+oP3PhnhEiMTIO8X2GdSN5Rxozgxl
-VIj/QWhLV64r5AqPr/Vpd1vcsxrg3aS5CASmoWQmTPuhEZptRtrkPkGw7k9NPZ34
-lnRenvKJ9e3DXhXRMqeYUY6wjwIDAQABo3sweTAdBgNVHQ4EFgQUEHtrxWCk96Eh
-r60E0HBuwLk2i+IwHwYDVR0jBBgwFoAUEHtrxWCk96Ehr60E0HBuwLk2i+IwDwYD
+bW8wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDYDbBlM8ILtq2xKLFU
+ZwU4n7+0VHsO0skCfyNwpSZndbArjJUd/ZgFyCy5RK5Cg23KtXSMgkU6QlXOWvIr
+WJ/1wAkH9tuef/JDo9NJ00jBeua7HjdudNAsz6WwXSZC+a6DhA7nVHNwuyqq1SyH
+g5tuSP294EwfbEhXhaDyfXyBa4PaEmyjD2+O1NHSZ1AuUhblcUelKkZbykMvwCb7
+gJVXxlm/SN0K4vOVq80dBknr785562hDFGoXFX9hd2uPCQKbWGdMca+MmRWwNM2B
+CuxVoUl/Ooqmr7AdZ62lhpcqCd+todWC5GzrxwZjcIwt5P7MDvd+Ktmc8ePcZhp3
+L3ddlxXNgfi+c9OnZaz1QVgEn1YlDAmHvQtj9H+v2mmawyyRycjmhIpV/eaXaJvW
+A2wq+O2OERl056IjjzcXHrD6DOk7IjlTwQ87AMU4mNrCzW1LLd428OxQdGv2I4/b
+nq+0snOJOrTk65upybJYMGKUuTRqfEQgv5d/923VUISC69uTq+0zVFxG3pyMJR2D
+O+6xinBkp0Gk+ft9L4aaBAYXyUmi+PRSfdTfUk3yQkYefC55QTDDRK2rb7JiQqzr
+xhJ2vBar0TqXShQKKlMaOWHd+1U2ZjuyzboDDPeACoAmUVY2IHs+P8Dem0fwuKNd
+TF4jZkVQIWWLfTzzghOelmy9mwIDAQABo3sweTAdBgNVHQ4EFgQU8doR+Mmgh+1K
+QdNvybCZ7bsu2J8wHwYDVR0jBBgwFoAU8doR+Mmgh+1KQdNvybCZ7bsu2J8wDwYD
 VR0TAQH/BAUwAwEB/zAmBgNVHREEHzAdgglsb2NhbGhvc3SCEGxvY2FsLnBsYXl3
-cmlnaHQwDQYJKoZIhvcNAQELBQADggIBALP4kOAP21ZusbEH89VkZT3MkGlZuDQP
-LyTYdLzT3EzN//2+lBDmJfpIPLL/K3sNEVSzNppa6tcCXiVNes/xJM7tHRhTOJ31
-HinSsib2r6DZ6SitQJWmD5FoAdkp9qdG8mA/5vOiwiVKKFV2/Z3i+3iUI/ZnEhUq
-uUA1I3TI5LAQzgWLwYu1jSEM1EbH6uQiZ8AmXLVO4GQnVQdbyarWHxIy+zsg+MJN
-fxIG/phDpkt1mI3SkAdpWRWjCKESQhrIcRUtu5eVk0lho6ttHODXF8bM7iWLoRc7
-rpcllI4HXHoXQqQkZHRa7KwTf0YVwwQbXTecZONWXwE9Ej5R5IcZzja5FWCSstsb
-ULNW0JVxGBE7j5aOjxasYAbRexDmlfEdLvnp6bctZuvMvuBxrB+x5HSEZl6bVnbC
-nvtoslylQJM1bwlZdCqJm04JXe1787HDBef2gABv27BjvG/zn89L5ipogZCrGpl6
-P9qs0eSERHuSrm3eHUVgXSQ1nbvOpk7RPFbsbp/npc1NbEDBdAMoXhLP9A+ytxLq
-TF+w08nfCF6yJJ3jTkvABo10UH6zcPnfH3Ys7JYsHRbcloMfn+mc88KrTaCO+VZx
-qjhFcz+zDu/AbtJkDJtxX2X7jNL0pzWS+9H8jFTrd3ta8XrJiSFq2VMxEU6R0IHk
-2Ct10prMWB/3
+cmlnaHQwDQYJKoZIhvcNAQELBQADggIBAH1/6Sp4dW96yvwi9ptgVRYfRSRWfYYy
+2nU6kJ1DPOW7hTPf2wLf6Z2KqiJXn8tECHfM4pnPSgDhtZHDDHAu9l7Diqzk/NIl
+AblRs++4vSKdnCx1uh3EFLjIMmHa/cRUzfuR+oGfri3v7jgTBV6UJJQ0pMqIDk/P
+VEOWWukllru40M8Rwy4F6LmpwIWMtNDxmhtXSbQJ6TZn+isNSoaWgHjQmayrVyXZ
+OcNYuR8M/ECvnufuIOW53+hhwG1X0jEoBdXqqXbTKcGjA+yLHp008AAB5DNQblYm
+FJ4N0v6eYLhOO0u3n0b/ZsqUkZx2h38tlZoAdJNqy+d4TE3WbGRNgNJrTjAOzpPL
+cQ5RNr3dDsUDFPnCoK3LUf9BWerARoDt+bbrM/VqvWH/0uqaU0/vo8IchSyQ9wGv
+SwrWLJU32HQUJ2VQP/m4ADf3X2Ozj+e8bBf7XPPD8KDyL4aR0KuYzrsOnhFlBkHD
+PtNjc7SgiE7AZe1WOEmhBQcr+vI6S8qFTurTntCBkvrFgYBAIIhK2XwFN5sFtByr
+GCB67NQMp37g2qFNYi8EmKQvPLpAcC3Je5PvHFSj2y9Z14FclGoxjU50SlH9/A5I
+iHGcIVjCv9NhNDFAwakF/sTnrpT/FIS7tm9GwoJGWCdYg4pl72WYCW6hJBG+XY7G
+t3jt9TP8623D
 -----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/server/server_key.pem b/tests/assets/client-certificates/server/server_key.pem
index ff6a3fc11..3a762bde7 100644
--- a/tests/assets/client-certificates/server/server_key.pem
+++ b/tests/assets/client-certificates/server/server_key.pem
@@ -1,52 +1,52 @@
 -----BEGIN PRIVATE KEY-----
-MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQC+K5JWhlfvI47Z
-L/AzL0xnOl+cMelr2BqH+7XS8187SbvluhFfFkq/7V7rwgsHI64sn8pgRCOnqKWV
-6jtb651dGzn7Nby6InmyOQzF4VwfSVWQ6BYXgXuryS9Gm0gi8sOL1Ji/jV49n1gz
-LyIxLNhd7NG2DCCedTHJnxyz4xq8MWhI/qI85iWJqcHhxkDb8wtH1Vd6nd/ZRVDb
-jgTvPH3EDK7JqmnYG9+x4Jz0yEhvV7jL3gNu2mIyttvm7oRna9oHgaKFUJt4BCfP
-bT5U3ipvcq29hdD5/5QIDzTWcExTnklolg5xpFext1+3KPSppESxcfBBNoL3h1B8
-ZcZalEMC/IoFUIDJQj5gmSn4okwMWIxgf+AL0609MKEqQ2FavOsvBmhHcQsqLk4M
-O/v0NGFv1/xGe4tUkX4han6ykf1+sqzupJT5qnUONmvghb2SpIt83o4j4KHVzZwk
-8JK0N6hN7JEjXQwSKCh3b0FFg+kPAe12d6BBcsNzEYmt2C1KNPbXMX84zIkgPN01
-XMg6kdCdjP6DH7CK+brW9qQufOqYpd3eNhJyeBm+oP3PhnhEiMTIO8X2GdSN5Rxo
-zgxlVIj/QWhLV64r5AqPr/Vpd1vcsxrg3aS5CASmoWQmTPuhEZptRtrkPkGw7k9N
-PZ34lnRenvKJ9e3DXhXRMqeYUY6wjwIDAQABAoICABfDfxpj2EowUdHvDR+AShZe
-M4Njs00AKLSUbjCpq91PRfUbjr8onHemVGW2jkU6nrHB1/q2mRQC3YpBxmAirbvs
-Qo8TNH24ACgWu/NgSXA5bEFa1yPh0M/zKH60uctwNaJcEyhgpIWjy1Q+EBJADduS
-09PhaRQUBgAxa1dJSlZ5ABSbCS/9/HPa7Djn2sQBd4fm73MJlmbipAuDkDdLAlZE
-1XSq4GYaeZYTQNnPy0lql1OWbyxjisDWm90cMhxwXELy3pm1LHBPaKAhgRf+2SOr
-G23i8m3DE778E3i2eLs8POUeVzi5NiIljYboTcaDGfhoigLEKpJ+7L5Ww3YfL85Q
-xk00Y0b+cYNrlJ3vCpflDXJunZ1gJHLDTixJeVMpXnMSi01+bSb8D/PTcbG3fZ0U
-y4f2G0M+gf+m3EMMD96yerPf6jhGlTqY+eMyNVwNVk4BIG+D/8nf13keAF4kVbPJ
-QMidnCNbu8ZiC12HqLyv3YZlseXPIkhpbYEhsj58sbG4Tms+mG/zPlTZjroIEdAX
-nwI1aoG+NAbe+WSH/P4SvIMi1o/fWoXBtb+t7uy1AG/Xbu414WED7iwvxtqJRQj5
-rhrqryWTGQKY1zVJIOxwZP0f5gSIkEITyE+rO6o6pbAZFX7N0aMIvksBkEN5mdoV
-RWzxfSVNGMWooRD5d3TZAoIBAQD1dvgOsLYP8lUfkKglLTqHQe3x75BVDR9zdTIt
-tQh9UIbyovPFdLcXrHHJMBVMPTRGeRNpjCT5BNSNbidrmAxYN7YXuSA4uy3bubNU
-76km5kmL2Ji+5u+qMm9Xycyqn30rLH9hT+9c/MVuPW6CNmETKX9+v9zb1v//RrBS
-2ZNAWjJcBYv/rS/vKsW9yH/DbM21eSeokUqpkejOk1UxVZEcb9vt8VF8p+jO1wv3
-+UgI4Gfkf3sjEL1m/hBvH5Z49RHTFj4npeK6Lko4NLLazU2904jbHxppH51UNH1j
-xp8Is+iNwW2qCOve8kSUUUjxLn4n45D2d+5qOqQTtsMWXHanAoIBAQDGVQ6UZqvo
-djfcULq0Jub1xpBfxIAg7jSY7aZ6H0YlG7KgpVTd2TUEEKgErxtfYufjtLjjWb/d
-lMG7UpkM5B4tFnpRDmvevltCqGsM3qi3AtPnzavgz2TAQy7qd2gJc8glE965LOfb
-l+mGzE4SzeFJ9WS7sUDf4WnX2xjt3OA0VCvcBRNIwCnEvXu81XLKZL6etBx6zdCt
-whWHIiqa4wkjuWEwvbeH4aWsh8gFY3E5mbvDdMFtyGWvTK8OGivl3CkdQxM+MOJD
-3aAEBTr0M7tSMy5IKewASlAWZEVpFFPIyiyMCTI0XcEgA7ewHw/F3c7cstgVktjm
-OYZytZPF0ZvZAoIBAB5+z0aT8ap9gtHPGPS1b8YKDNO33YiTfsrLTpabHRjkfj96
-uypW28BXLjO+g4bbO7ldpWnBfX5qeTWw77jQRQhYs4iy+SvTJVlc8siklbE9fvme
-ySs+aZwNdAPGEGVKNzS77H9cfPJifOy7ORV4SAsnZq2KjJfLWDaQw6snWMHv8r23
-+rKjA4eFGtf/JtBSniPjj2fD1TDH7dJsP3NHnCWaSAqBpowEGEpKMTR3hdmEd6PN
-qrCqjb1T5xrHI9yXJcXBx6sJUueqhJIDCg1g4D2rIB+I97EDunoRo1pX/L4KC+RA
-ma08OoGSO67pglRkYEv4W7QjJj2QV34TgJ0wk5UCggEALINom0wT5z+pN+xyiv50
-NdNUEfpzW3C7I1urUpt0Td3SkJWq34Phj0EBxNNcTGNRclzcZkJ9eojpllZqfWcx
-kqMJ3ulisoJ8zxAnvqK2sSSUVOFnYzSJA1HQ1NTp570xvYihI2R9wV5uDlAKcdP9
-bXEDI9Ebo2PfMpA9Hx3EwFnn4iDNfDWM6lgwzmgFtIE5+zqnbbSF0onN9R9o+oxc
-P8Val+rspzWwznFHJlZ0Uh478xlgVHh2wgpu+7ZKBfQM0kF8ryefkOXMBTr7SVXX
-BBLyn0Wxbzs+kFf+8B+c0mL17pQdzX0BXGMZNhEypBEtXYFSWD02Ky3cDCDOwsZR
-uQKCAQAKQtsUSO80N/kzsWuSxHhuLMTvNZfiE/qK1Mz5Rw1qXxMXfYNFZbU/MqW7
-5DLd4Kn7s3v1UlBn2tbLGLzghnHYRxT9kxF7ZnY6HZv2IrEUjE2I2YTTCQr/Q7Z5
-gRBQb5z+vJbKOYnlSHurTexKmuTjgJ/y/jRQiQABccVj1w5lIm1SPoxpdKzSFyWt
-0NVmff9VetoiWKJYldPBTOmqPUytuBZyX5fJ4pPixwgAns6ZaqJtVNyMZkZ/GoDk
-XP2CvB/HyMiS7vXK5QJYYumk7oyC15H6eDChITNPV3VGH2QqcdEvDLT81W+JZ2mX
-8ynLaTs3oV3BjQya9pAUyzIX5L67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 -----END PRIVATE KEY-----
diff --git a/tests/assets/simple-extension/content-script.js b/tests/assets/extension-mv3-simple/content-script.js
similarity index 100%
rename from tests/assets/simple-extension/content-script.js
rename to tests/assets/extension-mv3-simple/content-script.js
diff --git a/tests/assets/simple-extension/index.js b/tests/assets/extension-mv3-simple/index.js
similarity index 63%
rename from tests/assets/simple-extension/index.js
rename to tests/assets/extension-mv3-simple/index.js
index a0bb3f4ea..1523a8364 100644
--- a/tests/assets/simple-extension/index.js
+++ b/tests/assets/extension-mv3-simple/index.js
@@ -1,2 +1,2 @@
 // Mock script for background extension
-window.MAGIC = 42;
+globalThis.MAGIC = 42;
diff --git a/tests/assets/simple-extension/manifest.json b/tests/assets/extension-mv3-simple/manifest.json
similarity index 80%
rename from tests/assets/simple-extension/manifest.json
rename to tests/assets/extension-mv3-simple/manifest.json
index da2cd082e..39b77fc21 100644
--- a/tests/assets/simple-extension/manifest.json
+++ b/tests/assets/extension-mv3-simple/manifest.json
@@ -2,7 +2,7 @@
   "name": "Simple extension",
   "version": "0.1",
   "background": {
-    "scripts": ["index.js"]
+    "service_worker": "index.js"
   },
   "content_scripts": [{
     "matches": ["<all_urls>"],
@@ -10,5 +10,5 @@
     "js": ["content-script.js"]
   }],
   "permissions": ["background", "activeTab"],
-  "manifest_version": 2
+  "manifest_version": 3
 }
diff --git a/tests/assets/extension-mv3-with-logging/background.js b/tests/assets/extension-mv3-with-logging/background.js
new file mode 100644
index 000000000..3b1a406fb
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/background.js
@@ -0,0 +1,5 @@
+console.log("Service worker script loaded");
+
+chrome.runtime.onInstalled.addListener(() => {
+  console.log("Extension installed");
+});
diff --git a/tests/assets/extension-mv3-with-logging/content.js b/tests/assets/extension-mv3-with-logging/content.js
new file mode 100644
index 000000000..e718206c2
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/content.js
@@ -0,0 +1 @@
+console.log("Test console log from a third-party execution context");
diff --git a/tests/assets/extension-mv3-with-logging/manifest.json b/tests/assets/extension-mv3-with-logging/manifest.json
new file mode 100644
index 000000000..5ad1fde38
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/manifest.json
@@ -0,0 +1,17 @@
+{
+    "manifest_version": 3,
+    "name": "Console Log Extension",
+    "version": "1.0",
+    "background": {
+      "service_worker": "background.js"
+    },
+    "permissions": [
+      "tabs"
+    ],
+    "content_scripts": [
+      {
+        "matches": ["<all_urls>"],
+        "js": ["content.js"]
+      }
+    ]
+  }
diff --git a/tests/async/conftest.py b/tests/async/conftest.py
index 268c8a433..5dff9794f 100644
--- a/tests/async/conftest.py
+++ b/tests/async/conftest.py
@@ -13,19 +13,25 @@
 # limitations under the License.
 
 import asyncio
-from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, Generator, List
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, Generator
 
 import pytest
 
+from playwright._impl._driver import compute_driver_executable
 from playwright.async_api import (
     Browser,
     BrowserContext,
     BrowserType,
+    FrameLocator,
+    Locator,
     Page,
     Playwright,
     Selectors,
     async_playwright,
 )
+from tests.server import HTTPServer
 
 from .utils import Utils
 from .utils import utils as utils_object
@@ -36,12 +42,6 @@ def utils() -> Generator[Utils, None, None]:
     yield utils_object
 
 
-# Will mark all the tests as async
-def pytest_collection_modifyitems(items: List[pytest.Item]) -> None:
-    for item in items:
-        item.add_marker(pytest.mark.asyncio)
-
-
 @pytest.fixture(scope="session")
 async def playwright() -> AsyncGenerator[Playwright, None]:
     async with async_playwright() as playwright_object:
@@ -85,7 +85,7 @@ async def browser(
 
 
 @pytest.fixture(scope="session")
-async def browser_version(browser: Browser) -> str:
+def browser_version(browser: Browser) -> str:
     return browser.version
 
 
@@ -106,7 +106,7 @@ async def launch(**kwargs: Any) -> BrowserContext:
 
 
 @pytest.fixture(scope="session")
-async def default_same_site_cookie_value(browser_name: str, is_linux: bool) -> str:
+def default_same_site_cookie_value(browser_name: str, is_linux: bool) -> str:
     if browser_name == "chromium":
         return "Lax"
     if browser_name == "firefox":
@@ -137,3 +137,75 @@ async def page(context: BrowserContext) -> AsyncGenerator[Page, None]:
 @pytest.fixture(scope="session")
 def selectors(playwright: Playwright) -> Selectors:
     return playwright.selectors
+
+
+class TraceViewerPage:
+    def __init__(self, page: Page):
+        self.page = page
+
+    @property
+    def actions_tree(self) -> Locator:
+        return self.page.get_by_test_id("actions-tree")
+
+    @property
+    def action_titles(self) -> Locator:
+        return self.page.locator(".action-title")
+
+    @property
+    def stack_frames(self) -> Locator:
+        return self.page.get_by_role("list", name="Stack Trace").get_by_role("listitem")
+
+    async def select_action(self, title: str, ordinal: int = 0) -> None:
+        await self.page.locator(".action-title", has_text=title).nth(ordinal).click()
+
+    async def select_snapshot(self, name: str) -> None:
+        await self.page.click(
+            f'.snapshot-tab .tabbed-pane-tab-label:has-text("{name}")'
+        )
+
+    async def snapshot_frame(
+        self, action_name: str, ordinal: int = 0, has_subframe: bool = False
+    ) -> FrameLocator:
+        await self.select_action(action_name, ordinal)
+        expected_frames = 4 if has_subframe else 3
+        while len(self.page.frames) < expected_frames:
+            await self.page.wait_for_event("frameattached")
+        return self.page.frame_locator("iframe.snapshot-visible[name=snapshot]")
+
+    async def show_source_tab(self) -> None:
+        await self.page.click("text='Source'")
+
+    async def expand_action(self, title: str, ordinal: int = 0) -> None:
+        await self.actions_tree.locator(".tree-view-entry", has_text=title).nth(
+            ordinal
+        ).locator(".codicon-chevron-right").click()
+
+
+@pytest.fixture
+async def show_trace_viewer(browser: Browser) -> AsyncGenerator[Callable, None]:
+    """Fixture that provides a function to show trace viewer for a trace file."""
+
+    @asynccontextmanager
+    async def _show_trace_viewer(
+        trace_path: Path,
+    ) -> AsyncGenerator[TraceViewerPage, None]:
+        trace_viewer_path = (
+            Path(compute_driver_executable()[0]) / "../package/lib/vite/traceViewer"
+        ).resolve()
+
+        server = HTTPServer()
+        server.start(trace_viewer_path)
+        server.set_route("/trace.zip", lambda request: request.serve_file(trace_path))
+
+        page = await browser.new_page()
+
+        try:
+            await page.goto(
+                f"{server.PREFIX}/index.html?trace={server.PREFIX}/trace.zip"
+            )
+            yield TraceViewerPage(page)
+        finally:
+            await page.close()
+            server.stop()
+
+    yield _show_trace_viewer
diff --git a/tests/async/test_accessibility.py b/tests/async/test_accessibility.py
deleted file mode 100644
index 201ba8483..000000000
--- a/tests/async/test_accessibility.py
+++ /dev/null
@@ -1,392 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import sys
-
-import pytest
-
-from playwright.async_api import Page
-
-
-async def test_accessibility_should_work(
-    page: Page, is_firefox: bool, is_chromium: bool
-) -> None:
-    await page.set_content(
-        """<head>
-      <title>Accessibility Test</title>
-    </head>
-    <body>
-      <h1>Inputs</h1>
-      <input placeholder="Empty input" autofocus />
-      <input placeholder="readonly input" readonly />
-      <input placeholder="disabled input" disabled />
-      <input aria-label="Input with whitespace" value="  " />
-      <input value="value only" />
-      <input aria-placeholder="placeholder" value="and a value" />
-      <div aria-hidden="true" id="desc">This is a description!</div>
-      <input aria-placeholder="placeholder" value="and a value" aria-describedby="desc" />
-    </body>"""
-    )
-    # autofocus happens after a delay in chrome these days
-    await page.wait_for_function("document.activeElement.hasAttribute('autofocus')")
-
-    if is_firefox:
-        golden = {
-            "role": "document",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                },  # firefox doesn't use aria-placeholder for the name
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },  # and here
-            ],
-        }
-    elif is_chromium:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },
-            ],
-        }
-    else:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder"
-                    if (
-                        sys.platform == "darwin"
-                        and int(os.uname().release.split(".")[0]) >= 21
-                    )
-                    else "This is a description!",
-                    "value": "and a value",
-                },  # webkit uses the description over placeholder for the name
-            ],
-        }
-    assert await page.accessibility.snapshot() == golden
-
-
-async def test_accessibility_should_work_with_regular_text(
-    page: Page, is_firefox: bool
-) -> None:
-    await page.set_content("<div>Hello World</div>")
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "role": "text leaf" if is_firefox else "text",
-        "name": "Hello World",
-    }
-
-
-async def test_accessibility_roledescription(page: Page) -> None:
-    await page.set_content('<p tabIndex=-1 aria-roledescription="foo">Hi</p>')
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["roledescription"] == "foo"
-
-
-async def test_accessibility_orientation(page: Page) -> None:
-    await page.set_content(
-        '<a href="" role="slider" aria-orientation="vertical">11</a>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["orientation"] == "vertical"
-
-
-async def test_accessibility_autocomplete(page: Page) -> None:
-    await page.set_content('<div role="textbox" aria-autocomplete="list">hi</div>')
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["autocomplete"] == "list"
-
-
-async def test_accessibility_multiselectable(page: Page) -> None:
-    await page.set_content(
-        '<div role="grid" tabIndex=-1 aria-multiselectable=true>hey</div>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["multiselectable"]
-
-
-async def test_accessibility_keyshortcuts(page: Page) -> None:
-    await page.set_content(
-        '<div role="grid" tabIndex=-1 aria-keyshortcuts="foo">hey</div>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["keyshortcuts"] == "foo"
-
-
-async def test_accessibility_filtering_children_of_leaf_nodes_should_not_report_text_nodes_inside_controls(
-    page: Page, is_firefox: bool
-) -> None:
-    await page.set_content(
-        """
-    <div role="tablist">
-    <div role="tab" aria-selected="true"><b>Tab1</b></div>
-    <div role="tab">Tab2</div>
-    </div>"""
-    )
-    golden = {
-        "role": "document" if is_firefox else "WebArea",
-        "name": "",
-        "children": [
-            {"role": "tab", "name": "Tab1", "selected": True},
-            {"role": "tab", "name": "Tab2"},
-        ],
-    }
-    assert await page.accessibility.snapshot() == golden
-
-
-# Firefox does not support contenteditable="plaintext-only".
-# WebKit rich text accessibility is iffy
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_with_role_should_not_have_children(
-    page: Page,
-) -> None:
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only" role='textbox'>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "multiline": True,
-        "name": "",
-        "role": "textbox",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_without_role_should_not_have_content(
-    page: Page,
-) -> None:
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only">Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "name": "",
-        "role": "generic",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_with_tabindex_and_without_role_should_not_have_content(
-    page: Page,
-) -> None:
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only" tabIndex=0>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "name": "",
-        "role": "generic",
-        "value": "Edit this image:",
-    }
-
-
-async def test_accessibility_non_editable_textbox_with_role_and_tabIndex_and_label_should_not_have_children(
-    page: Page, is_chromium: bool, is_firefox: bool
-) -> None:
-    await page.set_content(
-        """
-      <div role="textbox" tabIndex=0 aria-checked="true" aria-label="my favorite textbox">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-      </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content yo",
-        }
-    elif is_chromium:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content ",
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content  ",
-        }
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_checkbox_with_and_tabIndex_and_label_should_not_have_children(
-    page: Page,
-) -> None:
-    await page.set_content(
-        """
-    <div role="checkbox" tabIndex=0 aria-checked="true" aria-label="my favorite checkbox">
-    this is the inner content
-    <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {"role": "checkbox", "name": "my favorite checkbox", "checked": True}
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_checkbox_without_label_should_not_have_children(
-    page: Page, is_firefox: bool
-) -> None:
-    await page.set_content(
-        """
-      <div role="checkbox" aria-checked="true">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {
-        "role": "checkbox",
-        "name": "this is the inner content yo",
-        "checked": True,
-    }
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_should_work_a_button(page: Page) -> None:
-    await page.set_content("<button>My Button</button>")
-
-    button = await page.query_selector("button")
-    assert await page.accessibility.snapshot(root=button) == {
-        "role": "button",
-        "name": "My Button",
-    }
-
-
-async def test_accessibility_should_work_an_input(page: Page) -> None:
-    await page.set_content('<input title="My Input" value="My Value">')
-
-    input = await page.query_selector("input")
-    assert await page.accessibility.snapshot(root=input) == {
-        "role": "textbox",
-        "name": "My Input",
-        "value": "My Value",
-    }
-
-
-async def test_accessibility_should_work_on_a_menu(page: Page) -> None:
-    await page.set_content(
-        """
-        <div role="menu" title="My Menu">
-        <div role="menuitem">First Item</div>
-        <div role="menuitem">Second Item</div>
-        <div role="menuitem">Third Item</div>
-        </div>
-    """
-    )
-
-    menu = await page.query_selector('div[role="menu"]')
-    golden = {
-        "role": "menu",
-        "name": "My Menu",
-        "children": [
-            {"role": "menuitem", "name": "First Item"},
-            {"role": "menuitem", "name": "Second Item"},
-            {"role": "menuitem", "name": "Third Item"},
-        ],
-    }
-    actual = await page.accessibility.snapshot(root=menu)
-    assert actual
-    # Different per browser channel
-    if "orientation" in actual:
-        del actual["orientation"]
-    assert actual == golden
-
-
-async def test_accessibility_should_return_null_when_the_element_is_no_longer_in_DOM(
-    page: Page,
-) -> None:
-    await page.set_content("<button>My Button</button>")
-    button = await page.query_selector("button")
-    await page.eval_on_selector("button", "button => button.remove()")
-    assert await page.accessibility.snapshot(root=button) is None
-
-
-async def test_accessibility_should_show_uninteresting_nodes(page: Page) -> None:
-    await page.set_content(
-        """
-        <div id="root" role="textbox">
-        <div>
-            hello
-            <div>
-            world
-            </div>
-        </div>
-        </div>
-    """
-    )
-
-    root = await page.query_selector("#root")
-    snapshot = await page.accessibility.snapshot(root=root, interesting_only=False)
-    assert snapshot
-    assert snapshot["role"] == "textbox"
-    assert "hello" in snapshot["value"]
-    assert "world" in snapshot["value"]
-    assert snapshot["children"]
diff --git a/tests/async/test_assertions.py b/tests/async/test_assertions.py
index d61e625c7..49e3c3e7f 100644
--- a/tests/async/test_assertions.py
+++ b/tests/async/test_assertions.py
@@ -145,6 +145,32 @@ async def test_assertions_locator_to_have_class(page: Page, server: Server) -> N
         await expect(page.locator("div.foobar")).to_have_class("oh-no", timeout=100)
 
 
+async def test_assertions_locator_to_contain_class(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div class='foo bar baz'></div>")
+    locator = page.locator("div")
+    await expect(locator).to_contain_class("")
+    await expect(locator).to_contain_class("bar")
+    await expect(locator).to_contain_class("baz bar")
+    await expect(locator).to_contain_class("  bar   foo ")
+    await expect(locator).not_to_contain_class(
+        "  baz   not-matching "
+    )  # Strip whitespace and match individual classes
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_contain_class("does-not-exist", timeout=100)
+
+    assert excinfo.match("Locator expected to contain class 'does-not-exist'")
+    assert excinfo.match("Actual value: foo bar baz")
+    assert excinfo.match('Expect "to_contain_class" with timeout 100ms')
+
+    await page.set_content(
+        '<div class="foo"></div><div class="hello bar"></div><div class="baz"></div>'
+    )
+    await expect(locator).to_contain_class(["foo", "hello", "baz"])
+    await expect(locator).not_to_contain_class(["not-there", "hello", "baz"])
+    await expect(locator).not_to_contain_class(["foo", "hello"])
+
+
 async def test_assertions_locator_to_have_count(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content("<div class=foobar>kek</div><div class=foobar>kek</div>")
@@ -274,6 +300,10 @@ async def test_assertions_locator_to_have_text(page: Page, server: Server) -> No
     await expect(page.locator("div")).to_have_text(
         ["Text  1", re.compile(r"Text   \d+a")]
     )
+    # Should work with a tuple
+    await expect(page.locator("div")).to_have_text(
+        ("Text  1", re.compile(r"Text   \d+a"))
+    )
 
 
 @pytest.mark.parametrize(
@@ -486,7 +516,7 @@ async def test_to_have_values_fails_when_multiple_not_specified(
     )
     locator = page.locator("select")
     await locator.select_option(["B"])
-    with pytest.raises(Error) as excinfo:
+    with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
     assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
 
@@ -500,7 +530,7 @@ async def test_to_have_values_fails_when_not_a_select_element(
     """
     )
     locator = page.locator("input")
-    with pytest.raises(Error) as excinfo:
+    with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
     assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
 
@@ -510,18 +540,47 @@ async def test_assertions_locator_to_be_checked(page: Page, server: Server) -> N
     await page.set_content("<input type=checkbox>")
     my_checkbox = page.locator("input")
     await expect(my_checkbox).not_to_be_checked()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be checked"):
         await expect(my_checkbox).to_be_checked(timeout=100)
     await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     with pytest.raises(AssertionError):
         await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
     await my_checkbox.check()
     await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be unchecked"):
         await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     await expect(my_checkbox).to_be_checked()
 
 
+async def test_assertions_boolean_checked_with_intermediate_true(page: Page) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    await page.locator("input").evaluate("e => e.indeterminate = true")
+    await expect(page.locator("input")).to_be_checked(indeterminate=True)
+
+
+async def test_assertions_boolean_checked_with_intermediate_true_and_checked(
+    page: Page,
+) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    await page.locator("input").evaluate("e => e.indeterminate = true")
+    with pytest.raises(
+        AssertionError, match="Can't assert indeterminate and checked at the same time"
+    ):
+        await expect(page.locator("input")).to_be_checked(
+            checked=False, indeterminate=True
+        )
+
+
+async def test_assertions_boolean_fail_with_indeterminate_true(page: Page) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 1000ms'
+    ):
+        await expect(page.locator("input")).to_be_checked(
+            indeterminate=True, timeout=1000
+        )
+
+
 async def test_assertions_locator_to_be_disabled_enabled(
     page: Page, server: Server
 ) -> None:
@@ -534,17 +593,98 @@ async def test_assertions_locator_to_be_disabled_enabled(
         await expect(my_checkbox).to_be_disabled(timeout=100)
     await my_checkbox.evaluate("e => e.disabled = true")
     await expect(my_checkbox).to_be_disabled()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be enabled"):
         await expect(my_checkbox).to_be_enabled(timeout=100)
 
 
+async def test_assertions_locator_to_be_enabled_with_true(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await expect(page.locator("button")).to_be_enabled(enabled=True)
+
+
+async def test_assertions_locator_to_be_enabled_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<button>Text</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be disabled"):
+        await expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_with_false(page: Page) -> None:
+    await page.set_content("<button disabled>Text</button>")
+    await expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_with_not_and_false(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await expect(page.locator("button")).not_to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_eventually(page: Page) -> None:
+    await page.set_content("<button disabled>Text</button>")
+    await page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.removeAttribute('disabled');
+        }, 700);
+    """,
+    )
+    await expect(page.locator("button")).to_be_enabled()
+
+
+async def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.setAttribute('disabled', '');
+        }, 700);
+    """,
+    )
+    await expect(page.locator("button")).not_to_be_enabled()
+
+
 async def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    await page.set_content("<input></input><button disabled>Text</button>")
-    await expect(page.locator("button")).not_to_be_editable()
+    await page.set_content("<input></input>")
     await expect(page.locator("input")).to_be_editable()
-    with pytest.raises(AssertionError):
-        await expect(page.locator("button")).to_be_editable(timeout=100)
+
+
+async def test_assertions_locator_to_be_editable_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        AssertionError,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        await expect(page.locator("button")).not_to_be_editable()
+
+
+async def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
+    await page.set_content("<input></input>")
+    await expect(page.locator("input")).to_be_editable(editable=True)
+
+
+async def test_assertions_locator_to_be_editable_with_false(page: Page) -> None:
+    await page.set_content("<input readonly></input>")
+    await expect(page.locator("input")).to_be_editable(editable=False)
+
+
+async def test_assertions_locator_to_be_editable_with_false_and_throw_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<input></input>")
+    with pytest.raises(AssertionError, match="Locator expected to be readonly"):
+        await expect(page.locator("input")).to_be_editable(editable=False)
+
+
+async def test_assertions_locator_to_be_editable_with_not_and_false(page: Page) -> None:
+    await page.set_content("<input></input>")
+    await expect(page.locator("input")).not_to_be_editable(editable=False)
 
 
 async def test_assertions_locator_to_be_empty(page: Page, server: Server) -> None:
@@ -579,10 +719,59 @@ async def test_assertions_locator_to_be_hidden_visible(
         await expect(my_checkbox).to_be_hidden(timeout=100)
     await my_checkbox.evaluate("e => e.style.display = 'none'")
     await expect(my_checkbox).to_be_hidden()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be visible"):
         await expect(my_checkbox).to_be_visible(timeout=100)
 
 
+async def test_assertions_locator_to_be_visible_with_true(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    await expect(page.locator("button")).to_be_visible(visible=True)
+
+
+async def test_assertions_locator_to_be_visible_with_false(page: Page) -> None:
+    await page.set_content("<button hidden>hello</button>")
+    await expect(page.locator("button")).to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<button>hello</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be hidden"):
+        await expect(page.locator("button")).to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_with_not_and_false(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    await expect(page.locator("button")).not_to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_eventually(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector(
+        "div",
+        """
+        div => setTimeout(() => {
+            div.innerHTML = '<span>Hello</span>';
+        }, 700);
+    """,
+    )
+    await expect(page.locator("span")).to_be_visible()
+
+
+async def test_assertions_locator_to_be_visible_eventually_with_not(page: Page) -> None:
+    await page.set_content("<div><span>Hello</span></div>")
+    await page.eval_on_selector(
+        "span",
+        """
+        span => setTimeout(() => {
+            span.textContent = '';
+        }, 700);
+    """,
+    )
+    await expect(page.locator("span")).not_to_be_visible()
+
+
 async def test_assertions_should_serialize_regexp_correctly(
     page: Page, server: Server
 ) -> None:
@@ -746,6 +935,15 @@ async def test_should_be_attached_with_attached_false(page: Page) -> None:
     await expect(locator).to_be_attached(attached=False)
 
 
+async def test_should_be_attached_with_attached_false_and_throw_good_error(
+    page: Page,
+) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    with pytest.raises(AssertionError, match="Locator expected to be detached"):
+        await expect(locator).to_be_attached(attached=False, timeout=1)
+
+
 async def test_should_be_attached_with_not_and_attached_false(page: Page) -> None:
     await page.set_content("<button>hello</button>")
     locator = page.locator("button")
@@ -773,7 +971,9 @@ async def test_should_be_attached_eventually_with_not(page: Page) -> None:
 async def test_should_be_attached_fail(page: Page) -> None:
     await page.set_content("<button>Hello</button>")
     locator = page.locator("input")
-    with pytest.raises(AssertionError) as exc_info:
+    with pytest.raises(
+        AssertionError, match="Locator expected to be attached"
+    ) as exc_info:
         await expect(locator).to_be_attached(timeout=1000)
     assert "locator resolved to" not in exc_info.value.args[0]
 
@@ -820,7 +1020,7 @@ async def test_should_be_attached_over_navigation(page: Page, server: Server) ->
 async def test_should_be_able_to_set_custom_timeout(page: Page) -> None:
     with pytest.raises(AssertionError) as exc_info:
         await expect(page.locator("#a1")).to_be_visible(timeout=111)
-    assert "LocatorAssertions.to_be_visible with timeout 111ms" in str(exc_info.value)
+    assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
 
 
 async def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
@@ -828,9 +1028,7 @@ async def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
         expect.set_options(timeout=111)
         with pytest.raises(AssertionError) as exc_info:
             await expect(page.locator("#a1")).to_be_visible()
-        assert "LocatorAssertions.to_be_visible with timeout 111ms" in str(
-            exc_info.value
-        )
+        assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
     finally:
         expect.set_options(timeout=None)
 
@@ -847,6 +1045,64 @@ async def test_to_have_accessible_name(page: Page) -> None:
         re.compile(r"hello"), ignore_case=True
     )
 
+    await page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    await expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+async def test_to_have_accessible_error_message(page: Page) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    await expect(locator).to_have_accessible_error_message("Hello")
+    await expect(locator).not_to_have_accessible_error_message("hello")
+    await expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+async def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    await expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
 
 async def test_to_have_accessible_description(page: Page) -> None:
     await page.set_content('<div role="button" aria-description="Hello"></div>')
@@ -860,6 +1116,14 @@ async def test_to_have_accessible_description(page: Page) -> None:
         re.compile(r"hello"), ignore_case=True
     )
 
+    await page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    await expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
 
 async def test_to_have_role(page: Page) -> None:
     await page.set_content('<div role="button">Button!</div>')
diff --git a/tests/async/test_asyncio.py b/tests/async/test_asyncio.py
index 1d4423afb..971c65473 100644
--- a/tests/async/test_asyncio.py
+++ b/tests/async/test_asyncio.py
@@ -13,11 +13,12 @@
 # limitations under the License.
 import asyncio
 import gc
+import sys
 from typing import Dict
 
 import pytest
 
-from playwright.async_api import async_playwright
+from playwright.async_api import Page, async_playwright
 from tests.server import Server
 from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
@@ -67,3 +68,34 @@ async def test_cancel_pending_protocol_call_on_playwright_stop(server: Server) -
     with pytest.raises(Exception) as exc_info:
         await pending_task
     assert TARGET_CLOSED_ERROR_MESSAGE in str(exc_info.value)
+
+
+async def test_should_not_throw_with_taskgroup(page: Page) -> None:
+    if sys.version_info < (3, 11):
+        pytest.skip("TaskGroup is only available in Python 3.11+")
+
+    from builtins import ExceptionGroup  # type: ignore
+
+    async def raise_exception() -> None:
+        raise ValueError("Something went wrong")
+
+    with pytest.raises(ExceptionGroup) as exc_info:
+        async with asyncio.TaskGroup() as group:  # type: ignore
+            group.create_task(page.locator(".this-element-does-not-exist").inner_text())
+            group.create_task(raise_exception())
+    assert len(exc_info.value.exceptions) == 1
+    assert "Something went wrong" in str(exc_info.value.exceptions[0])
+    assert isinstance(exc_info.value.exceptions[0], ValueError)
+    assert await page.evaluate("() => 11 * 11") == 121
+
+
+async def test_should_return_proper_api_name_on_error(page: Page) -> None:
+    try:
+        await page.evaluate("does_not_exist")
+
+        assert (
+            False
+        ), "Accessing undefined JavaScript variable should have thrown exception"
+    except Exception as error:
+        # Each browser returns slightly different error messages, but they should all start with "Page.evaluate:", because that was the Playwright method where the error originated
+        assert str(error).startswith("Page.evaluate:")
diff --git a/tests/async/test_browsercontext.py b/tests/async/test_browsercontext.py
index af4516f87..ba53b6f95 100644
--- a/tests/async/test_browsercontext.py
+++ b/tests/async/test_browsercontext.py
@@ -32,6 +32,11 @@
 from .utils import Utils
 
 
+@pytest.fixture(scope="session")
+def fails_on_401(browser_name: str, is_headless_shell: bool) -> bool:
+    return browser_name == "chromium" and not is_headless_shell
+
+
 async def test_page_event_should_create_new_context(browser: Browser) -> None:
     assert len(browser.contexts) == 0
     context = await browser.new_context()
@@ -113,9 +118,9 @@ async def test_page_event_should_propagate_default_viewport_to_the_page(
 
 
 async def test_page_event_should_respect_device_scale_factor(browser: Browser) -> None:
-    context = await browser.new_context(device_scale_factor=3)
+    context = await browser.new_context(device_scale_factor=3.5)
     page = await context.new_page()
-    assert await page.evaluate("window.devicePixelRatio") == 3
+    assert await page.evaluate("window.devicePixelRatio") == 3.5
     await context.close()
 
 
@@ -472,13 +477,17 @@ def logme(t: JSHandle) -> int:
 
 
 async def test_auth_should_fail_without_credentials(
-    context: BrowserContext, server: Server
+    context: BrowserContext, server: Server, fails_on_401: bool
 ) -> None:
     server.set_auth("/empty.html", "user", "pass")
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response
-    assert response.status == 401
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
 
 
 async def test_auth_should_work_with_correct_credentials(
@@ -562,7 +571,7 @@ async def test_should_work_with_correct_credentials_and_matching_origin_case_ins
 
 
 async def test_should_fail_with_correct_credentials_and_mismatching_scheme(
-    browser: Browser, server: Server
+    browser: Browser, server: Server, fails_on_401: bool
 ) -> None:
     server.set_auth("/empty.html", "user", "pass")
     context = await browser.new_context(
@@ -573,14 +582,18 @@ async def test_should_fail_with_correct_credentials_and_mismatching_scheme(
         }
     )
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response
-    assert response.status == 401
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
 async def test_should_fail_with_correct_credentials_and_mismatching_hostname(
-    browser: Browser, server: Server
+    browser: Browser, server: Server, fails_on_401: bool
 ) -> None:
     server.set_auth("/empty.html", "user", "pass")
     hostname = urlparse(server.PREFIX).hostname
@@ -590,14 +603,18 @@ async def test_should_fail_with_correct_credentials_and_mismatching_hostname(
         http_credentials={"username": "user", "password": "pass", "origin": origin}
     )
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response
-    assert response.status == 401
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
 async def test_should_fail_with_correct_credentials_and_mismatching_port(
-    browser: Browser, server: Server
+    browser: Browser, server: Server, fails_on_401: bool
 ) -> None:
     server.set_auth("/empty.html", "user", "pass")
     origin = server.PREFIX.replace(str(server.PORT), str(server.PORT + 1))
@@ -605,9 +622,13 @@ async def test_should_fail_with_correct_credentials_and_mismatching_port(
         http_credentials={"username": "user", "password": "pass", "origin": origin}
     )
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response
-    assert response.status == 401
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
@@ -804,7 +825,6 @@ async def test_strict_selectors_on_context(browser: Browser, server: Server) ->
     await context.close()
 
 
-@pytest.mark.skip_browser("webkit")  # https://bugs.webkit.org/show_bug.cgi?id=225281
 async def test_should_support_forced_colors(browser: Browser) -> None:
     context = await browser.new_context(forced_colors="active")
     page = await context.new_page()
diff --git a/tests/async/test_browsercontext_events.py b/tests/async/test_browsercontext_events.py
index a0a3b90eb..8ae14def6 100644
--- a/tests/async/test_browsercontext_events.py
+++ b/tests/async/test_browsercontext_events.py
@@ -17,7 +17,7 @@
 
 import pytest
 
-from playwright.async_api import Page
+from playwright.async_api import BrowserContext, Page
 from tests.utils import must
 
 from ..server import Server, TestServerRequest
@@ -198,3 +198,11 @@ async def test_page_error_event_should_work(page: Page) -> None:
     page_error = await page_error_info.value
     assert page_error.page == page
     assert "boom" in page_error.error.stack
+
+
+async def test_weberror_event_should_work(context: BrowserContext, page: Page) -> None:
+    async with context.expect_event("weberror") as error_info:
+        await page.goto('data:text/html,<script>throw new Error("Test")</script>')
+    error = await error_info.value
+    assert error.page == page
+    assert error.error.message == "Test"
diff --git a/tests/async/test_browsercontext_proxy.py b/tests/async/test_browsercontext_proxy.py
index b5fbdbcb4..f511a0bee 100644
--- a/tests/async/test_browsercontext_proxy.py
+++ b/tests/async/test_browsercontext_proxy.py
@@ -17,7 +17,6 @@
 from typing import AsyncGenerator, Awaitable, Callable
 
 import pytest
-from flaky import flaky
 
 from playwright.async_api import Browser, BrowserContext
 from tests.server import Server, TestServerRequest
@@ -108,7 +107,6 @@ async def test_should_work_with_ip_port_notion(
     assert await page.title() == "Served by the proxy"
 
 
-@flaky  # Upstream flaky
 async def test_should_authenticate(
     context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
 ) -> None:
@@ -139,7 +137,6 @@ def handler(req: TestServerRequest) -> None:
     )
 
 
-@flaky  # Upstream flaky
 async def test_should_authenticate_with_empty_password(
     context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
 ) -> None:
diff --git a/tests/async/test_browsercontext_storage_state.py b/tests/async/test_browsercontext_storage_state.py
index f11aa8281..5004844ff 100644
--- a/tests/async/test_browsercontext_storage_state.py
+++ b/tests/async/test_browsercontext_storage_state.py
@@ -16,7 +16,7 @@
 import json
 from pathlib import Path
 
-from playwright.async_api import Browser, BrowserContext, Page
+from playwright.async_api import Browser, BrowserContext, Page, StorageState
 from tests.server import Server
 
 
@@ -44,16 +44,30 @@ async def test_should_capture_local_storage(context: BrowserContext) -> None:
 
 
 async def test_should_set_local_storage(browser: Browser) -> None:
-    context = await browser.new_context(
-        storage_state={
-            "origins": [
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = await browser.new_context(storage_state=storage_state)
 
     page = await context.new_page()
     await page.route(
@@ -62,11 +76,28 @@ async def test_should_set_local_storage(browser: Browser) -> None:
     await page.goto("https://www.example.com")
     local_storage = await page.evaluate("window.localStorage")
     assert local_storage == {"name1": "value1"}
+
+    indexed_db = await page.evaluate(
+        """async () => {
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open('db', 42);
+            openRequest.addEventListener('success', () => {
+                const db = openRequest.result;
+                const transaction = db.transaction('store', 'readonly');
+                const getRequest = transaction.objectStore('store').get('bar');
+                getRequest.addEventListener('success', () => resolve(getRequest.result));
+                getRequest.addEventListener('error', () => reject(getRequest.error));
+            });
+            openRequest.addEventListener('error', () => reject(openRequest.error));
+        });
+    }"""
+    )
+    assert indexed_db == "foo"
     await context.close()
 
 
 async def test_should_round_trip_through_the_file(
-    browser: Browser, context: BrowserContext, tmpdir: Path
+    browser: Browser, context: BrowserContext, tmp_path: Path
 ) -> None:
     page1 = await context.new_page()
     await page1.route(
@@ -82,7 +113,7 @@ async def test_should_round_trip_through_the_file(
         }"""
     )
 
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     state = await context.storage_state(path=path)
     with open(path, "r") as f:
         written = json.load(f)
@@ -112,3 +143,48 @@ async def test_should_serialiser_storage_state_with_lone_surrogates(
     storage_state = await context.storage_state()
     # 65533 is the Unicode replacement character
     assert storage_state["origins"][0]["localStorage"][0]["value"] == chr(65533)
+
+
+async def test_should_serialise_indexed_db(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """async () => {
+            await new Promise((resolve, reject) => {
+                const openRequest = indexedDB.open('db', 42);
+                openRequest.onupgradeneeded = () => {
+                openRequest.result.createObjectStore('store');
+                };
+                openRequest.onsuccess = () => {
+                const request = openRequest.result.transaction('store', 'readwrite')
+                    .objectStore('store')
+                    .put('foo', 'bar');
+                request.addEventListener('success', resolve);
+                request.addEventListener('error', reject);
+                };
+            });
+        }"""
+    )
+    assert await page.context.storage_state() == {"cookies": [], "origins": []}
+    assert await page.context.storage_state(indexed_db=True) == {
+        "cookies": [],
+        "origins": [
+            {
+                "origin": f"http://localhost:{server.PORT}",
+                "localStorage": [],
+                "indexedDB": [
+                    {
+                        "name": "db",
+                        "version": 42,
+                        "stores": [
+                            {
+                                "name": "store",
+                                "autoIncrement": False,
+                                "records": [{"key": "bar", "value": "foo"}],
+                                "indexes": [],
+                            }
+                        ],
+                    }
+                ],
+            }
+        ],
+    }
diff --git a/tests/async/test_browsertype_connect.py b/tests/async/test_browsertype_connect.py
index f58fd2981..ccb112ab9 100644
--- a/tests/async/test_browsertype_connect.py
+++ b/tests/async/test_browsertype_connect.py
@@ -16,15 +16,16 @@
 import os
 import re
 from pathlib import Path
-from typing import Callable
+from typing import AsyncContextManager, Callable
 
 import pytest
-from flaky import flaky
 
-from playwright.async_api import BrowserType, Error, Playwright, Route
+from playwright.async_api import BrowserType, Error, Playwright, Route, expect
 from tests.conftest import RemoteServer
 from tests.server import Server, TestServerRequest, WebSocketProtocol
-from tests.utils import chromium_version_less_than, parse_trace
+from tests.utils import chromium_version_less_than
+
+from .conftest import TraceViewerPage
 
 
 async def test_should_print_custom_ws_close_error(
@@ -209,12 +210,12 @@ def handle_download(request: TestServerRequest) -> None:
 async def test_prevent_getting_video_path(
     browser_type: BrowserType,
     launch_server: Callable[[], RemoteServer],
-    tmpdir: Path,
+    tmp_path: Path,
     server: Server,
 ) -> None:
     remote_server = launch_server()
     browser = await browser_type.connect(remote_server.ws_endpoint)
-    page = await browser.new_page(record_video_dir=tmpdir)
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
     await browser.close()
     assert page.video
@@ -266,7 +267,6 @@ async def handle_request(route: Route) -> None:
     remote.kill()
 
 
-@flaky
 async def test_should_upload_large_file(
     browser_type: BrowserType,
     launch_server: Callable[[], RemoteServer],
@@ -327,6 +327,7 @@ async def test_should_record_trace_with_source(
     server: Server,
     tmp_path: Path,
     browser_type: BrowserType,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     remote = launch_server()
     browser = await browser_type.connect(remote.ws_endpoint)
@@ -343,14 +344,28 @@ async def test_should_record_trace_with_source(
     await context.close()
     await browser.close()
 
-    (resources, events) = parse_trace(path)
-    current_file_content = Path(__file__).read_bytes()
-    found_current_file = False
-    for name, resource in resources.items():
-        if resource == current_file_content:
-            found_current_file = True
-            break
-    assert found_current_file
+    async with show_trace_viewer(path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        await trace_viewer.show_source_tab()
+        await expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"test_should_record_trace_with_source"),
+            ]
+        )
+        await trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        await expect(
+            trace_viewer.page.locator(".source-tab-file-name")
+        ).to_have_attribute("title", re.compile(r".*test_browsertype_connect\.py"))
+        await expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
 
 
 async def test_should_record_trace_with_relative_trace_path(
diff --git a/tests/async/test_chromium_tracing.py b/tests/async/test_chromium_tracing.py
index 4cbd77a21..4cd796e0d 100644
--- a/tests/async/test_chromium_tracing.py
+++ b/tests/async/test_chromium_tracing.py
@@ -24,9 +24,9 @@
 
 @pytest.mark.only_browser("chromium")
 async def test_should_output_a_trace(
-    browser: Browser, page: Page, server: Server, tmpdir: Path
+    browser: Browser, page: Page, server: Server, tmp_path: Path
 ) -> None:
-    output_file = tmpdir / "trace.json"
+    output_file = tmp_path / "trace.json"
     await browser.start_tracing(page=page, screenshots=True, path=output_file)
     await page.goto(server.PREFIX + "/grid.html")
     await browser.stop_tracing()
@@ -35,42 +35,52 @@ async def test_should_output_a_trace(
 
 @pytest.mark.only_browser("chromium")
 async def test_should_create_directories_as_needed(
-    browser: Browser, page: Page, server: Server, tmpdir: Path
+    browser: Browser, page: Page, server: Server, tmp_path: Path
 ) -> None:
-    output_file = tmpdir / "these" / "are" / "directories" / "trace.json"
+    output_file = tmp_path / "these" / "are" / "directories" / "trace.json"
     await browser.start_tracing(page=page, screenshots=True, path=output_file)
     await page.goto(server.PREFIX + "/grid.html")
     await browser.stop_tracing()
     assert os.path.getsize(output_file) > 0
 
 
+async def rafraf(target: Page, count: int = 1) -> None:
+    for _ in range(count):
+        await target.evaluate(
+            "async () => await new Promise(f => window.requestAnimationFrame(() => window.requestAnimationFrame(f)));"
+        )
+
+
 @pytest.mark.only_browser("chromium")
 async def test_should_run_with_custom_categories_if_provided(
-    browser: Browser, page: Page, tmpdir: Path
+    browser: Browser, page: Page, tmp_path: Path
 ) -> None:
-    output_file = tmpdir / "trace.json"
+    output_file = tmp_path / "trace.json"
     await browser.start_tracing(
         page=page,
-        screenshots=True,
         path=output_file,
-        categories=["disabled-by-default-v8.cpu_profiler.hires"],
+        categories=["disabled-by-default-cc.debug"],
     )
+    await rafraf(page)
     await browser.stop_tracing()
     with open(output_file, mode="r") as of:
         trace_json = json.load(of)
+        trace_config = trace_json["metadata"].get("trace-config")
+        trace_events = trace_json["traceEvents"]
         assert (
-            "disabled-by-default-v8.cpu_profiler.hires"
-            in trace_json["metadata"]["trace-config"]
+            trace_config is not None and "disabled-by-default-cc.debug" in trace_config
+        ) or any(
+            event.get("cat") == "disabled-by-default-cc.debug" for event in trace_events
         )
 
 
 @pytest.mark.only_browser("chromium")
 async def test_should_throw_if_tracing_on_two_pages(
-    browser: Browser, page: Page, tmpdir: Path
+    browser: Browser, page: Page, tmp_path: Path
 ) -> None:
-    output_file_1 = tmpdir / "trace1.json"
+    output_file_1 = tmp_path / "trace1.json"
     await browser.start_tracing(page=page, screenshots=True, path=output_file_1)
-    output_file_2 = tmpdir / "trace2.json"
+    output_file_2 = tmp_path / "trace2.json"
     with pytest.raises(Exception):
         await browser.start_tracing(page=page, screenshots=True, path=output_file_2)
     await browser.stop_tracing()
@@ -78,9 +88,9 @@ async def test_should_throw_if_tracing_on_two_pages(
 
 @pytest.mark.only_browser("chromium")
 async def test_should_return_a_buffer(
-    browser: Browser, page: Page, server: Server, tmpdir: Path
+    browser: Browser, page: Page, server: Server, tmp_path: Path
 ) -> None:
-    output_file = tmpdir / "trace.json"
+    output_file = tmp_path / "trace.json"
     await browser.start_tracing(page=page, path=output_file, screenshots=True)
     await page.goto(server.PREFIX + "/grid.html")
     value = await browser.stop_tracing()
@@ -104,5 +114,6 @@ async def test_should_support_a_buffer_without_a_path(
 ) -> None:
     await browser.start_tracing(page=page, screenshots=True)
     await page.goto(server.PREFIX + "/grid.html")
+    await rafraf(page)
     trace = await browser.stop_tracing()
     assert "screenshot" in trace.decode()
diff --git a/tests/async/test_click.py b/tests/async/test_click.py
index fd783546d..8fb06ec38 100644
--- a/tests/async/test_click.py
+++ b/tests/async/test_click.py
@@ -1111,3 +1111,35 @@ async def test_check_the_box_by_aria_role(page: Page) -> None:
     )
     await page.check("div")
     assert await page.evaluate("checkbox.getAttribute ('aria-checked')")
+
+
+async def test_click_with_tweened_mouse_movement(page: Page, browser_name: str) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0; height: 500px; width: 500px;">
+          <div style="position: relative; top: 280px; left: 150px; width: 100px; height: 40px">Click me</div>
+        </body>
+        """
+    )
+
+    # The test becomes flaky on WebKit without next line.
+    if browser_name == "webkit":
+        await page.evaluate("() => new Promise(requestAnimationFrame)")
+    await page.mouse.move(100, 100)
+    await page.evaluate(
+        """() => {
+        window.result = [];
+        document.addEventListener('mousemove', event => {
+          window.result.push([event.clientX, event.clientY]);
+        });
+      }"""
+    )
+    # Centerpoint at 150 + 100/2, 280 + 40/2 = 200, 300
+    await page.locator("div").click(steps=5)
+    assert await page.evaluate("result") == [
+        [120, 140],
+        [140, 180],
+        [160, 220],
+        [180, 260],
+        [200, 300],
+    ]
diff --git a/tests/async/test_console.py b/tests/async/test_console.py
index b9a4102a8..5952d1caa 100644
--- a/tests/async/test_console.py
+++ b/tests/async/test_console.py
@@ -107,7 +107,7 @@ async def test_console_should_trigger_correct_log(page: Page, server: Server) ->
     async with page.expect_console_message() as message_info:
         await page.evaluate("async url => fetch(url).catch(e => {})", server.EMPTY_PAGE)
     message = await message_info.value
-    assert "Access-Control-Allow-Origin" in message.text
+    assert "Access-Control-Allow-Origin" in message.text or "CORS" in message.text
     assert message.type == "error"
 
 
diff --git a/tests/async/test_defaultbrowsercontext.py b/tests/async/test_defaultbrowsercontext.py
index ff3b32489..f5d2a606d 100644
--- a/tests/async/test_defaultbrowsercontext.py
+++ b/tests/async/test_defaultbrowsercontext.py
@@ -21,14 +21,23 @@
     Awaitable,
     Callable,
     Dict,
+    List,
     Literal,
     Optional,
+    Sequence,
     Tuple,
 )
 
 import pytest
 
-from playwright.async_api import BrowserContext, BrowserType, Error, Page, expect
+from playwright.async_api import (
+    BrowserContext,
+    BrowserType,
+    Cookie,
+    Error,
+    Page,
+    expect,
+)
 from tests.server import Server
 from tests.utils import must
 
@@ -37,7 +46,7 @@
 
 @pytest.fixture()
 async def launch_persistent(
-    tmpdir: Path, launch_arguments: Dict, browser_type: BrowserType
+    tmp_path: Path, launch_arguments: Dict, browser_type: BrowserType
 ) -> AsyncGenerator[Callable[..., Awaitable[Tuple[Page, BrowserContext]]], None]:
     context: Optional[BrowserContext] = None
 
@@ -46,7 +55,7 @@ async def _launch(**options: Any) -> Tuple[Page, BrowserContext]:
         if context:
             raise ValueError("can only launch one persistent context")
         context = await browser_type.launch_persistent_context(
-            str(tmpdir), **{**launch_arguments, **options}
+            str(tmp_path), **{**launch_arguments, **options}
         )
         assert context
         return (context.pages[0], context)
@@ -70,7 +79,7 @@ async def test_context_cookies_should_work(
     )
 
     assert document_cookie == "username=John Doe"
-    assert await page.context.cookies() == [
+    assert _filter_cookies(await page.context.cookies()) == [
         {
             "name": "username",
             "value": "John Doe",
@@ -102,7 +111,7 @@ async def test_context_add_cookies_should_work(
         ]
     )
     assert await page.evaluate("() => document.cookie") == "username=John Doe"
-    assert await page.context.cookies() == [
+    assert _filter_cookies(await page.context.cookies()) == [
         {
             "name": "username",
             "value": "John Doe",
@@ -116,6 +125,12 @@ async def test_context_add_cookies_should_work(
     ]
 
 
+def _filter_cookies(cookies: Sequence[Cookie]) -> List[Cookie]:
+    return list(
+        filter(lambda cookie: not cookie["domain"].endswith("microsoft.com"), cookies)
+    )
+
+
 async def test_context_clear_cookies_should_work(
     server: Server,
     launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
@@ -131,7 +146,7 @@ async def test_context_clear_cookies_should_work(
     assert await page.evaluate("document.cookie") == "cookie1=1; cookie2=2"
     await page.context.clear_cookies()
     await page.reload()
-    assert await page.context.cookies([]) == []
+    assert _filter_cookies(await page.context.cookies([])) == []
     assert await page.evaluate("document.cookie") == ""
 
 
@@ -303,6 +318,16 @@ async def test_should_support_timezone_id_option(
     )
 
 
+async def test_should_support_contrast_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
+    (page, _) = await launch_persistent(contrast="more")
+    assert await page.evaluate('() => matchMedia("(prefers-contrast: more)").matches')
+    assert not await page.evaluate(
+        '() => matchMedia("(prefers-contrast: no-preference)").matches'
+    )
+
+
 async def test_should_support_locale_option(
     launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
 ) -> None:
@@ -349,14 +374,14 @@ async def test_should_support_extra_http_headers_option(
 
 
 async def test_should_accept_user_data_dir(
-    tmpdir: Path,
+    tmp_path: Path,
     launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
 ) -> None:
     (page, context) = await launch_persistent()
     # Note: we need an open page to make sure its functional.
-    assert len(os.listdir(tmpdir)) > 0
+    assert len(os.listdir(tmp_path)) > 0
     await context.close()
-    assert len(os.listdir(tmpdir)) > 0
+    assert len(os.listdir(tmp_path)) > 0
 
 
 async def test_should_restore_state_from_userDataDir(
@@ -402,11 +427,11 @@ async def test_should_have_default_url_when_launching_browser(
 
 @pytest.mark.skip_browser("firefox")
 async def test_should_throw_if_page_argument_is_passed(
-    browser_type: BrowserType, server: Server, tmpdir: Path, launch_arguments: Dict
+    browser_type: BrowserType, server: Server, tmp_path: Path, launch_arguments: Dict
 ) -> None:
     options = {**launch_arguments, "args": [server.EMPTY_PAGE]}
     with pytest.raises(Error) as exc:
-        await browser_type.launch_persistent_context(tmpdir, **options)
+        await browser_type.launch_persistent_context(tmp_path, **options)
     assert "can not specify page" in exc.value.message
 
 
diff --git a/tests/async/test_download.py b/tests/async/test_download.py
index 082fcac26..6b0d6be1a 100644
--- a/tests/async/test_download.py
+++ b/tests/async/test_download.py
@@ -83,14 +83,14 @@ async def test_should_report_downloads_with_accept_downloads_true(
 
 
 async def test_should_save_to_user_specified_path(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
@@ -98,14 +98,14 @@ async def test_should_save_to_user_specified_path(
 
 
 async def test_should_save_to_user_specified_path_without_updating_original_path(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
@@ -117,19 +117,19 @@ async def test_should_save_to_user_specified_path_without_updating_original_path
 
 
 async def test_should_save_to_two_different_paths_with_multiple_save_as_calls(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
 
-    anotheruser_path = tmpdir / "download (2).txt"
+    anotheruser_path = tmp_path / "download (2).txt"
     await download.save_as(anotheruser_path)
     assert anotheruser_path.exists()
     assert anotheruser_path.read_text("utf-8") == "Hello world"
@@ -137,32 +137,32 @@ async def test_should_save_to_two_different_paths_with_multiple_save_as_calls(
 
 
 async def test_should_save_to_overwritten_filepath(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
-    assert len(list(Path(tmpdir).glob("*.*"))) == 1
+    assert len(list(tmp_path.glob("*.*"))) == 1
     await download.save_as(user_path)
-    assert len(list(Path(tmpdir).glob("*.*"))) == 1
+    assert len(list(tmp_path.glob("*.*"))) == 1
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
     await page.close()
 
 
 async def test_should_create_subdirectories_when_saving_to_non_existent_user_specified_path(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    nested_path = tmpdir / "these" / "are" / "directories" / "download.txt"
+    nested_path = tmp_path / "these" / "are" / "directories" / "download.txt"
     await download.save_as(nested_path)
     assert nested_path.exists()
     assert nested_path.read_text("utf-8") == "Hello world"
@@ -170,14 +170,14 @@ async def test_should_create_subdirectories_when_saving_to_non_existent_user_spe
 
 
 async def test_should_error_when_saving_with_downloads_disabled(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=False)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     with pytest.raises(Error) as exc:
         await download.save_as(user_path)
     assert (
@@ -192,14 +192,14 @@ async def test_should_error_when_saving_with_downloads_disabled(
 
 
 async def test_should_error_when_saving_after_deletion(
-    tmpdir: Path, browser: Browser, server: Server
+    tmp_path: Path, browser: Browser, server: Server
 ) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
     async with page.expect_download() as download_info:
         await page.click("a")
     download = await download_info.value
-    user_path = tmpdir / "download.txt"
+    user_path = tmp_path / "download.txt"
     await download.delete()
     with pytest.raises(Error) as exc:
         await download.save_as(user_path)
diff --git a/tests/async/test_emulation_focus.py b/tests/async/test_emulation_focus.py
index a59d549f4..8f298f9ca 100644
--- a/tests/async/test_emulation_focus.py
+++ b/tests/async/test_emulation_focus.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import asyncio
-from typing import Callable
 
 from playwright.async_api import Page
 from tests.server import Server
@@ -106,29 +105,6 @@ async def test_should_change_document_activeElement(page: Page, server: Server)
     assert active == ["INPUT", "TEXTAREA"]
 
 
-async def test_should_not_affect_screenshots(
-    page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
-) -> None:
-    # Firefox headed produces a different image.
-    page2 = await page.context.new_page()
-    await asyncio.gather(
-        page.set_viewport_size({"width": 500, "height": 500}),
-        page.goto(server.PREFIX + "/grid.html"),
-        page2.set_viewport_size({"width": 50, "height": 50}),
-        page2.goto(server.PREFIX + "/grid.html"),
-    )
-    await asyncio.gather(
-        page.focus("body"),
-        page2.focus("body"),
-    )
-    screenshots = await asyncio.gather(
-        page.screenshot(),
-        page2.screenshot(),
-    )
-    assert_to_be_golden(screenshots[0], "screenshot-sanity.png")
-    assert_to_be_golden(screenshots[1], "grid-cell-0.png")
-
-
 async def test_should_change_focused_iframe(
     page: Page, server: Server, utils: Utils
 ) -> None:
diff --git a/tests/async/test_expect_misc.py b/tests/async/test_expect_misc.py
index 9c6a8aa01..2148b0d9e 100644
--- a/tests/async/test_expect_misc.py
+++ b/tests/async/test_expect_misc.py
@@ -58,7 +58,7 @@ async def test_to_be_in_viewport_should_have_good_stack(
     page: Page, server: Server
 ) -> None:
     with pytest.raises(AssertionError) as exc_info:
-        await expect(page.locator("body")).not_to_be_in_viewport(timeout=100)
+        await expect(page.locator("body")).not_to_be_in_viewport(timeout=1000)
     assert 'unexpected value "viewport ratio' in str(exc_info.value)
 
 
diff --git a/tests/async/test_extension.py b/tests/async/test_extension.py
new file mode 100644
index 000000000..853afd8a5
--- /dev/null
+++ b/tests/async/test_extension.py
@@ -0,0 +1,125 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+from pathlib import Path
+from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, List, Optional
+
+import pytest
+
+from playwright.async_api import BrowserContext, BrowserType
+
+from ..server import Server
+
+
+@pytest.fixture()
+async def launch_persistent_context(
+    browser_type: BrowserType,
+    browser_channel: Optional[str],
+    tmp_path: Path,
+    launch_arguments: Dict[str, Any],
+    is_headless_shell: bool,
+) -> AsyncGenerator[Callable[..., Awaitable[BrowserContext]], None]:
+    if browser_channel and browser_channel.startswith("chrome"):
+        pytest.skip(
+            "--load-extension is not supported in Chrome anymore. https://groups.google.com/a/chromium.org/g/chromium-extensions/c/1-g8EFx2BBY/m/S0ET5wPjCAAJ"
+        )
+    if is_headless_shell:
+        pytest.skip("Headless Shell has no support for extensions")
+
+    contexts: List[BrowserContext] = []
+
+    async def launch(extension_path: str, **kwargs: Any) -> BrowserContext:
+        context = await browser_type.launch_persistent_context(
+            str(tmp_path),
+            **launch_arguments,
+            **kwargs,
+            args=[
+                f"--disable-extensions-except={extension_path}",
+                f"--load-extension={extension_path}",
+            ],
+        )
+        contexts.append(context)
+        return context
+
+    yield launch
+
+    for context in contexts:
+        await context.close()
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_give_access_to_the_service_worker(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = await launch_persistent_context(extension_path)
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else await context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not await service_worker.evaluate("globalThis.MAGIC") == 42:
+        await context.pages[0].wait_for_timeout(100)
+    await context.close()
+    assert len(context.background_pages) == 0
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_give_access_to_the_service_worker_when_recording_video(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    tmp_path: Path,
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = await launch_persistent_context(
+        extension_path, record_video_dir=(tmp_path / "videos")
+    )
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else await context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not await service_worker.evaluate("globalThis.MAGIC") == 42:
+        await context.pages[0].wait_for_timeout(100)
+    await context.close()
+    assert len(context.background_pages) == 0
+
+
+# https://github.com/microsoft/playwright/issues/32762
+@pytest.mark.only_browser("chromium")
+async def test_should_report_console_messages_from_content_script(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    assetdir: Path,
+    server: Server,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-with-logging")
+    context = await launch_persistent_context(extension_path)
+    page = await context.new_page()
+    [message, _] = await asyncio.gather(
+        page.context.wait_for_event(
+            "console",
+            lambda e: "Test console log from a third-party execution context" in e.text,
+        ),
+        page.goto(server.EMPTY_PAGE),
+    )
+    assert "Test console log from a third-party execution context" in message.text
+    await context.close()
diff --git a/tests/async/test_fetch_global.py b/tests/async/test_fetch_global.py
index 838e56c7d..1f7593194 100644
--- a/tests/async/test_fetch_global.py
+++ b/tests/async/test_fetch_global.py
@@ -85,10 +85,19 @@ async def test_should_support_global_timeout_option(
 ) -> None:
     request = await playwright.request.new_context(timeout=100)
     server.set_route("/empty.html", lambda req: None)
-    with pytest.raises(Error, match="Request timed out after 100ms"):
+    with pytest.raises(Error, match="Timeout 100ms exceeded"):
         await request.get(server.EMPTY_PAGE)
 
 
+async def test_should_support_timeout_option_in_get_method(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="APIRequestContext.get: Timeout 123ms exceeded."):
+        await request.get(server.EMPTY_PAGE, timeout=123)
+
+
 async def test_should_propagate_extra_http_headers_with_redirects(
     playwright: Playwright, server: Server
 ) -> None:
@@ -289,7 +298,7 @@ async def test_should_return_empty_body(playwright: Playwright, server: Server)
 
 
 async def test_storage_state_should_round_trip_through_file(
-    playwright: Playwright, tmpdir: Path
+    playwright: Playwright, tmp_path: Path
 ) -> None:
     expected: StorageState = {
         "cookies": [
@@ -307,7 +316,7 @@ async def test_storage_state_should_round_trip_through_file(
         "origins": [],
     }
     request = await playwright.request.new_context(storage_state=expected)
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     actual = await request.storage_state(path=path)
     assert actual == expected
 
@@ -486,3 +495,61 @@ def _handle_request(req: TestServerRequest) -> None:
     assert await response.text() == "Hello!"
     assert request_count == 4
     await request.dispose()
+
+
+async def test_should_throw_when_fail_on_status_code_is_true(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = await playwright.request.new_context(fail_on_status_code=True)
+    with pytest.raises(Error, match="404 Not Found"):
+        await request.fetch(server.EMPTY_PAGE)
+    await request.dispose()
+
+
+async def test_should_not_throw_when_fail_on_status_code_is_false(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = await playwright.request.new_context(fail_on_status_code=False)
+    response = await request.fetch(server.EMPTY_PAGE)
+    assert response.status == 404
+    await request.dispose()
+
+
+async def test_should_follow_max_redirects(
+    playwright: Playwright, server: Server
+) -> None:
+    redirect_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal redirect_count
+        redirect_count += 1
+        req.setResponseCode(301)
+        req.setHeader("Location", server.EMPTY_PAGE)
+        req.finish()
+
+    server.set_route("/empty.html", _handle_request)
+    request = await playwright.request.new_context(max_redirects=1)
+    with pytest.raises(Error, match="Max redirect count exceeded"):
+        await request.fetch(server.EMPTY_PAGE)
+    assert redirect_count == 2
+    await request.dispose()
diff --git a/tests/async/test_fill.py b/tests/async/test_fill.py
index 4dd6db321..c5f0a55be 100644
--- a/tests/async/test_fill.py
+++ b/tests/async/test_fill.py
@@ -22,7 +22,14 @@ async def test_fill_textarea(page: Page, server: Server) -> None:
     assert await page.evaluate("result") == "some value"
 
 
-#
+async def test_is_enabled_for_non_editable_button(page: Page) -> None:
+    await page.set_content(
+        """
+        <button>button</button>
+    """
+    )
+    button = page.locator("button")
+    assert await button.is_enabled() is True
 
 
 async def test_fill_input(page: Page, server: Server) -> None:
diff --git a/tests/async/test_geolocation.py b/tests/async/test_geolocation.py
index 5791b5984..12b00a4fa 100644
--- a/tests/async/test_geolocation.py
+++ b/tests/async/test_geolocation.py
@@ -48,7 +48,7 @@ async def test_should_isolate_contexts(
     await page.goto(server.EMPTY_PAGE)
 
     context2 = await browser.new_context(
-        permissions=["geolocation"], geolocation={"latitude": 20, "longitude": 20}
+        permissions=["geolocation"], geolocation={"latitude": 10.5, "longitude": 10.5}
     )
 
     page2 = await context2.new_page()
@@ -66,7 +66,7 @@ async def test_should_isolate_contexts(
       resolve({latitude: position.coords.latitude, longitude: position.coords.longitude})
     }))"""
     )
-    assert geolocation2 == {"latitude": 20, "longitude": 20}
+    assert geolocation2 == {"latitude": 10.5, "longitude": 10.5}
 
     await context2.close()
 
diff --git a/tests/async/test_har.py b/tests/async/test_har.py
index b7875ea35..0ea5ee054 100644
--- a/tests/async/test_har.py
+++ b/tests/async/test_har.py
@@ -27,8 +27,8 @@
 from tests.utils import must
 
 
-async def test_should_work(browser: Browser, server: Server, tmpdir: Path) -> None:
-    path = os.path.join(tmpdir, "log.har")
+async def test_should_work(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(record_har_path=path)
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -39,9 +39,9 @@ async def test_should_work(browser: Browser, server: Server, tmpdir: Path) -> No
 
 
 async def test_should_omit_content(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         record_har_path=path,
         record_har_content="omit",
@@ -59,9 +59,9 @@ async def test_should_omit_content(
 
 
 async def test_should_omit_content_legacy(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         record_har_path=path, record_har_omit_content=True
     )
@@ -78,9 +78,9 @@ async def test_should_omit_content_legacy(
 
 
 async def test_should_attach_content(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har.zip")
+    path = os.path.join(tmp_path, "log.har.zip")
     context = await browser.new_context(
         record_har_path=path,
         record_har_content="attach",
@@ -137,9 +137,9 @@ async def test_should_attach_content(
 
 
 async def test_should_not_omit_content(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         record_har_path=path, record_har_omit_content=False
     )
@@ -153,9 +153,9 @@ async def test_should_not_omit_content(
 
 
 async def test_should_include_content(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(record_har_path=path)
     page = await context.new_page()
     await page.goto(server.PREFIX + "/har.html")
@@ -171,9 +171,9 @@ async def test_should_include_content(
 
 
 async def test_should_default_to_full_mode(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         record_har_path=path,
     )
@@ -188,9 +188,9 @@ async def test_should_default_to_full_mode(
 
 
 async def test_should_support_minimal_mode(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         record_har_path=path,
         record_har_mode="minimal",
@@ -206,9 +206,9 @@ async def test_should_support_minimal_mode(
 
 
 async def test_should_filter_by_glob(
-    browser: Browser, server: Server, tmpdir: str
+    browser: Browser, server: Server, tmp_path: str
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         base_url=server.PREFIX,
         record_har_path=path,
@@ -227,9 +227,9 @@ async def test_should_filter_by_glob(
 
 
 async def test_should_filter_by_regexp(
-    browser: Browser, server: Server, tmpdir: str
+    browser: Browser, server: Server, tmp_path: str
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
         base_url=server.PREFIX,
         record_har_path=path,
@@ -303,9 +303,9 @@ async def test_by_default_should_abort_requests_not_found_in_har(
 
 
 async def test_fallback_continue_should_continue_requests_on_bad_har(
-    context: BrowserContext, server: Server, tmpdir: Path
+    context: BrowserContext, server: Server, tmp_path: Path
 ) -> None:
-    path_to_invalid_har = tmpdir / "invalid.har"
+    path_to_invalid_har = tmp_path / "invalid.har"
     with path_to_invalid_har.open("w") as f:
         json.dump({"log": {}}, f)
     await context.route_from_har(har=path_to_invalid_har, not_found="fallback")
@@ -500,9 +500,9 @@ async def test_should_fulfill_from_har_with_content_in_a_file(
 
 
 async def test_should_round_trip_har_zip(
-    browser: Browser, server: Server, assetdir: Path, tmpdir: Path
+    browser: Browser, server: Server, assetdir: Path, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = await browser.new_context(
         record_har_mode="minimal", record_har_path=har_path
     )
@@ -521,7 +521,7 @@ async def test_should_round_trip_har_zip(
 
 
 async def test_should_round_trip_har_with_post_data(
-    browser: Browser, server: Server, assetdir: Path, tmpdir: Path
+    browser: Browser, server: Server, assetdir: Path, tmp_path: Path
 ) -> None:
     server.set_route("/echo", lambda req: (req.write(req.post_body), req.finish()))
     fetch_function = """
@@ -530,7 +530,7 @@ async def test_should_round_trip_har_with_post_data(
             return await response.text();
         };
     """
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = await browser.new_context(
         record_har_mode="minimal", record_har_path=har_path
     )
@@ -554,7 +554,7 @@ async def test_should_round_trip_har_with_post_data(
 
 
 async def test_should_disambiguate_by_header(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
     server.set_route(
         "/echo",
@@ -574,7 +574,7 @@ async def test_should_disambiguate_by_header(
             return await response.text();
         };
     """
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = await browser.new_context(
         record_har_mode="minimal", record_har_path=har_path
     )
@@ -597,9 +597,9 @@ async def test_should_disambiguate_by_header(
 
 
 async def test_should_produce_extracted_zip(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.har"
+    har_path = tmp_path / "har.har"
     context = await browser.new_context(
         record_har_mode="minimal", record_har_path=har_path, record_har_content="attach"
     )
@@ -624,9 +624,9 @@ async def test_should_produce_extracted_zip(
 
 
 async def test_should_update_har_zip_for_context(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context = await browser.new_context()
     await context.route_from_har(har_path, update=True)
     page_1 = await context.new_page()
@@ -684,9 +684,9 @@ async def test_context_unroute_call_should_stop_context_route_from_har(
 
 
 async def test_should_update_har_zip_for_page(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context = await browser.new_context()
     page_1 = await context.new_page()
     await page_1.route_from_har(har_path, update=True)
@@ -706,9 +706,9 @@ async def test_should_update_har_zip_for_page(
 
 
 async def test_should_update_har_zip_for_page_with_different_options(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context1 = await browser.new_context()
     page1 = await context1.new_page()
     await page1.route_from_har(
@@ -729,9 +729,9 @@ async def test_should_update_har_zip_for_page_with_different_options(
 
 
 async def test_should_update_extracted_har_zip_for_page(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.har"
+    har_path = tmp_path / "har.har"
     context = await browser.new_context()
     page_1 = await context.new_page()
     await page_1.route_from_har(har_path, update=True)
@@ -757,9 +757,9 @@ async def test_should_update_extracted_har_zip_for_page(
 async def test_should_ignore_aborted_requests(
     context_factory: Callable[[], Awaitable[BrowserContext]],
     server: Server,
-    tmpdir: Path,
+    tmp_path: Path,
 ) -> None:
-    path = tmpdir / "test.har"
+    path = tmp_path / "test.har"
     server.set_route("/x", lambda request: request.loseConnection())
     context1 = await context_factory()
     await context1.route_from_har(har=path, update=True)
diff --git a/tests/async/test_headful.py b/tests/async/test_headful.py
index 2e0dd026f..2b0b64c8e 100644
--- a/tests/async/test_headful.py
+++ b/tests/async/test_headful.py
@@ -23,10 +23,10 @@
 
 
 async def test_should_have_default_url_when_launching_browser(
-    browser_type: BrowserType, launch_arguments: Dict, tmpdir: Path
+    browser_type: BrowserType, launch_arguments: Dict, tmp_path: Path
 ) -> None:
     browser_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": False}
+        tmp_path, **{**launch_arguments, "headless": False}
     )
     urls = [page.url for page in browser_context.pages]
     assert urls == ["about:blank"]
@@ -34,10 +34,10 @@ async def test_should_have_default_url_when_launching_browser(
 
 
 async def test_should_close_browser_with_beforeunload_page(
-    browser_type: BrowserType, launch_arguments: Dict, server: Server, tmpdir: Path
+    browser_type: BrowserType, launch_arguments: Dict, server: Server, tmp_path: Path
 ) -> None:
     browser_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": False}
+        tmp_path, **{**launch_arguments, "headless": False}
     )
     page = await browser_context.new_page()
     await page.goto(server.PREFIX + "/beforeunload.html")
diff --git a/tests/async/test_input.py b/tests/async/test_input.py
index f9c487867..b7bd3d799 100644
--- a/tests/async/test_input.py
+++ b/tests/async/test_input.py
@@ -21,7 +21,6 @@
 from typing import Any
 
 import pytest
-from flaky import flaky
 
 from playwright._impl._path_utils import get_file_dirname
 from playwright.async_api import Error, FilePayload, Page
@@ -316,7 +315,6 @@ async def _listen_for_wheel_events(page: Page, selector: str) -> None:
     )
 
 
-@flaky
 async def test_should_upload_large_file(
     page: Page, server: Server, tmp_path: Path
 ) -> None:
@@ -383,7 +381,6 @@ async def test_set_input_files_should_preserve_last_modified_timestamp(
         assert abs(timestamps[i] - expected_timestamps[i]) < 1000
 
 
-@flaky
 async def test_should_upload_multiple_large_file(
     page: Page, server: Server, tmp_path: Path
 ) -> None:
diff --git a/tests/async/test_keyboard.py b/tests/async/test_keyboard.py
index d94f036e7..e175f429a 100644
--- a/tests/async/test_keyboard.py
+++ b/tests/async/test_keyboard.py
@@ -109,7 +109,9 @@ async def test_should_send_a_character_with_send_character(
         '() => window.addEventListener("keydown", e => e.preventDefault(), true)'
     )
     await page.keyboard.insert_text("a")
-    assert await page.evaluate('() => document.querySelector("textarea").value') == "嗨a"
+    assert (
+        await page.evaluate('() => document.querySelector("textarea").value') == "嗨a"
+    )
 
 
 async def test_should_only_emit_input_event(page: Page, server: Server) -> None:
diff --git a/tests/async/test_launcher.py b/tests/async/test_launcher.py
index d29b20989..bd5dd82de 100644
--- a/tests/async/test_launcher.py
+++ b/tests/async/test_launcher.py
@@ -15,7 +15,7 @@
 import asyncio
 import os
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict
 
 import pytest
 
@@ -107,39 +107,3 @@ async def test_browser_close_should_be_callable_twice(
         browser.close(),
     )
     await browser.close()
-
-
-@pytest.mark.only_browser("chromium")
-async def test_browser_launch_should_return_background_pages(
-    browser_type: BrowserType,
-    tmpdir: Path,
-    browser_channel: Optional[str],
-    assetdir: Path,
-    launch_arguments: Dict,
-) -> None:
-    if browser_channel:
-        pytest.skip()
-
-    extension_path = str(assetdir / "simple-extension")
-    context = await browser_type.launch_persistent_context(
-        str(tmpdir),
-        **{
-            **launch_arguments,
-            "headless": False,
-            "args": [
-                f"--disable-extensions-except={extension_path}",
-                f"--load-extension={extension_path}",
-            ],
-        },
-    )
-    background_page = None
-    if len(context.background_pages):
-        background_page = context.background_pages[0]
-    else:
-        background_page = await context.wait_for_event("backgroundpage")
-    assert background_page
-    assert background_page in context.background_pages
-    assert background_page not in context.pages
-    await context.close()
-    assert len(context.background_pages) == 0
-    assert len(context.pages) == 0
diff --git a/tests/async/test_locators.py b/tests/async/test_locators.py
index b12a25a56..1e49bf303 100644
--- a/tests/async/test_locators.py
+++ b/tests/async/test_locators.py
@@ -128,7 +128,7 @@ async def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> No
     )
 
     div = page.locator("div")
-    assert await div.is_enabled() is True
+    assert await div.is_enabled()
     assert await div.is_disabled() is False
 
     button1 = page.locator(':text("button1")')
@@ -136,7 +136,7 @@ async def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> No
     assert await button1.is_disabled() is True
 
     button1 = page.locator(':text("button2")')
-    assert await button1.is_enabled() is True
+    assert await button1.is_enabled()
     assert await button1.is_disabled() is False
 
 
@@ -532,6 +532,28 @@ async def test_should_combine_visible_with_other_selectors(page: Page) -> None:
     )
 
 
+async def test_should_support_filter_visible(page: Page) -> None:
+    await page.set_content(
+        """<div>
+    <div class="item" style="display: none">Hidden data0</div>
+    <div class="item">visible data1</div>
+    <div class="item" style="display: none">Hidden data1</div>
+    <div class="item">visible data2</div>
+    <div class="item" style="display: none">Hidden data2</div>
+    <div class="item">visible data3</div>
+    </div>
+    """
+    )
+    locator = page.locator(".item").filter(visible=True).nth(1)
+    await expect(locator).to_have_text("visible data2")
+    await expect(
+        page.locator(".item").filter(visible=True).get_by_text("data3")
+    ).to_have_text("visible data3")
+    await expect(
+        page.locator(".item").filter(visible=False).get_by_text("data1")
+    ).to_have_text("Hidden data1")
+
+
 async def test_locator_count_should_work_with_deleted_map_in_main_world(
     page: Page,
 ) -> None:
@@ -1121,3 +1143,51 @@ async def test_locator_click_timeout_error_should_contain_call_log(page: Page) -
         "During handling of the above exception, another exception occurred"
         not in formatted_exception
     )
+
+
+async def test_locator_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    await page.set_content("<div>foo</div>")
+    div = page.locator("div")
+    assert await div.is_hidden(timeout=10) is False
+    assert await div.is_visible(timeout=10) is True
+
+
+async def test_description_should_return_none_for_locator_without_description(
+    page: Page,
+) -> None:
+    locator = page.locator("button")
+    assert locator.description is None
+
+
+async def test_description_should_return_description_for_locator_with_simple_description(
+    page: Page,
+) -> None:
+    locator = page.locator("button").describe("Submit button")
+    assert locator.description == "Submit button"
+
+
+async def test_description_should_return_description_with_special_characters(
+    page: Page,
+) -> None:
+    locator = page.locator("div").describe("Button with \"quotes\" and 'apostrophes'")
+    assert locator.description == "Button with \"quotes\" and 'apostrophes'"
+
+
+async def test_description_should_return_description_for_chained_locators(
+    page: Page,
+) -> None:
+    locator = page.locator("form").locator("input").describe("Form input field")
+    assert locator.description == "Form input field"
+
+
+async def test_description_should_return_description_for_locator_with_multiple_describe_calls(
+    page: Page,
+) -> None:
+    locator1 = page.locator("foo").describe("First description")
+    assert locator1.description == "First description"
+    locator2 = locator1.locator("button").describe("Second description")
+    assert locator2.description == "Second description"
+    locator3 = locator2.locator("button")
+    assert locator3.description is None
diff --git a/tests/async/test_navigation.py b/tests/async/test_navigation.py
index de4a2f5e9..240aee242 100644
--- a/tests/async/test_navigation.py
+++ b/tests/async/test_navigation.py
@@ -264,7 +264,7 @@ async def test_goto_should_fail_when_main_resources_failed_to_load(
     if is_chromium:
         assert "net::ERR_CONNECTION_REFUSED" in exc_info.value.message
     elif is_webkit and is_win:
-        assert "Couldn't connect to server" in exc_info.value.message
+        assert "Could not connect to server" in exc_info.value.message
     elif is_webkit:
         assert "Could not connect" in exc_info.value.message
     else:
@@ -504,9 +504,10 @@ async def test_wait_for_nav_should_respect_timeout(page: Page, server: Server) -
 async def test_wait_for_nav_should_work_with_both_domcontentloaded_and_load(
     page: Page, server: Server
 ) -> None:
-    async with page.expect_navigation(
-        wait_until="domcontentloaded"
-    ), page.expect_navigation(wait_until="load"):
+    async with (
+        page.expect_navigation(wait_until="domcontentloaded"),
+        page.expect_navigation(wait_until="load"),
+    ):
         await page.goto(server.PREFIX + "/one-style.html")
 
 
diff --git a/tests/async/test_network.py b/tests/async/test_network.py
index 0725516bd..8747956ab 100644
--- a/tests/async/test_network.py
+++ b/tests/async/test_network.py
@@ -19,7 +19,6 @@
 from typing import Dict, List, Optional, Union
 
 import pytest
-from flaky import flaky
 from twisted.web import http
 
 from playwright.async_api import Browser, Error, Page, Request, Response, Route
@@ -819,7 +818,6 @@ async def test_set_extra_http_headers_should_work_with_extra_headers_from_browse
     assert request.getHeader("foo") == "bar"
 
 
-@flaky  # Flaky upstream https://devops.aslushnikov.com/flakiness2.html#filter_spec=should+override+extra+headers+from+browser+context&test_parameter_filters=%5B%5B%22browserName%22%2C%5B%5B%22webkit%22%2C%22include%22%5D%5D%5D%2C%5B%22video%22%2C%5B%5Btrue%2C%22exclude%22%5D%5D%5D%2C%5B%22platform%22%2C%5B%5B%22Windows%22%2C%22include%22%5D%5D%5D%5D
 async def test_set_extra_http_headers_should_override_extra_headers_from_browser_context(
     browser: Browser, server: Server
 ) -> None:
@@ -855,12 +853,12 @@ async def test_set_extra_http_headers_should_throw_for_non_string_header_values(
 
 
 async def test_response_server_addr(page: Page, server: Server) -> None:
-    response = await page.goto(f"http://127.0.0.1:{server.PORT}")
+    response = await page.goto(server.EMPTY_PAGE)
     assert response
     server_addr = await response.server_addr()
     assert server_addr
     assert server_addr["port"] == server.PORT
-    assert server_addr["ipAddress"] in ["127.0.0.1", "::1"]
+    assert server_addr["ipAddress"] in ["127.0.0.1", "[::1]"]
 
 
 async def test_response_security_details(
diff --git a/tests/async/test_page.py b/tests/async/test_page.py
index 376df8376..562d98248 100644
--- a/tests/async/test_page.py
+++ b/tests/async/test_page.py
@@ -662,7 +662,7 @@ async def load() -> None:
 
 
 async def test_set_content_should_work_with_tricky_content(page: Page) -> None:
-    await page.set_content("<div>hello world</div>" + "\x7F")
+    await page.set_content("<div>hello world</div>" + "\x7f")
     assert await page.eval_on_selector("div", "div => div.textContent") == "hello world"
 
 
@@ -1320,6 +1320,106 @@ async def test_drag_and_drop_with_position(page: Page, server: Server) -> None:
     ]
 
 
+async def test_drag_and_drop_with_tweened_mouse_movement(page: Page) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0;">
+          <div style="width:100px;height:100px;background:red;" id="red"></div>
+          <div style="width:300px;height:100px;background:blue;" id="blue"></div>
+        </body>
+        """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+            const events = [];
+            document.addEventListener('mousedown', event => {
+                events.push({
+                    type: 'mousedown',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mouseup', event => {
+                events.push({
+                    type: 'mouseup',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mousemove', event => {
+                events.push({
+                    type: 'mousemove',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            return events;
+        }
+        """
+    )
+    await page.drag_and_drop("#red", "#blue", steps=4)
+    assert await events_handle.json_value() == [
+        {"type": "mousemove", "x": 50, "y": 50},
+        {"type": "mousedown", "x": 50, "y": 50},
+        {"type": "mousemove", "x": 75, "y": 75},
+        {"type": "mousemove", "x": 100, "y": 100},
+        {"type": "mousemove", "x": 125, "y": 125},
+        {"type": "mousemove", "x": 150, "y": 150},
+        {"type": "mouseup", "x": 150, "y": 150},
+    ]
+
+
+async def test_locator_drag_to_with_tweened_mouse_movement(page: Page) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0;">
+          <div style="width:100px;height:100px;background:red;" id="red"></div>
+          <div style="width:300px;height:100px;background:blue;" id="blue"></div>
+        </body>
+        """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+            const events = [];
+            document.addEventListener('mousedown', event => {
+                events.push({
+                    type: 'mousedown',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mouseup', event => {
+                events.push({
+                    type: 'mouseup',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mousemove', event => {
+                events.push({
+                    type: 'mousemove',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            return events;
+        }
+        """
+    )
+    await page.locator("#red").drag_to(page.locator("#blue"), steps=4)
+    assert await events_handle.json_value() == [
+        {"type": "mousemove", "x": 50, "y": 50},
+        {"type": "mousedown", "x": 50, "y": 50},
+        {"type": "mousemove", "x": 75, "y": 75},
+        {"type": "mousemove", "x": 100, "y": 100},
+        {"type": "mousemove", "x": 125, "y": 125},
+        {"type": "mousemove", "x": 150, "y": 150},
+        {"type": "mouseup", "x": 150, "y": 150},
+    ]
+
+
 async def test_should_check_box_using_set_checked(page: Page) -> None:
     await page.set_content("`<input id='checkbox' type='checkbox'></input>`")
     await page.set_checked("input", True)
@@ -1350,7 +1450,6 @@ async def test_should_set_bodysize_to_0(page: Page, server: Server) -> None:
     assert sizes["requestHeadersSize"] >= 200
 
 
-@pytest.mark.skip_browser("webkit")  # https://bugs.webkit.org/show_bug.cgi?id=225281
 async def test_should_emulate_forced_colors(page: Page) -> None:
     assert await page.evaluate("matchMedia('(forced-colors: none)').matches")
     await page.emulate_media(forced_colors="none")
@@ -1361,6 +1460,26 @@ async def test_should_emulate_forced_colors(page: Page) -> None:
     assert not await page.evaluate("matchMedia('(forced-colors: none)').matches")
 
 
+async def test_should_emulate_contrast(page: Page) -> None:
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    await page.emulate_media(contrast="no-preference")
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    assert not await page.evaluate("matchMedia('(prefers-contrast: more)').matches")
+    await page.emulate_media(contrast="more")
+    assert not await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    assert await page.evaluate("matchMedia('(prefers-contrast: more)').matches")
+    await page.emulate_media(contrast="null")
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+
+
 async def test_should_not_throw_when_continuing_while_page_is_closing(
     page: Page, server: Server
 ) -> None:
@@ -1384,7 +1503,6 @@ async def test_should_not_throw_when_continuing_after_page_is_closed(
     async def handle_route(route: Route) -> None:
         await page.close()
         await route.continue_()
-        nonlocal done
         done.set_result(True)
 
     await page.route("**/*", handle_route)
@@ -1432,3 +1550,11 @@ async def test_page_pause_should_reset_custom_timeouts(
     server.set_route("/empty.html", lambda route: None)
     with pytest.raises(Error, match="Timeout 456ms exceeded."):
         await page.goto(server.EMPTY_PAGE)
+
+
+async def test_page_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    await page.set_content("<div>foo</div>")
+    assert await page.is_hidden("div", timeout=10) is False
+    assert await page.is_visible("div", timeout=10) is True
diff --git a/tests/async/test_page_add_locator_handler.py b/tests/async/test_page_add_locator_handler.py
index 4492037a7..5f44170f8 100644
--- a/tests/async/test_page_add_locator_handler.py
+++ b/tests/async/test_page_add_locator_handler.py
@@ -30,7 +30,6 @@ async def test_should_work(page: Page, server: Server) -> None:
     original_locator = page.get_by_text("This interstitial covers the button")
 
     async def handler(locator: Locator) -> None:
-        nonlocal original_locator
         assert locator == original_locator
         nonlocal before_count
         nonlocal after_count
@@ -312,7 +311,7 @@ def _handler() -> None:
     with pytest.raises(Error) as exc_info:
         await page.locator("#target").click(timeout=3000)
     assert await page.evaluate("window.clicked") == 0
-    await expect(page.locator("#interstitial")).to_be_visible()
+    assert await page.locator("#interstitial").is_visible()
     assert called == 1
     assert (
         'locator handler has finished, waiting for get_by_role("button", name="close") to be hidden'
diff --git a/tests/async/test_page_aria_snapshot.py b/tests/async/test_page_aria_snapshot.py
new file mode 100644
index 000000000..cef17cdd0
--- /dev/null
+++ b/tests/async/test_page_aria_snapshot.py
@@ -0,0 +1,216 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+import pytest
+
+from playwright.async_api import Locator, Page, expect
+
+
+def _unshift(snapshot: str) -> str:
+    lines = snapshot.split("\n")
+    whitespace_prefix_length = 100
+    for line in lines:
+        if not line.strip():
+            continue
+        match = re.match(r"^(\s*)", line)
+        if match and len(match[1]) < whitespace_prefix_length:
+            whitespace_prefix_length = len(match[1])
+    return "\n".join(
+        [line[whitespace_prefix_length:] for line in lines if line.strip()]
+    )
+
+
+async def check_and_match_snapshot(locator: Locator, snapshot: str) -> None:
+    assert await locator.aria_snapshot() == _unshift(snapshot)
+    await expect(locator).to_match_aria_snapshot(snapshot, timeout=1000)
+
+
+async def test_should_snapshot(page: Page) -> None:
+    await page.set_content("<h1>title</h1>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+    """,
+    )
+
+
+async def test_should_snapshot_list(page: Page) -> None:
+    await page.set_content("<h1>title</h1><h1>title 2</h1>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+      - heading "title 2" [level=1]
+    """,
+    )
+
+
+async def test_should_snapshot_list_with_list(page: Page) -> None:
+    await page.set_content("<ul><li>one</li><li>two</li></ul>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+async def test_should_snapshot_list_with_accessible_name(page: Page) -> None:
+    await page.set_content('<ul aria-label="my list"><li>one</li><li>two</li></ul>')
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list "my list":
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+async def test_should_snapshot_complex(page: Page) -> None:
+    await page.set_content('<ul><li><a href="about:blank">link</a></li></ul>')
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem:
+          - link "link":
+            - /url: about:blank
+    """,
+    )
+
+
+async def test_should_snapshot_with_unexpected_children_equal(page: Page) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>One</li>
+        <li>Two</li>
+        <li>Three</li>
+      </ul>
+    """
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem: One
+        - listitem: Three
+    """,
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: equal
+          - listitem: One
+          - listitem: Three
+      """,
+            timeout=1000,
+        )
+
+
+async def test_should_snapshot_with_unexpected_children_deep_equal(page: Page) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem:
+          - list:
+            - listitem: 1.1
+    """,
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+          - list:
+            - /children: deep-equal
+            - listitem:
+              - list:
+                - listitem: 1.1
+        """,
+            timeout=1000,
+        )
+
+
+async def test_should_snapshot_with_restored_contain_mode_inside_deep_equal(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+            timeout=1000,
+        )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - /children: contain
+              - listitem: 1.1
+      """,
+    )
+
+
+async def test_match_values_both_against_regex_and_string(page: Page) -> None:
+    await page.set_content('<a href="/auth?r=/">Log in</a>')
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - link "Log in":
+          - /url: /auth?r=/
+      """,
+    )
diff --git a/tests/async/test_page_base_url.py b/tests/async/test_page_base_url.py
index ab917b248..3f0599e01 100644
--- a/tests/async/test_page_base_url.py
+++ b/tests/async/test_page_base_url.py
@@ -38,10 +38,10 @@ async def test_should_construct_a_new_url_when_a_base_url_in_browser_new_page_is
 
 
 async def test_should_construct_a_new_url_when_a_base_url_in_browser_new_persistent_context_is_passed(
-    browser_type: BrowserType, tmpdir: Path, server: Server, launch_arguments: Dict
+    browser_type: BrowserType, tmp_path: Path, server: Server, launch_arguments: Dict
 ) -> None:
     context = await browser_type.launch_persistent_context(
-        tmpdir, **launch_arguments, base_url=server.PREFIX
+        tmp_path, **launch_arguments, base_url=server.PREFIX
     )
     page = await context.new_page()
     assert (must(await page.goto("/empty.html"))).url == server.EMPTY_PAGE
diff --git a/tests/async/test_page_clock.py b/tests/async/test_page_clock.py
index 0676ee581..cbe7740ea 100644
--- a/tests/async/test_page_clock.py
+++ b/tests/async/test_page_clock.py
@@ -409,7 +409,6 @@ async def test_should_pause(self, page: Page) -> None:
         await page.goto("data:text/html,")
         await page.clock.pause_at(1)
         await page.wait_for_timeout(1000)
-        await page.clock.resume()
         now = await page.evaluate("Date.now()")
         assert 0 <= now <= 1000
 
diff --git a/tests/async/test_page_evaluate.py b/tests/async/test_page_evaluate.py
index 9b7712906..058263b18 100644
--- a/tests/async/test_page_evaluate.py
+++ b/tests/async/test_page_evaluate.py
@@ -65,6 +65,29 @@ async def test_evaluate_transfer_arrays(page: Page) -> None:
     assert result == [1, 2, 3]
 
 
+async def test_evaluate_transfer_typed_arrays(page: Page) -> None:
+    async def test_typed_array(
+        typed_array: str, expected: list[float], value_suffix: Optional[str]
+    ) -> None:
+        value_suffix = "" if value_suffix is None else value_suffix
+        result = await page.evaluate(
+            f"() => new {typed_array}([1{value_suffix}, 2{value_suffix}, 3{value_suffix}])"
+        )
+        assert result == expected
+
+    await test_typed_array("Int8Array", [1, 2, 3], None)
+    await test_typed_array("Uint8Array", [1, 2, 3], None)
+    await test_typed_array("Uint8ClampedArray", [1, 2, 3], None)
+    await test_typed_array("Int16Array", [1, 2, 3], None)
+    await test_typed_array("Uint16Array", [1, 2, 3], None)
+    await test_typed_array("Int32Array", [1, 2, 3], None)
+    await test_typed_array("Uint32Array", [1, 2, 3], None)
+    await test_typed_array("Float32Array", [1.5, 2.5, 3.5], ".5")
+    await test_typed_array("Float64Array", [1.5, 2.5, 3.5], ".5")
+    await test_typed_array("BigInt64Array", [1, 2, 3], "n")
+    await test_typed_array("BigUint64Array", [1, 2, 3], "n")
+
+
 async def test_evaluate_transfer_bigint(page: Page) -> None:
     assert await page.evaluate("() => 42n") == 42
     assert await page.evaluate("a => a", 17) == 17
diff --git a/tests/async/test_page_event_console.py b/tests/async/test_page_event_console.py
new file mode 100644
index 000000000..4326e1823
--- /dev/null
+++ b/tests/async/test_page_event_console.py
@@ -0,0 +1,35 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright._impl._page import Page
+
+
+async def test_console_messages_should_work(page: Page) -> None:
+    await page.evaluate(
+        """() => {
+            for (let i = 0; i < 301; i++)
+                console.log('message' + i);
+        }"""
+    )
+
+    messages = await page.console_messages()
+    objects = [{"text": m.text, "type": m.type, "page": m.page} for m in messages]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append({"text": f"message{i}", "type": "log", "page": page})
+
+    assert len(objects) >= 100, "should be at least 100 messages"
+    message_count = len(messages) - len(expected)
+    assert objects[message_count:] == expected, "should return last messages"
diff --git a/tests/async/test_page_event_pageerror.py b/tests/async/test_page_event_pageerror.py
new file mode 100644
index 000000000..4914af5d1
--- /dev/null
+++ b/tests/async/test_page_event_pageerror.py
@@ -0,0 +1,36 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.async_api import Page
+
+
+async def test_page_errors_should_work(page: Page) -> None:
+    await page.evaluate(
+        """async () => {
+            for (let i = 0; i < 301; i++)
+                window.setTimeout(() => { throw new Error('error' + i); }, 0);
+            await new Promise(f => window.setTimeout(f, 100));
+        }"""
+    )
+
+    errors = await page.page_errors()
+    messages = [e.message for e in errors]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append(f"error{i}")
+
+    assert len(messages) >= 100, "should be at least 100 errors"
+    message_count = len(messages) - len(expected)
+    assert messages[message_count:] == expected, "should return last errors"
diff --git a/tests/async/test_page_event_request.py b/tests/async/test_page_event_request.py
new file mode 100644
index 000000000..73d6fd785
--- /dev/null
+++ b/tests/async/test_page_event_request.py
@@ -0,0 +1,62 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+
+from playwright._impl._network import Request, Route
+from playwright._impl._page import Page
+from tests.server import Server
+
+
+async def test_should_return_last_requests(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/title.html")
+    for i in range(200):
+
+        def _handle_route(route: Route) -> None:
+            asyncio.ensure_future(
+                route.fulfill(
+                    status=200,
+                    body=f"url:{route.request.url}",
+                )
+            )
+
+        await page.route(f"**/fetch?{i}", _handle_route)
+
+    # #0 is the navigation request, so start with #1.
+    for i in range(1, 100):
+        await page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    first_100_requests_with_goto = await page.requests()
+    first_100_requests = first_100_requests_with_goto[1:]
+
+    for i in range(100, 200):
+        await page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    last_100_requests = await page.requests()
+
+    all_requests = first_100_requests + last_100_requests
+
+    async def gather_response(request: Request) -> dict:
+        response = await request.response()
+        assert response
+        return {"text": await response.text(), "url": request.url}
+
+    # All 199 requests are fully functional.
+    received = await asyncio.gather(
+        *[gather_response(request) for request in all_requests]
+    )
+
+    expected = []
+    for i in range(1, 200):
+        url = server.PREFIX + f"/fetch?{i}"
+        expected.append({"url": url, "text": f"url:{url}"})
+    assert received == expected
diff --git a/tests/async/test_page_request_gc.py b/tests/async/test_page_request_gc.py
new file mode 100644
index 000000000..7d0cce9ef
--- /dev/null
+++ b/tests/async/test_page_request_gc.py
@@ -0,0 +1,34 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.async_api import Page
+from tests.server import Server
+
+
+async def test_should_work(page: Page, server: Server) -> None:
+    await page.evaluate(
+        """() => {
+        globalThis.objectToDestroy = { hello: 'world' };
+        globalThis.weakRef = new WeakRef(globalThis.objectToDestroy);
+    }"""
+    )
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    await page.evaluate("() => globalThis.objectToDestroy = null")
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") is None
diff --git a/tests/async/test_page_request_intercept.py b/tests/async/test_page_request_intercept.py
index 934aed8a0..a9859e87b 100644
--- a/tests/async/test_page_request_intercept.py
+++ b/tests/async/test_page_request_intercept.py
@@ -34,7 +34,7 @@ def _handler(request: TestServerRequest) -> None:
     async def handle(route: Route) -> None:
         with pytest.raises(Error) as error:
             await route.fetch(timeout=1000)
-        assert "Request timed out after 1000ms" in error.value.message
+        assert "Route.fetch: Timeout 1000ms exceeded." in error.value.message
 
     await page.route("**/*", lambda route: handle(route))
     with pytest.raises(Error) as error:
diff --git a/tests/async/test_page_route.py b/tests/async/test_page_route.py
index 8e0b74130..848a95045 100644
--- a/tests/async/test_page_route.py
+++ b/tests/async/test_page_route.py
@@ -20,7 +20,8 @@
 
 import pytest
 
-from playwright._impl._glob import glob_to_regex
+from playwright._impl._glob import glob_to_regex_pattern
+from playwright._impl._helper import url_matches
 from playwright.async_api import (
     Browser,
     BrowserContext,
@@ -29,6 +30,7 @@
     Playwright,
     Request,
     Route,
+    expect,
 )
 from tests.server import Server, TestServerRequest
 from tests.utils import must
@@ -527,12 +529,10 @@ def _handle(route: Route) -> None:
 
     await page.route("**/*", _handle)
 
-    response = await page.goto(
+    await page.set_content(
         f"""data:text/html,<link rel="stylesheet" href="{server.PREFIX}/fonts?helvetica|arial"/>"""
     )
-    assert response is None
-    # TODO: https://github.com/microsoft/playwright/issues/12789
-    assert len(requests) >= 1
+    assert len(requests) == 1
     assert (must(await requests[0].response())).status == 404
 
 
@@ -605,9 +605,9 @@ async def test_page_route_should_support_cors_with_GET(
 
     async def handle_route(route: Route, request: Request) -> None:
         headers = {
-            "access-control-allow-origin": "*"
-            if request.url.endswith("allow")
-            else "none"
+            "access-control-allow-origin": (
+                "*" if request.url.endswith("allow") else "none"
+            )
         }
         await route.fulfill(
             content_type="application/json",
@@ -1051,17 +1051,19 @@ async def handle_request(route: Route) -> None:
     assert await response.json() == {"foo": "bar"}
 
 
-async def test_glob_to_regex() -> None:
+async def test_should_work_with_glob() -> None:
+    def glob_to_regex(pattern: str) -> re.Pattern:
+        return re.compile(glob_to_regex_pattern(pattern))
+
     assert glob_to_regex("**/*.js").match("https://localhost:8080/foo.js")
     assert not glob_to_regex("**/*.css").match("https://localhost:8080/foo.js")
-    assert not glob_to_regex("*.js").match("https://localhost:8080/foo.js")
+    assert not glob_to_regex("*.js").match(
+        "https://localhost:8080/foo.js"
+    )  # Doesn"t match path separator
     assert glob_to_regex("https://**/*.js").match("https://localhost:8080/foo.js")
     assert glob_to_regex("http://localhost:8080/simple/path.js").match(
         "http://localhost:8080/simple/path.js"
     )
-    assert glob_to_regex("http://localhost:8080/?imple/path.js").match(
-        "http://localhost:8080/Simple/path.js"
-    )
     assert glob_to_regex("**/{a,b}.js").match("https://localhost:8080/a.js")
     assert glob_to_regex("**/{a,b}.js").match("https://localhost:8080/b.js")
     assert not glob_to_regex("**/{a,b}.js").match("https://localhost:8080/c.js")
@@ -1081,15 +1083,166 @@ async def test_glob_to_regex() -> None:
         "http://localhost:3000/signin-oidcnice"
     )
 
-    assert glob_to_regex("**/three-columns/settings.html?**id=[a-z]**").match(
+    assert glob_to_regex("**/*.js").match("/foo.js")
+    assert not glob_to_regex("asd/**.js").match("/foo.js")
+    assert not glob_to_regex("**/*.js").match("bar_foo.js")
+
+    # range [] is NOT supported
+    assert glob_to_regex("**/api/v[0-9]").fullmatch("http://example.com/api/v[0-9]")
+    assert not glob_to_regex("**/api/v[0-9]").fullmatch(
+        "http://example.com/api/version"
+    )
+    assert not glob_to_regex("**/api/v[0-9]").fullmatch(
+        "http://example.com/api/v1"
+    )  # Should not match if [] is literal
+
+    # query params
+    assert glob_to_regex("**/api\\?param").match("http://example.com/api?param")
+    assert not glob_to_regex("**/api\\?param").match("http://example.com/api-param")
+
+    assert glob_to_regex("**/three-columns/settings.html\\?**id=settings-**").match(
         "http://mydomain:8080/blah/blah/three-columns/settings.html?id=settings-e3c58efe-02e9-44b0-97ac-dd138100cf7c&blah"
     )
 
-    assert glob_to_regex("\\?") == re.compile(r"^\?$")
-    assert glob_to_regex("\\") == re.compile(r"^\\$")
-    assert glob_to_regex("\\\\") == re.compile(r"^\\$")
-    assert glob_to_regex("\\[") == re.compile(r"^\[$")
-    assert glob_to_regex("[a-z]") == re.compile(r"^[a-z]$")
-    assert glob_to_regex("$^+.\\*()|\\?\\{\\}\\[\\]") == re.compile(
-        r"^\$\^\+\.\*\(\)\|\?\{\}\[\]$"
+    assert glob_to_regex("\\?").pattern == r"^\?$"
+    assert glob_to_regex("\\").pattern == r"^\\$"
+    assert glob_to_regex("\\\\").pattern == r"^\\$"
+    assert glob_to_regex("\\[").pattern == r"^\[$"
+    assert glob_to_regex("[a-z]").pattern == r"^\[a-z\]$"
+    assert (
+        glob_to_regex("$^+.\\*()|\\?\\{\\}\\[\\]").pattern
+        == r"^\$\^\+\.\*\(\)\|\?\{\}\[\]$"
+    )
+
+    # --- url_matches tests ---
+    # Basic exact and wildcard matching
+    assert url_matches(None, "http://playwright.dev/", "http://playwright.dev")
+    assert url_matches(None, "http://playwright.dev/?a=b", "http://playwright.dev?a=b")
+    assert url_matches(None, "http://playwright.dev/", "h*://playwright.dev")
+    assert url_matches(
+        None, "http://api.playwright.dev/?x=y", "http://*.playwright.dev?x=y"
+    )
+    assert url_matches(None, "http://playwright.dev/foo/bar", "**/foo/**")
+
+    # Relative path matching with base URL
+    assert url_matches("http://playwright.dev", "http://playwright.dev/?x=y", "?x=y")
+    assert url_matches(
+        "http://playwright.dev/foo/", "http://playwright.dev/foo/bar?x=y", "./bar?x=y"
+    )
+
+    # Case insensitive matching
+    assert url_matches(
+        None, "https://playwright.dev/fooBAR", "HtTpS://pLaYwRiGhT.dEv/fooBAR"
+    )
+    assert url_matches(
+        "http://ignored",
+        "https://playwright.dev/fooBAR",
+        "HtTpS://pLaYwRiGhT.dEv/fooBAR",
+    )
+    # Path and search query are case-sensitive
+    assert not url_matches(
+        None, "https://playwright.dev/foobar", "https://playwright.dev/fooBAR"
+    )
+    assert not url_matches(
+        None, "https://playwright.dev/foobar?a=b", "https://playwright.dev/foobar?A=B"
+    )
+
+    assert url_matches(None, "https://localhost:3000/?a=b", "**/?a=b")
+    assert url_matches(None, "https://localhost:3000/?a=b", "**?a=b")
+    assert url_matches(None, "https://localhost:3000/?a=b", "**=b")
+
+    # Custom schema.
+    assert url_matches(None, "my.custom.protocol://foo", "my.custom.protocol://**")
+    assert not url_matches(None, "my.p://foo", "my.{p,y}://**")
+    assert url_matches(None, "my.p://foo/", "my.{p,y}://**")
+    assert url_matches(None, "file:///foo/", "f*e://**")
+
+    # This is not supported, we treat ? as a query separator.
+    assert not url_matches(
+        None,
+        "http://localhost:8080/Simple/path.js",
+        "http://localhost:8080/?imple/path.js",
+    )
+    assert not url_matches(None, "http://playwright.dev/", "http://playwright.?ev")
+    assert url_matches(None, "http://playwright./?ev", "http://playwright.?ev")
+    assert not url_matches(
+        None, "http://playwright.dev/foo", "http://playwright.dev/f??"
+    )
+    assert url_matches(None, "http://playwright.dev/f??", "http://playwright.dev/f??")
+    assert url_matches(
+        None, "http://playwright.dev/?x=y", r"http://playwright.dev\?x=y"
+    )
+    assert url_matches(
+        None, "http://playwright.dev/?x=y", r"http://playwright.dev/\?x=y"
+    )
+    assert url_matches(
+        "http://playwright.dev/foo", "http://playwright.dev/foo?bar", "?bar"
+    )
+    assert url_matches(
+        "http://playwright.dev/foo", "http://playwright.dev/foo?bar", r"\\?bar"
+    )
+    assert url_matches("http://first.host/", "http://second.host/foo", "**/foo")
+    assert url_matches("http://playwright.dev/", "http://localhost/", "*//localhost/")
+
+    # /**/ should match /.
+    assert url_matches(None, "https://foo/bar.js", "https://foo/**/bar.js")
+    assert url_matches(None, "https://foo/bar.js", "https://foo/**/**/bar.js")
+
+    custom_prefixes = ["about", "data", "chrome", "edge", "file"]
+    for prefix in custom_prefixes:
+        assert url_matches(
+            "http://playwright.dev/", f"{prefix}:blank", f"{prefix}:blank"
+        )
+        assert not url_matches(
+            "http://playwright.dev/", f"{prefix}:blank", "http://playwright.dev/"
+        )
+        assert url_matches(None, f"{prefix}:blank", f"{prefix}:blank")
+        assert url_matches(None, f"{prefix}:blank", f"{prefix}:*")
+        assert not url_matches(None, f"not{prefix}:blank", f"{prefix}:*")
+
+    # Added for Python implementation
+    assert url_matches(
+        None,
+        "custom://example.com/foo/bar?id=123",
+        "{custom,another}://example.com/foo/bar?id=123",
+    )
+    assert url_matches(
+        None, "custom://example.com/foo/bar?id=123", "**example.com/foo/bar?id=123"
+    )
+
+
+async def test_should_not_support_question_in_glob_pattern(
+    page: Page, playwright: Playwright, server: Server
+) -> None:
+    server.set_route("/index", lambda req: (req.write(b"index-no-hello"), req.finish()))
+    server.set_route(
+        "/index123hello", lambda req: (req.write(b"index123hello"), req.finish())
+    )
+    server.set_route(
+        "/index?hello", lambda req: (req.write(b"index?hello"), req.finish())
     )
+    server.set_route(
+        "/index1hello", lambda req: (req.write(b"index1hello"), req.finish())
+    )
+
+    async def handle_any_char(route: Route) -> None:
+        await route.fulfill(body="intercepted any character")
+
+    await page.route("**/index?hello", handle_any_char)
+
+    async def handle_question_mark(route: Route) -> None:
+        await route.fulfill(body="intercepted question mark")
+
+    await page.route(r"**/index\?hello", handle_question_mark)
+
+    await page.goto(server.PREFIX + "/index?hello")
+    await expect(page.locator("body")).to_have_text("intercepted question mark")
+
+    await page.goto(server.PREFIX + "/index")
+    await expect(page.locator("body")).to_have_text("index-no-hello")
+
+    await page.goto(server.PREFIX + "/index1hello")
+    await expect(page.locator("body")).to_have_text("index1hello")
+
+    await page.goto(server.PREFIX + "/index123hello")
+    await expect(page.locator("body")).to_have_text("index123hello")
diff --git a/tests/async/test_page_select_option.py b/tests/async/test_page_select_option.py
index e59c6a481..c5edf543d 100644
--- a/tests/async/test_page_select_option.py
+++ b/tests/async/test_page_select_option.py
@@ -45,6 +45,22 @@ async def test_select_option_should_select_single_option_by_label(
     assert await page.evaluate("result.onChange") == ["indigo"]
 
 
+async def test_select_option_should_select_single_option_by_empty_label(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+        <select>
+            <option value="indigo">Indigo</option>
+            <option value="violet"></option>
+        </select>
+    """
+    )
+    assert await page.locator("select").input_value() == "indigo"
+    await page.select_option("select", label="")
+    assert await page.locator("select").input_value() == "violet"
+
+
 async def test_select_option_should_select_single_option_by_handle(
     page: Page, server: Server
 ) -> None:
@@ -65,6 +81,14 @@ async def test_select_option_should_select_single_option_by_index(
     assert await page.evaluate("result.onChange") == ["brown"]
 
 
+async def test_select_option_should_select_single_option_by_index_0(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", index=0)
+    assert await page.evaluate("result.onInput") == ["black"]
+
+
 async def test_select_option_should_select_only_first_option(
     page: Page, server: Server
 ) -> None:
@@ -112,6 +136,23 @@ async def test_select_option_should_select_multiple_options_with_attributes(
     assert await page.evaluate("result.onChange") == ["blue", "gray", "green"]
 
 
+async def test_select_option_should_select_option_with_empty_value(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <select>
+            <option value="first">First</option>
+            <option value="">Second</option>
+        </select>
+    """
+    )
+    assert await page.locator("select").input_value() == "first"
+    await page.select_option("select", value="")
+    assert await page.locator("select").input_value() == ""
+
+
 async def test_select_option_should_respect_event_bubbling(
     page: Page, server: Server
 ) -> None:
diff --git a/tests/async/test_pdf.py b/tests/async/test_pdf.py
index 7e916dc11..93d1fcf8a 100644
--- a/tests/async/test_pdf.py
+++ b/tests/async/test_pdf.py
@@ -23,8 +23,8 @@
 pytestmark = pytest.mark.only_browser("chromium")
 
 
-async def test_should_be_able_to_save_pdf_file(page: Page, tmpdir: Path) -> None:
-    output_file = tmpdir / "foo.png"
+async def test_should_be_able_to_save_pdf_file(page: Page, tmp_path: Path) -> None:
+    output_file = tmp_path / "foo.png"
     await page.pdf(path=str(output_file))
     assert os.path.getsize(output_file) > 0
 
@@ -35,11 +35,11 @@ async def test_should_be_able_capture_pdf_without_path(page: Page) -> None:
 
 
 async def test_should_be_able_to_generate_outline(
-    page: Page, server: Server, tmpdir: Path
+    page: Page, server: Server, tmp_path: Path
 ) -> None:
     await page.goto(server.PREFIX + "/headings.html")
-    output_file_no_outline = tmpdir / "outputNoOutline.pdf"
-    output_file_outline = tmpdir / "outputOutline.pdf"
+    output_file_no_outline = tmp_path / "outputNoOutline.pdf"
+    output_file_outline = tmp_path / "outputOutline.pdf"
     await page.pdf(path=output_file_no_outline)
     await page.pdf(path=output_file_outline, tagged=True, outline=True)
     assert os.path.getsize(output_file_outline) > os.path.getsize(
diff --git a/tests/async/test_request_intercept.py b/tests/async/test_request_intercept.py
index 316e0b102..75746bbca 100644
--- a/tests/async/test_request_intercept.py
+++ b/tests/async/test_request_intercept.py
@@ -175,3 +175,17 @@ async def test_should_give_access_to_the_intercepted_response_body(
         route.fulfill(response=response),
         eval_task,
     )
+
+
+async def test_should_intercept_by_glob(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.route(
+        "http://localhos**?*oo",
+        lambda route: route.fulfill(body="intercepted", status=200),
+    )
+
+    result = await page.evaluate(
+        "url => fetch(url).then(r => r.text())", server.PREFIX + "/?foo"
+    )
+
+    assert result == "intercepted"
diff --git a/tests/async/test_resource_timing.py b/tests/async/test_resource_timing.py
index 2a14414df..a8481b8c8 100644
--- a/tests/async/test_resource_timing.py
+++ b/tests/async/test_resource_timing.py
@@ -15,7 +15,6 @@
 from typing import Dict
 
 import pytest
-from flaky import flaky
 
 from playwright.async_api import Browser, Page
 from tests.server import Server
@@ -33,7 +32,6 @@ async def test_should_work(page: Page, server: Server) -> None:
     assert timing["responseEnd"] < 10000
 
 
-@flaky
 async def test_should_work_for_subresource(
     page: Page, server: Server, is_win: bool, is_mac: bool, is_webkit: bool
 ) -> None:
@@ -51,7 +49,6 @@ async def test_should_work_for_subresource(
     assert timing["responseEnd"] < 10000
 
 
-@flaky  # Upstream flaky
 async def test_should_work_for_ssl(browser: Browser, https_server: Server) -> None:
     page = await browser.new_page(ignore_https_errors=True)
     async with page.expect_event("requestfinished") as request_info:
diff --git a/tests/async/test_route_web_socket.py b/tests/async/test_route_web_socket.py
new file mode 100644
index 000000000..465832adf
--- /dev/null
+++ b/tests/async/test_route_web_socket.py
@@ -0,0 +1,381 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import re
+from typing import Any, Awaitable, Callable, Literal, Tuple, Union
+
+from playwright.async_api import Frame, Page, WebSocketRoute
+from playwright.async_api._generated import Browser
+from tests.server import Server, WebSocketProtocol
+
+
+async def assert_equal(
+    actual_cb: Callable[[], Union[Any, Awaitable[Any]]], expected: Any
+) -> None:
+    __tracebackhide__ = True
+    start_time = asyncio.get_event_loop().time()
+    attempts = 0
+    while True:
+        actual = actual_cb()
+        if asyncio.iscoroutine(actual):
+            actual = await actual
+        if actual == expected:
+            return
+        attempts += 1
+        if asyncio.get_event_loop().time() - start_time > 5:
+            raise TimeoutError(f"Timed out after 10 seconds. Last actual was: {actual}")
+        await asyncio.sleep(0.2)
+
+
+async def setup_ws(
+    target: Union[Page, Frame],
+    port: int,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    await target.goto("about:blank")
+    await target.evaluate(
+        """({ port, binaryType }) => {
+    window.log = [];
+    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
+    window.ws.binaryType = binaryType;
+    window.ws.addEventListener('open', () => window.log.push('open'));
+    window.ws.addEventListener('close', event => window.log.push(`close code=${event.code} reason=${event.reason} wasClean=${event.wasClean}`));
+    window.ws.addEventListener('error', event => window.log.push(`error`));
+    window.ws.addEventListener('message', async event => {
+      let data;
+      if (typeof event.data === 'string')
+        data = event.data;
+      else if (event.data instanceof Blob)
+        data = 'blob:' + await event.data.text();
+      else
+        data = 'arraybuffer:' + await (new Blob([event.data])).text();
+      window.log.push(`message: data=${data} origin=${event.origin} lastEventId=${event.lastEventId}`);
+    });
+    window.wsOpened = new Promise(f => window.ws.addEventListener('open', () => f()));
+  }""",
+        {"port": port, "binaryType": protocol},
+    )
+
+
+async def test_should_work_with_ws_close(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.connect_to_server()
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+
+    ws_task = server.wait_for_web_socket()
+    await setup_ws(page, server.PORT, "blob")
+    ws = await ws_task
+
+    route = await future
+    route.send("hello")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    closed_promise: asyncio.Future[Tuple[int, str]] = asyncio.Future()
+    ws.events.once(
+        "close", lambda code, reason: closed_promise.set_result((code, reason))
+    )
+    await route.close(code=3009, reason="oops")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3009 reason=oops wasClean=true",
+        ],
+    )
+    assert await closed_promise == (3009, "oops")
+
+
+async def test_should_pattern_match(page: Page, server: Server) -> None:
+    await page.route_web_socket(
+        re.compile(r".*/ws$"), lambda ws: ws.connect_to_server()
+    )
+    await page.route_web_socket(
+        "**/mock-ws", lambda ws: ws.on_message(lambda message: ws.send("mock-response"))
+    )
+
+    ws_task = server.wait_for_web_socket()
+    await page.goto("about:blank")
+    await page.evaluate(
+        """async ({ port }) => {
+        window.log = [];
+        window.ws1 = new WebSocket('ws://localhost:' + port + '/ws');
+        window.ws1.addEventListener('message', event => window.log.push(`ws1:${event.data}`));
+        window.ws2 = new WebSocket('ws://localhost:' + port + '/something/something/mock-ws');
+        window.ws2.addEventListener('message', event => window.log.push(`ws2:${event.data}`));
+        await Promise.all([
+            new Promise(f => window.ws1.addEventListener('open', f)),
+            new Promise(f => window.ws2.addEventListener('open', f)),
+        ]);
+    }""",
+        {"port": server.PORT},
+    )
+
+    ws = await ws_task
+    ws.events.on("message", lambda payload, isBinary: ws.sendMessage(b"response"))
+
+    await page.evaluate("window.ws1.send('request')")
+    await assert_equal(lambda: page.evaluate("window.log"), ["ws1:response"])
+
+    await page.evaluate("window.ws2.send('request')")
+    await assert_equal(
+        lambda: page.evaluate("window.log"), ["ws1:response", "ws2:mock-response"]
+    )
+
+
+async def test_should_work_with_server(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        server = ws.connect_to_server()
+
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+                return
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                server.send("modified")
+                return
+            server.send(message)
+
+        ws.on_message(_ws_on_message)
+
+        def _server_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                ws.send("modified")
+                return
+            ws.send(message)
+
+        server.on_message(_server_on_message)
+        server.send("fake")
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+    ws_task = server.wait_for_web_socket()
+    log = []
+
+    def _once_web_socket_connection(ws: WebSocketProtocol) -> None:
+        ws.events.on(
+            "message", lambda data, is_binary: log.append(f"message: {data.decode()}")
+        )
+        ws.events.on(
+            "close",
+            lambda code, reason: log.append(f"close: code={code} reason={reason}"),
+        )
+
+    server.once_web_socket_connection(_once_web_socket_connection)
+
+    await setup_ws(page, server.PORT, "blob")
+    ws = await ws_task
+    await assert_equal(lambda: log, ["message: fake"])
+
+    ws.sendMessage(b"to-modify")
+    ws.sendMessage(b"to-block")
+    ws.sendMessage(b"pass-server")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.send('to-respond');
+        window.ws.send('to-modify');
+        window.ws.send('to-block');
+        window.ws.send('pass-client');
+    }"""
+    )
+    await assert_equal(
+        lambda: log, ["message: fake", "message: modified", "message: pass-client"]
+    )
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    route = await future
+    route.send("another")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.send('pass-client-2');
+    }"""
+    )
+    await assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.close(3009, 'problem');
+    }"""
+    )
+    await assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+            "close: code=3009 reason=problem",
+        ],
+    )
+
+
+async def test_should_work_without_server(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+
+        ws.on_message(_ws_on_message)
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+    await setup_ws(page, server.PORT, "blob")
+
+    await page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('to-respond');
+        window.ws.send('to-block');
+        window.ws.send('to-respond');
+    }"""
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    route = await future
+    route.send("another")
+    # wait for the message to be processed
+    await page.wait_for_timeout(100)
+    await route.close(code=3008, reason="oops")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3008 reason=oops wasClean=true",
+        ],
+    )
+
+
+async def test_should_work_with_base_url(browser: Browser, server: Server) -> None:
+    context = await browser.new_context(base_url=f"http://localhost:{server.PORT}")
+    page = await context.new_page()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.on_message(lambda message: ws.send(message))
+
+    await page.route_web_socket("/ws", _handle_ws)
+    await setup_ws(page, server.PORT, "blob")
+
+    await page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('echo');
+    }"""
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=echo origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+
+async def test_should_work_with_no_trailing_slash(page: Page, server: Server) -> None:
+    log: list[str] = []
+
+    async def handle_ws(ws: WebSocketRoute) -> None:
+        def on_message(message: Union[str, bytes]) -> None:
+            assert isinstance(message, str)
+            log.append(message)
+            ws.send("response")
+
+        ws.on_message(on_message)
+
+    # No trailing slash in the route pattern
+    await page.route_web_socket(f"ws://localhost:{server.PORT}", handle_ws)
+
+    await page.goto("about:blank")
+    await page.evaluate(
+        """({ port }) => {
+            window.log = [];
+            // No trailing slash in WebSocket URL
+            window.ws = new WebSocket('ws://localhost:' + port);
+            window.ws.addEventListener('message', event => window.log.push(event.data));
+        }""",
+        {"port": server.PORT},
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.ws.readyState"), 1  # WebSocket.OPEN
+    )
+    await page.evaluate("window.ws.send('query')")
+    await assert_equal(lambda: log, ["query"])
+    await assert_equal(lambda: page.evaluate("window.log"), ["response"])
diff --git a/tests/async/test_screenshot.py b/tests/async/test_screenshot.py
index 3cd536f96..36149225f 100644
--- a/tests/async/test_screenshot.py
+++ b/tests/async/test_screenshot.py
@@ -12,13 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from pathlib import Path
 from typing import Callable
 
+from PIL import Image
+
 from playwright.async_api import Page
 from tests.server import Server
 from tests.utils import must
 
 
+def assert_image_file_format(path: Path, image_format: str) -> None:
+    with Image.open(path) as img:
+        assert img.format == image_format
+
+
 async def test_should_screenshot_with_mask(
     page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
 ) -> None:
@@ -43,3 +51,29 @@ async def test_should_screenshot_with_mask(
         ),
         "mask-should-work-with-element-handle.png",
     )
+
+
+async def test_should_infer_screenshot_type_from_path(
+    page: Page, tmp_path: Path
+) -> None:
+    output_png_file = tmp_path / "foo.png"
+    await page.screenshot(path=output_png_file)
+    assert_image_file_format(output_png_file, "PNG")
+
+    output_jpeg_file = tmp_path / "bar.jpeg"
+    await page.screenshot(path=output_jpeg_file)
+    assert_image_file_format(output_jpeg_file, "JPEG")
+
+    output_jpg_file = tmp_path / "bar.jpg"
+    await page.screenshot(path=output_jpg_file)
+    assert_image_file_format(output_jpg_file, "JPEG")
+
+
+async def test_should_screenshot_with_type_argument(page: Page, tmp_path: Path) -> None:
+    output_jpeg_with_png_extension = tmp_path / "foo_jpeg.png"
+    await page.screenshot(path=output_jpeg_with_png_extension, type="jpeg")
+    assert_image_file_format(output_jpeg_with_png_extension, "JPEG")
+
+    output_png_with_jpeg_extension = tmp_path / "bar_png.jpeg"
+    await page.screenshot(path=output_png_with_jpeg_extension, type="png")
+    assert_image_file_format(output_png_with_jpeg_extension, "PNG")
diff --git a/tests/async/test_selector_generator.py b/tests/async/test_selector_generator.py
index 1239973a5..6668020da 100644
--- a/tests/async/test_selector_generator.py
+++ b/tests/async/test_selector_generator.py
@@ -40,7 +40,7 @@ async def test_should_use_data_test_id_in_strict_errors(
         """
         )
         with pytest.raises(Error) as exc_info:
-            await page.locator(".foo").hover(timeout=200)
+            await page.locator(".foo").hover()
         assert "strict mode violation" in exc_info.value.message
         assert '<div class="foo bar:0' in exc_info.value.message
         assert '<div class="foo bar:1' in exc_info.value.message
diff --git a/tests/async/test_selectors_misc.py b/tests/async/test_selectors_misc.py
index 5527d6ec8..5ad6c3519 100644
--- a/tests/async/test_selectors_misc.py
+++ b/tests/async/test_selectors_misc.py
@@ -12,6 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pytest
+
+from playwright._impl._browser import Browser
+from playwright._impl._errors import Error
+from playwright._impl._selectors import Selectors
 from playwright.async_api import Page
 
 
@@ -52,3 +57,26 @@ async def test_should_work_with_internal_and(page: Page) -> None:
             '.bar >> internal:and="span"', "els => els.map(e => e.textContent)"
         )
     ) == ["world2"]
+
+
+async def test_should_throw_already_registered_error_when_registering(
+    selectors: Selectors,
+    browser: Browser,
+) -> None:
+    create_tag_selector = """
+    () => ({
+        query(root, selector) {
+            return root.querySelector(selector);
+        },
+        queryAll(root, selector) {
+            return Array.from(root.querySelectorAll(selector));
+        }
+    })
+    """
+    name = f"alreadyRegistered-{browser.browser_type.name}"
+    await selectors.register(name, create_tag_selector)
+    with pytest.raises(
+        Error,
+        match=f'Selectors.register: "{name}" selector engine has been already registered',
+    ):
+        await selectors.register(name, create_tag_selector)
diff --git a/tests/async/test_tracing.py b/tests/async/test_tracing.py
index a9cfdfbcb..cbd282820 100644
--- a/tests/async/test_tracing.py
+++ b/tests/async/test_tracing.py
@@ -12,13 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import re
 from pathlib import Path
-from typing import Dict, List
-
-from playwright.async_api import Browser, BrowserContext, BrowserType, Page
+from typing import AsyncContextManager, Callable
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    Page,
+    Response,
+    expect,
+)
 from tests.server import Server
-from tests.utils import get_trace_actions, parse_trace
+
+from .conftest import TraceViewerPage
 
 
 async def test_browser_context_output_trace(
@@ -40,7 +49,7 @@ async def test_start_stop(browser: Browser) -> None:
 
 
 async def test_browser_context_should_not_throw_when_stopping_without_start_but_not_exporting(
-    context: BrowserContext, server: Server, tmp_path: Path
+    context: BrowserContext,
 ) -> None:
     await context.tracing.stop()
 
@@ -66,27 +75,60 @@ async def test_browser_context_output_trace_chunk(
 
 
 async def test_should_collect_sources(
-    context: BrowserContext, page: Page, server: Server, tmp_path: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     await context.tracing.start(sources=True)
     await page.goto(server.EMPTY_PAGE)
     await page.set_content("<button>Click</button>")
-    await page.click("button")
+
+    async def my_method_outer() -> None:
+        async def my_method_inner() -> None:
+            await page.get_by_text("Click").click()
+
+        await my_method_inner()
+
+    await my_method_outer()
     path = tmp_path / "trace.zip"
     await context.tracing.stop(path=path)
 
-    (resources, events) = parse_trace(path)
-    current_file_content = Path(__file__).read_bytes()
-    found_current_file = False
-    for name, resource in resources.items():
-        if resource == current_file_content:
-            found_current_file = True
-            break
-    assert found_current_file
+    async with show_trace_viewer(path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        await trace_viewer.show_source_tab()
+        # Check that stack frames are shown (they might be anonymous in Python)
+        await expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"my_method_inner"),
+                re.compile(r"my_method_outer"),
+                re.compile(r"test_should_collect_sources"),
+            ]
+        )
+
+        await trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        await expect(
+            trace_viewer.page.locator(".source-tab-file-name")
+        ).to_have_attribute("title", re.compile(r".*test_.*\.py"))
+        await expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
 
 
 async def test_should_collect_trace_with_resources_but_no_js(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     await context.tracing.start(screenshots=True, snapshots=True)
     await page.goto(server.PREFIX + "/frames/frame.html")
@@ -94,95 +136,117 @@ async def test_should_collect_trace_with_resources_but_no_js(
     await page.click('"Click"')
     await page.mouse.move(20, 20)
     await page.mouse.dblclick(30, 30)
+    await page.request.get(server.EMPTY_PAGE)
     await page.keyboard.insert_text("abc")
     await page.wait_for_timeout(2000)  # Give it some time to produce screenshots.
-    await page.route(
-        "**/empty.html", lambda route: route.continue_()
-    )  # should produce a route.continue_ entry.
+    await page.route("**/empty.html", lambda route: route.continue_())
     await page.goto(server.EMPTY_PAGE)
-    await page.goto(
-        server.PREFIX + "/one-style.html"
-    )  # should not produce a route.continue_ entry since we continue all routes if no match.
+    await page.goto(server.PREFIX + "/one-style.html")
     await page.close()
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     await context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.click",
-        "Mouse.move",
-        "Mouse.dblclick",
-        "Keyboard.insert_text",
-        "Page.wait_for_timeout",
-        "Page.route",
-        "Page.goto",
-        "Route.continue_",
-        "Page.goto",
-        "Page.close",
-    ]
-
-    assert len(list(filter(lambda e: e["type"] == "frame-snapshot", events))) >= 1
-    assert len(list(filter(lambda e: e["type"] == "screencast-frame", events))) >= 1
-    style = list(
-        filter(
-            lambda e: e["type"] == "resource-snapshot"
-            and e["snapshot"]["request"]["url"].endswith("style.css"),
-            events,
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/frames/frame\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+                re.compile(r"Mouse move"),
+                re.compile(r"Double click"),
+                re.compile(r"GET \"/empty\.html\""),
+                re.compile(r'Insert "abc"'),
+                re.compile(r"Wait for timeout"),
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Navigate to "/one-style\.html"'),
+                re.compile(r"Close"),
+            ]
         )
-    )[0]
-    assert style
-    assert style["snapshot"]["response"]["content"]["_sha1"]
-    script = list(
-        filter(
-            lambda e: e["type"] == "resource-snapshot"
-            and e["snapshot"]["request"]["url"].endswith("script.js"),
-            events,
+
+        await trace_viewer.select_action("Set content")
+        await expect(
+            trace_viewer.page.locator(".browser-frame-address-bar")
+        ).to_have_text(server.PREFIX + "/frames/frame.html")
+        frame = await trace_viewer.snapshot_frame("Set content", 0, False)
+        await expect(frame.locator("button")).to_have_text("Click")
+
+
+async def test_should_correctly_determine_sync_apiname(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable,
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+
+    received_response: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handle_response(response: Response) -> None:
+        await response.request.all_headers()
+        await response.text()
+        received_response.set_result(None)
+
+    page.once("response", _handle_response)
+    await page.goto(server.PREFIX + "/grid.html")
+    await received_response
+    await page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_file_path)
+
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/grid\.html"'),
+                re.compile(r"Close"),
+            ]
         )
-    )[0]
-    assert script
-    assert script["snapshot"]["response"]["content"].get("_sha1") is None
 
 
 async def test_should_collect_two_traces(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     await context.tracing.start(screenshots=True, snapshots=True)
     await page.goto(server.EMPTY_PAGE)
     await page.set_content("<button>Click</button>")
     await page.click('"Click"')
-    tracing1_path = tmpdir / "trace1.zip"
+    tracing1_path = tmp_path / "trace1.zip"
     await context.tracing.stop(path=tracing1_path)
 
     await context.tracing.start(screenshots=True, snapshots=True)
     await page.dblclick('"Click"')
     await page.close()
-    tracing2_path = tmpdir / "trace2.zip"
+    tracing2_path = tmp_path / "trace2.zip"
     await context.tracing.stop(path=tracing2_path)
 
-    (_, events) = parse_trace(tracing1_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.click",
-    ]
-
-    (_, events) = parse_trace(tracing2_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == ["Page.dblclick", "Page.close"]
-
+    async with show_trace_viewer(tracing1_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
 
-async def test_should_not_throw_when_stopping_without_start_but_not_exporting(
-    context: BrowserContext,
-) -> None:
-    await context.tracing.stop()
+    async with show_trace_viewer(tracing2_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Double click"),
+                re.compile(r"Close"),
+            ]
+        )
 
 
 async def test_should_work_with_playwright_context_managers(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     await context.tracing.start(screenshots=True, snapshots=True)
     await page.goto(server.EMPTY_PAGE)
@@ -194,24 +258,29 @@ async def test_should_work_with_playwright_context_managers(
 
     async with page.expect_popup():
         await page.evaluate("window._popup = window.open(document.location.href)")
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     await context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.expect_console_message",
-        "Page.evaluate",
-        "Page.click",
-        "Page.expect_popup",
-        "Page.evaluate",
-    ]
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r'Wait for event "page\.expect_event\(console\)"'),
+                re.compile(r"Evaluate"),
+                re.compile(r"Click"),
+                re.compile(r'Wait for event "page\.expect_event\(popup\)"'),
+                re.compile(r"Evaluate"),
+            ]
+        )
 
 
 async def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
     await context.tracing.start(screenshots=True, snapshots=True)
 
@@ -219,67 +288,102 @@ async def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
     await page.wait_for_load_state("load")
     await page.wait_for_load_state("load")
 
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     await context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.wait_for_load_state",
-        "Page.wait_for_load_state",
-    ]
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+            ]
+        )
 
 
 async def test_should_respect_traces_dir_and_name(
     browser_type: BrowserType,
     server: Server,
-    tmpdir: Path,
-    launch_arguments: Dict,
+    tmp_path: Path,
+    launch_arguments: dict,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
 ) -> None:
-    traces_dir = tmpdir / "traces"
+    traces_dir = tmp_path / "traces"
     browser = await browser_type.launch(traces_dir=traces_dir, **launch_arguments)
     context = await browser.new_context()
     page = await context.new_page()
 
     await context.tracing.start(name="name1", snapshots=True)
     await page.goto(server.PREFIX + "/one-style.html")
-    await context.tracing.stop_chunk(path=tmpdir / "trace1.zip")
+    await context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
     assert (traces_dir / "name1.trace").exists()
     assert (traces_dir / "name1.network").exists()
 
     await context.tracing.start_chunk(name="name2")
     await page.goto(server.PREFIX + "/har.html")
-    await context.tracing.stop(path=tmpdir / "trace2.zip")
+    await context.tracing.stop(path=tmp_path / "trace2.zip")
     assert (traces_dir / "name2.trace").exists()
     assert (traces_dir / "name2.network").exists()
 
     await browser.close()
 
-    def resource_names(resources: Dict[str, bytes]) -> List[str]:
-        return sorted(
+    async with show_trace_viewer(tmp_path / "trace1.zip") as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile('Navigate to "/one-style\\.html"'),
+            ]
+        )
+        frame = await trace_viewer.snapshot_frame(
+            'Navigate to "/one-style.html"', 0, False
+        )
+        await expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        await expect(frame.locator("body")).to_have_text("hello, world!")
+
+    async with show_trace_viewer(tmp_path / "trace2.zip") as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
             [
-                re.sub(r"^resources/.*\.(html|css)$", r"resources/XXX.\g<1>", file)
-                for file in resources.keys()
+                re.compile(r'Navigate to "/har\.html"'),
             ]
         )
+        frame = await trace_viewer.snapshot_frame('Navigate to "/har.html"', 0, False)
+        await expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        await expect(frame.locator("body")).to_have_text("hello, world!")
 
-    (resources, events) = parse_trace(tmpdir / "trace1.zip")
-    assert get_trace_actions(events) == ["Page.goto"]
-    assert resource_names(resources) == [
-        "resources/XXX.css",
-        "resources/XXX.html",
-        "trace.network",
-        "trace.stacks",
-        "trace.trace",
-    ]
-
-    (resources, events) = parse_trace(tmpdir / "trace2.zip")
-    assert get_trace_actions(events) == ["Page.goto"]
-    assert resource_names(resources) == [
-        "resources/XXX.css",
-        "resources/XXX.html",
-        "resources/XXX.html",
-        "trace.network",
-        "trace.stacks",
-        "trace.trace",
-    ]
+
+async def test_should_show_tracing_group_in_action_list(
+    context: BrowserContext,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start()
+    page = await context.new_page()
+
+    await context.tracing.group("outer group")
+    await page.goto("data:text/html,<!DOCTYPE html><body><div>Hello world</div></body>")
+    await context.tracing.group("inner group 1")
+    await page.locator("body").click()
+    await context.tracing.group_end()
+    await context.tracing.group("inner group 2")
+    await page.get_by_text("Hello").is_visible()
+    await context.tracing.group_end()
+    await context.tracing.group_end()
+
+    trace_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_path)
+
+    async with show_trace_viewer(trace_path) as trace_viewer:
+        await trace_viewer.expand_action("inner group 1")
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Create page"),
+                re.compile(r"outer group"),
+                re.compile(r"Navigate to \"data:\""),
+                re.compile(r"inner group 1"),
+                re.compile(r"Click"),
+                re.compile(r"inner group 2"),
+            ]
+        )
diff --git a/tests/async/test_unroute_behavior.py b/tests/async/test_unroute_behavior.py
index 036423cdc..ff737eaab 100644
--- a/tests/async/test_unroute_behavior.py
+++ b/tests/async/test_unroute_behavior.py
@@ -451,3 +451,59 @@ async def _goto_ignore_exceptions() -> None:
     await page.close()
     # Should not throw.
     await route.fulfill()
+
+
+async def test_should_not_continue_requests_in_flight_page(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+
+    async def handle(route: Route) -> None:
+        route_future.set_result(route)
+        await asyncio.sleep(3)
+        await route.fulfill(status=200)
+
+    async def _evaluate_ignore_exceptions() -> None:
+        try:
+            await page.evaluate("() => fetch('/')")
+        except Error:
+            pass
+
+    await page.route(
+        "**/*",
+        handle,
+    )
+
+    asyncio.create_task(_evaluate_ignore_exceptions())
+    await route_future
+    await page.unroute_all(behavior="wait")
+
+
+async def test_should_not_continue_requests_in_flight_context(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+
+    async def handle(route: Route) -> None:
+        route_future.set_result(route)
+        await asyncio.sleep(3)
+        await route.fulfill(status=200)
+
+    async def _evaluate_ignore_exceptions() -> None:
+        try:
+            await page.evaluate("() => fetch('/')")
+        except Error:
+            pass
+
+    await context.route(
+        "**/*",
+        handle,
+    )
+
+    asyncio.create_task(_evaluate_ignore_exceptions())
+    await route_future
+    await context.unroute_all(behavior="wait")
diff --git a/tests/async/test_video.py b/tests/async/test_video.py
index b0ab4c529..08d757794 100644
--- a/tests/async/test_video.py
+++ b/tests/async/test_video.py
@@ -21,37 +21,37 @@
 
 
 async def test_should_expose_video_path(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
-    page = await browser.new_page(record_video_dir=tmpdir)
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
     assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     await page.context.close()
 
 
 async def test_short_video_should_throw(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
-    page = await browser.new_page(record_video_dir=tmpdir)
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
     assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     await page.wait_for_timeout(1000)
     await page.context.close()
     assert os.path.exists(path)
 
 
 async def test_short_video_should_throw_persistent_context(
-    browser_type: BrowserType, tmpdir: Path, launch_arguments: Dict, server: Server
+    browser_type: BrowserType, tmp_path: Path, launch_arguments: Dict, server: Server
 ) -> None:
     context = await browser_type.launch_persistent_context(
-        str(tmpdir),
+        str(tmp_path),
         **launch_arguments,
         viewport={"width": 320, "height": 240},
-        record_video_dir=str(tmpdir) + "1",
+        record_video_dir=str(tmp_path) + "1",
     )
     page = context.pages[0]
     await page.goto(server.PREFIX + "/grid.html")
@@ -60,16 +60,16 @@ async def test_short_video_should_throw_persistent_context(
 
     assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
 
 
 async def test_should_not_error_if_page_not_closed_before_save_as(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
-    page = await browser.new_page(record_video_dir=tmpdir)
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
     await page.wait_for_timeout(1000)  # make sure video has some data
-    out_path = tmpdir / "some-video.webm"
+    out_path = tmp_path / "some-video.webm"
     assert page.video
     saved = page.video.save_as(out_path)
     await page.close()
@@ -79,7 +79,7 @@ async def test_should_not_error_if_page_not_closed_before_save_as(
 
 
 async def test_should_be_None_if_not_recording(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
     page = await browser.new_page()
     assert page.video is None
diff --git a/tests/async/test_websocket.py b/tests/async/test_websocket.py
index 9b006f15d..c4729a4a5 100644
--- a/tests/async/test_websocket.py
+++ b/tests/async/test_websocket.py
@@ -16,7 +16,6 @@
 from typing import Union
 
 import pytest
-from flaky import flaky
 
 from playwright.async_api import Error, Page, WebSocket
 from tests.server import Server, WebSocketProtocol
@@ -151,7 +150,6 @@ def on_web_socket(ws: WebSocket) -> None:
     assert received == ["incoming", b"\x04\x02"]
 
 
-@flaky
 async def test_should_reject_wait_for_event_on_close_and_error(
     page: Page, server: Server
 ) -> None:
@@ -172,7 +170,7 @@ async def test_should_reject_wait_for_event_on_close_and_error(
 
 
 async def test_should_emit_error_event(
-    page: Page, server: Server, browser_name: str
+    page: Page, server: Server, browser_name: str, browser_channel: str
 ) -> None:
     future: "asyncio.Future[str]" = asyncio.Future()
 
@@ -194,4 +192,4 @@ def _on_websocket(websocket: WebSocket) -> None:
     if browser_name == "firefox":
         assert err == "CLOSE_ABNORMAL"
     else:
-        assert ": 404" in err
+        assert ("" if browser_channel == "msedge" else ": 404") in err
diff --git a/tests/async/test_worker.py b/tests/async/test_worker.py
index 996404b6e..4c2e4ebeb 100644
--- a/tests/async/test_worker.py
+++ b/tests/async/test_worker.py
@@ -16,7 +16,6 @@
 from asyncio.futures import Future
 
 import pytest
-from flaky import flaky
 
 from playwright.async_api import Browser, ConsoleMessage, Error, Page, Worker
 from tests.server import Server
@@ -107,7 +106,6 @@ async def test_workers_should_report_errors(page: Page) -> None:
     assert "this is my error" in error_log.message
 
 
-@flaky  # Upstream flaky
 async def test_workers_should_clear_upon_navigation(server: Server, page: Page) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_event("worker") as event_info:
@@ -123,7 +121,6 @@ async def test_workers_should_clear_upon_navigation(server: Server, page: Page)
     assert len(page.workers) == 0
 
 
-@flaky  # Upstream flaky
 async def test_workers_should_clear_upon_cross_process_navigation(
     server: Server, page: Page
 ) -> None:
@@ -151,9 +148,10 @@ async def test_workers_should_report_network_activity(
         await page.goto(server.PREFIX + "/worker/worker.html")
     worker = await worker_info.value
     url = server.PREFIX + "/one-style.css"
-    async with page.expect_request(url) as request_info, page.expect_response(
-        url
-    ) as response_info:
+    async with (
+        page.expect_request(url) as request_info,
+        page.expect_response(url) as response_info,
+    ):
         await worker.evaluate(
             "url => fetch(url).then(response => response.text()).then(console.log)", url
         )
@@ -173,9 +171,10 @@ async def test_workers_should_report_network_activity_on_worker_creation(
     # Chromium needs waitForDebugger enabled for this one.
     await page.goto(server.EMPTY_PAGE)
     url = server.PREFIX + "/one-style.css"
-    async with page.expect_request(url) as request_info, page.expect_response(
-        url
-    ) as response_info:
+    async with (
+        page.expect_request(url) as request_info,
+        page.expect_response(url) as response_info,
+    ):
         await page.evaluate(
             """url => new Worker(URL.createObjectURL(new Blob([`
         fetch("${url}").then(response => response.text()).then(console.log);
@@ -190,7 +189,7 @@ async def test_workers_should_report_network_activity_on_worker_creation(
 
 
 async def test_workers_should_format_number_using_context_locale(
-    browser: Browser, server: Server
+    browser: Browser, server: Server, browser_name: str
 ) -> None:
     context = await browser.new_context(locale="ru-RU")
     page = await context.new_page()
@@ -200,5 +199,46 @@ async def test_workers_should_format_number_using_context_locale(
             "() => new Worker(URL.createObjectURL(new Blob(['console.log(1)'], {type: 'application/javascript'})))"
         )
     worker = await worker_info.value
-    assert await worker.evaluate("() => (10000.20).toLocaleString()") == "10\u00A0000,2"
+    # https://github.com/microsoft/playwright/issues/38919
+    expected = "10,000.2" if browser_name == "firefox" else "10\u00a0000,2"
+    assert await worker.evaluate("() => (10000.20).toLocaleString()") == expected
     await context.close()
+
+
+async def test_worker_should_report_console_event(page: Page) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.evaluate(
+            "() => { window.worker = new Worker(URL.createObjectURL(new Blob(['42'], { type: 'application/javascript' }))); }"
+        )
+    worker = await worker_info.value
+
+    async with worker.expect_event("console") as message1_info:
+        async with page.expect_console_message() as message2_info:
+            async with page.context.expect_console_message() as message3_info:
+                await worker.evaluate("() => { console.log('hello from worker'); }")
+
+    message1 = await message1_info.value
+    message2 = await message2_info.value
+    message3 = await message3_info.value
+
+    assert message1.text == "hello from worker"
+    assert message1 is message2
+    assert message1 is message3
+    assert message1.worker is worker
+
+
+async def test_worker_should_report_console_event_when_not_listening_on_page_or_context(
+    page: Page,
+) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.evaluate(
+            "() => { window.worker = new Worker(URL.createObjectURL(new Blob(['42'], { type: 'application/javascript' }))); }"
+        )
+    worker = await worker_info.value
+
+    async with worker.expect_event("console") as message_info:
+        await worker.evaluate("() => { console.log('hello from worker'); }")
+
+    message = await message_info.value
+    assert message.text == "hello from worker"
+    assert message.worker is worker
diff --git a/tests/common/test_signals.py b/tests/common/test_signals.py
index 472e74042..ba600b44d 100644
--- a/tests/common/test_signals.py
+++ b/tests/common/test_signals.py
@@ -27,6 +27,10 @@
 def _test_signals_async(
     browser_name: str, launch_arguments: Dict, wait_queue: "multiprocessing.Queue[str]"
 ) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
     os.setpgrp()
     sigint_received = False
 
@@ -46,7 +50,6 @@ async def main() -> None:
         page = await context.new_page()
         notified = False
         try:
-            nonlocal sigint_received
             while not sigint_received:
                 if not notified:
                     wait_queue.put("ready")
@@ -67,6 +70,10 @@ async def main() -> None:
 def _test_signals_sync(
     browser_name: str, launch_arguments: Dict, wait_queue: "multiprocessing.Queue[str]"
 ) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
     os.setpgrp()
     sigint_received = False
 
@@ -103,6 +110,10 @@ def my_sig_handler(signum: int, frame: Any) -> None:
 def _create_signals_test(
     target: Any, browser_name: str, launch_arguments: Dict
 ) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
     wait_queue: "multiprocessing.Queue[str]" = multiprocessing.Queue()
     process = multiprocessing.Process(
         target=target, args=[browser_name, launch_arguments, wait_queue]
diff --git a/tests/conftest.py b/tests/conftest.py
index 770bd9c30..2b533f15f 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
 import inspect
 import io
 import json
@@ -20,7 +19,7 @@
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, AsyncGenerator, Callable, Dict, Generator, List, Optional, cast
+from typing import Any, Callable, Dict, Generator, List, Optional, cast
 
 import pytest
 from PIL import Image
@@ -35,19 +34,17 @@
 _dirname = get_file_dirname()
 
 
+def pytest_configure(config: pytest.Config) -> None:
+    if os.environ.get("CI"):
+        config.option.reruns = 3
+
+
 def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     if "browser_name" in metafunc.fixturenames:
         browsers = metafunc.config.option.browser or ["chromium", "firefox", "webkit"]
         metafunc.parametrize("browser_name", browsers, scope="session")
 
 
-@pytest.fixture(scope="session")
-def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
-    loop = asyncio.get_event_loop()
-    yield loop
-    loop.close()
-
-
 @pytest.fixture(scope="session")
 def assetdir() -> Path:
     return _dirname / "assets"
@@ -60,10 +57,12 @@ def headless(pytestconfig: pytest.Config) -> bool:
 
 @pytest.fixture(scope="session")
 def launch_arguments(pytestconfig: pytest.Config, headless: bool) -> Dict:
-    return {
+    args: Dict = {
         "headless": headless,
-        "channel": pytestconfig.getoption("--browser-channel"),
     }
+    if pytestconfig.getoption("--browser-channel"):
+        args["channel"] = pytestconfig.getoption("--browser-channel")
+    return args
 
 
 @pytest.fixture
@@ -77,7 +76,7 @@ def https_server() -> Generator[Server, None, None]:
 
 
 @pytest.fixture(autouse=True, scope="session")
-async def start_server() -> AsyncGenerator[None, None]:
+def start_server() -> Generator[None, None, None]:
     test_server.start()
     yield
     test_server.stop()
@@ -99,6 +98,14 @@ def browser_channel(pytestconfig: pytest.Config) -> Optional[str]:
     return cast(Optional[str], pytestconfig.getoption("--browser-channel"))
 
 
+@pytest.fixture(scope="session")
+def is_headless_shell(browser_name: str, browser_channel: str, headless: bool) -> bool:
+    return browser_name == "chromium" and (
+        browser_channel == "chromium-headless-shell"
+        or (not browser_channel and headless)
+    )
+
+
 @pytest.fixture(scope="session")
 def is_webkit(browser_name: str) -> bool:
     return browser_name == "webkit"
diff --git a/tests/server.py b/tests/server.py
index 23d7ff374..d69176950 100644
--- a/tests/server.py
+++ b/tests/server.py
@@ -17,6 +17,7 @@
 import contextlib
 import gzip
 import mimetypes
+import pathlib
 import socket
 import threading
 from contextlib import closing
@@ -32,6 +33,7 @@
     Set,
     Tuple,
     TypeVar,
+    Union,
     cast,
 )
 from urllib.parse import urlparse
@@ -39,6 +41,7 @@
 from autobahn.twisted.resource import WebSocketResource
 from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol
 from OpenSSL import crypto
+from pyee import EventEmitter
 from twisted.internet import reactor as _twisted_reactor
 from twisted.internet import ssl
 from twisted.internet.selectreactor import SelectReactor
@@ -83,8 +86,7 @@ def process(self) -> None:
             self.content.seek(0, 0)
         else:
             self.post_body = None
-        uri = urlparse(self.uri.decode())
-        path = uri.path
+        path = urlparse(self.uri.decode()).path
 
         request_subscriber = server.request_subscribers.get(path)
         if request_subscriber:
@@ -108,6 +110,7 @@ def process(self) -> None:
             if not creds_correct:
                 self.setHeader(b"www-authenticate", 'Basic realm="Secure Area"')
                 self.setResponseCode(HTTPStatus.UNAUTHORIZED)
+                self.write(b"HTTP Error 401 Unauthorized: Access is denied")
                 self.finish()
                 return
         if server.csp.get(path):
@@ -115,15 +118,23 @@ def process(self) -> None:
         if server.routes.get(path):
             server.routes[path](self)
             return
+
+        self._serve_file(server.static_path / path[1:], path)
+
+    def serve_file(self, path: pathlib.Path) -> None:
+        return self._serve_file(path, urlparse(self.uri.decode()).path)
+
+    def _serve_file(self, path: pathlib.Path, request_path: str) -> None:
+        server = self.channel.factory.server_instance
         file_content = None
         try:
-            file_content = (server.static_path / path[1:]).read_bytes()
+            file_content = path.read_bytes()
             content_type = mimetypes.guess_type(path)[0]
             if content_type and content_type.startswith("text/"):
                 content_type += "; charset=utf-8"
             self.setHeader(b"Content-Type", content_type)
             self.setHeader(b"Cache-Control", "no-cache, no-store")
-            if path in server.gzip_routes:
+            if request_path in server.gzip_routes:
                 self.setHeader("Content-Encoding", "gzip")
                 self.write(gzip.compress(file_content))
             else:
@@ -131,7 +142,10 @@ def process(self) -> None:
                 self.write(file_content)
             self.setResponseCode(HTTPStatus.OK)
         except (FileNotFoundError, IsADirectoryError, PermissionError):
+            self.setHeader(b"Content-Type", "text/plain")
             self.setResponseCode(HTTPStatus.NOT_FOUND)
+            if self.method != "HEAD":
+                self.write(f"File not found: {path}".encode())
         self.finish()
 
 
@@ -167,7 +181,7 @@ def __repr__(self) -> str:
     def listen(self, factory: TestServerFactory) -> None:
         pass
 
-    def start(self) -> None:
+    def start(self, static_path: pathlib.Path = _dirname / "assets") -> None:
         request_subscribers: Dict[str, asyncio.Future] = {}
         auth: Dict[str, Tuple[str, str]] = {}
         csp: Dict[str, str] = {}
@@ -179,13 +193,13 @@ def start(self) -> None:
         self.routes = routes
         self._ws_handlers: List[Callable[["WebSocketProtocol"], None]] = []
         self.gzip_routes = gzip_routes
-        self.static_path = _dirname / "assets"
+        self.static_path = static_path
         factory = TestServerFactory()
         factory.server_instance = self
 
         ws_factory = WebSocketServerFactory()
         ws_factory.protocol = WebSocketProtocol
-        ws_factory.server_instance = self
+        setattr(ws_factory, "server_instance", self)
         self._ws_resource = WebSocketResource(ws_factory)
 
         self.listen(factory)
@@ -197,6 +211,11 @@ async def wait_for_request(self, path: str) -> TestServerRequest:
         self.request_subscribers[path] = future
         return await future
 
+    def wait_for_web_socket(self) -> 'asyncio.Future["WebSocketProtocol"]':
+        future: asyncio.Future[WebSocketProtocol] = asyncio.Future()
+        self.once_web_socket_connection(future.set_result)
+        return future
+
     @contextlib.contextmanager
     def expect_request(
         self, path: str
@@ -211,6 +230,20 @@ def done_cb(task: asyncio.Task) -> None:
         future.add_done_callback(done_cb)
         yield cb_wrapper
 
+    @contextlib.contextmanager
+    def expect_websocket(
+        self,
+    ) -> Generator[ExpectResponse["WebSocketProtocol"], None, None]:
+        future = self.wait_for_web_socket()
+
+        cb_wrapper: ExpectResponse["WebSocketProtocol"] = ExpectResponse()
+
+        def done_cb(_: asyncio.Future) -> None:
+            cb_wrapper._value = future.result()
+
+        future.add_done_callback(done_cb)
+        yield cb_wrapper
+
     def set_auth(self, path: str, username: str, password: str) -> None:
         self.auth[path] = (username, password)
 
@@ -251,17 +284,34 @@ def once_web_socket_connection(
 
 
 class HTTPServer(Server):
+    def __init__(self) -> None:
+        self._listeners: list[Any] = []
+        super().__init__()
+
     def listen(self, factory: http.HTTPFactory) -> None:
-        reactor.listenTCP(self.PORT, factory, interface="127.0.0.1")
+        self._listeners.append(
+            reactor.listenTCP(self.PORT, factory, interface="127.0.0.1")
+        )
         try:
-            reactor.listenTCP(self.PORT, factory, interface="::1")
+            self._listeners.append(
+                reactor.listenTCP(self.PORT, factory, interface="::1")
+            )
         except Exception:
             pass
 
+    def stop(self) -> None:
+        for listener in self._listeners:
+            listener.stopListening()
+        self._listeners.clear()
+
 
 class HTTPSServer(Server):
     protocol = "https"
 
+    def __init__(self) -> None:
+        self._listeners: list[Any] = []
+        super().__init__()
+
     def listen(self, factory: http.HTTPFactory) -> None:
         cert = ssl.PrivateCertificate.fromCertificateAndKeyPair(
             ssl.Certificate.loadPEM(
@@ -272,17 +322,41 @@ def listen(self, factory: http.HTTPFactory) -> None:
             ),
         )
         contextFactory = cert.options()
-        reactor.listenSSL(self.PORT, factory, contextFactory, interface="127.0.0.1")
+        self._listeners.append(
+            reactor.listenSSL(self.PORT, factory, contextFactory, interface="127.0.0.1")
+        )
         try:
-            reactor.listenSSL(self.PORT, factory, contextFactory, interface="::1")
+            self._listeners.append(
+                reactor.listenSSL(self.PORT, factory, contextFactory, interface="::1")
+            )
         except Exception:
             pass
 
+    def stop(self) -> None:
+        for listener in self._listeners:
+            listener.stopListening()
+        self._listeners.clear()
+
 
 class WebSocketProtocol(WebSocketServerProtocol):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.events = EventEmitter()
+
+    def onClose(self, wasClean: bool, code: int, reason: str) -> None:
+        super().onClose(wasClean, code, reason)
+        self.events.emit(
+            "close",
+            code,
+            reason,
+        )
+
+    def onMessage(self, payload: Union[str, bytes], isBinary: bool) -> None:
+        self.events.emit("message", payload, isBinary)
+
     def onOpen(self) -> None:
-        for handler in self.factory.server_instance._ws_handlers.copy():
-            self.factory.server_instance._ws_handlers.remove(handler)
+        for handler in getattr(self.factory, "server_instance")._ws_handlers.copy():
+            getattr(self.factory, "server_instance")._ws_handlers.remove(handler)
             handler(self)
 
 
diff --git a/tests/sync/conftest.py b/tests/sync/conftest.py
index b825ca2fe..58193c0de 100644
--- a/tests/sync/conftest.py
+++ b/tests/sync/conftest.py
@@ -14,20 +14,26 @@
 
 
 import asyncio
+from contextlib import contextmanager
+from pathlib import Path
 from typing import Any, Callable, Dict, Generator, List
 
 import pytest
 from greenlet import greenlet
 
+from playwright._impl._driver import compute_driver_executable
 from playwright.sync_api import (
     Browser,
     BrowserContext,
     BrowserType,
+    FrameLocator,
+    Locator,
     Page,
     Playwright,
     Selectors,
     sync_playwright,
 )
+from tests.server import HTTPServer
 
 from .utils import Utils
 from .utils import utils as utils_object
@@ -121,3 +127,71 @@ async def task() -> None:
         return list(map(lambda action: results[action], actions))
 
     yield _sync_gather_impl
+
+
+class TraceViewerPage:
+    def __init__(self, page: Page):
+        self.page = page
+
+    @property
+    def actions_tree(self) -> Locator:
+        return self.page.get_by_test_id("actions-tree")
+
+    @property
+    def action_titles(self) -> Locator:
+        return self.page.locator(".action-title")
+
+    @property
+    def stack_frames(self) -> Locator:
+        return self.page.get_by_role("list", name="Stack trace").get_by_role("listitem")
+
+    def select_action(self, title: str, ordinal: int = 0) -> None:
+        self.page.locator(".action-title", has_text=title).nth(ordinal).click()
+
+    def select_snapshot(self, name: str) -> None:
+        self.page.click(f'.snapshot-tab .tabbed-pane-tab-label:has-text("{name}")')
+
+    def snapshot_frame(
+        self, action_name: str, ordinal: int = 0, has_subframe: bool = False
+    ) -> FrameLocator:
+        self.select_action(action_name, ordinal)
+        expected_frames = 4 if has_subframe else 3
+        while len(self.page.frames) < expected_frames:
+            self.page.wait_for_event("frameattached")
+        return self.page.frame_locator("iframe.snapshot-visible[name=snapshot]")
+
+    def show_source_tab(self) -> None:
+        self.page.click("text='Source'")
+
+    def expand_action(self, title: str, ordinal: int = 0) -> None:
+        self.actions_tree.locator(".tree-view-entry", has_text=title).nth(
+            ordinal
+        ).locator(".codicon-chevron-right").click()
+
+
+@pytest.fixture
+def show_trace_viewer(browser: Browser) -> Generator[Callable, None, None]:
+    """Fixture that provides a function to show trace viewer for a trace file."""
+
+    @contextmanager
+    def _show_trace_viewer(
+        trace_path: Path,
+    ) -> Generator[TraceViewerPage, None, None]:
+        trace_viewer_path = (
+            Path(compute_driver_executable()[0]) / "../package/lib/vite/traceViewer"
+        ).resolve()
+
+        server = HTTPServer()
+        server.start(trace_viewer_path)
+        server.set_route("/trace.zip", lambda request: request.serve_file(trace_path))
+
+        page = browser.new_page()
+
+        try:
+            page.goto(f"{server.PREFIX}/index.html?trace={server.PREFIX}/trace.zip")
+            yield TraceViewerPage(page)
+        finally:
+            page.close()
+            server.stop()
+
+    yield _show_trace_viewer
diff --git a/tests/sync/test_accessibility.py b/tests/sync/test_accessibility.py
deleted file mode 100644
index d7516d6d9..000000000
--- a/tests/sync/test_accessibility.py
+++ /dev/null
@@ -1,389 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import sys
-
-import pytest
-
-from playwright.sync_api import Page
-
-
-def test_accessibility_should_work(
-    page: Page, is_firefox: bool, is_chromium: bool
-) -> None:
-    page.set_content(
-        """<head>
-      <title>Accessibility Test</title>
-    </head>
-    <body>
-      <h1>Inputs</h1>
-      <input placeholder="Empty input" autofocus />
-      <input placeholder="readonly input" readonly />
-      <input placeholder="disabled input" disabled />
-      <input aria-label="Input with whitespace" value="  " />
-      <input value="value only" />
-      <input aria-placeholder="placeholder" value="and a value" />
-      <div aria-hidden="true" id="desc">This is a description!</div>
-      <input aria-placeholder="placeholder" value="and a value" aria-describedby="desc" />
-    </body>"""
-    )
-    # autofocus happens after a delay in chrome these days
-    page.wait_for_function("document.activeElement.hasAttribute('autofocus')")
-
-    if is_firefox:
-        golden = {
-            "role": "document",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                },  # firefox doesn't use aria-placeholder for the name
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },  # and here
-            ],
-        }
-    elif is_chromium:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },
-            ],
-        }
-    else:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder"
-                    if (
-                        sys.platform == "darwin"
-                        and int(os.uname().release.split(".")[0]) >= 21
-                    )
-                    else "This is a description!",
-                    "value": "and a value",
-                },  # webkit uses the description over placeholder for the name
-            ],
-        }
-    assert page.accessibility.snapshot() == golden
-
-
-def test_accessibility_should_work_with_regular_text(
-    page: Page, is_firefox: bool
-) -> None:
-    page.set_content("<div>Hello World</div>")
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "role": "text leaf" if is_firefox else "text",
-        "name": "Hello World",
-    }
-
-
-def test_accessibility_roledescription(page: Page) -> None:
-    page.set_content('<p tabIndex=-1 aria-roledescription="foo">Hi</p>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["roledescription"] == "foo"
-
-
-def test_accessibility_orientation(page: Page) -> None:
-    page.set_content('<a href="" role="slider" aria-orientation="vertical">11</a>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["orientation"] == "vertical"
-
-
-def test_accessibility_autocomplete(page: Page) -> None:
-    page.set_content('<div role="textbox" aria-autocomplete="list">hi</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["autocomplete"] == "list"
-
-
-def test_accessibility_multiselectable(page: Page) -> None:
-    page.set_content('<div role="grid" tabIndex=-1 aria-multiselectable=true>hey</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["multiselectable"]
-
-
-def test_accessibility_keyshortcuts(page: Page) -> None:
-    page.set_content('<div role="grid" tabIndex=-1 aria-keyshortcuts="foo">hey</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0]["keyshortcuts"] == "foo"
-
-
-def test_accessibility_filtering_children_of_leaf_nodes_should_not_report_text_nodes_inside_controls(
-    page: Page, is_firefox: bool
-) -> None:
-    page.set_content(
-        """
-    <div role="tablist">
-    <div role="tab" aria-selected="true"><b>Tab1</b></div>
-    <div role="tab">Tab2</div>
-    </div>"""
-    )
-    golden = {
-        "role": "document" if is_firefox else "WebArea",
-        "name": "",
-        "children": [
-            {"role": "tab", "name": "Tab1", "selected": True},
-            {"role": "tab", "name": "Tab2"},
-        ],
-    }
-    assert page.accessibility.snapshot() == golden
-
-
-# Firefox does not support contenteditable="plaintext-only".
-# WebKit rich text accessibility is iffy
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_with_role_should_not_have_children(
-    page: Page,
-) -> None:
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only" role='textbox'>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "multiline": True,
-        "name": "",
-        "role": "textbox",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_without_role_should_not_have_content(
-    page: Page,
-) -> None:
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only">Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "name": "",
-        "role": "generic",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_with_tabindex_and_without_role_should_not_have_content(
-    page: Page,
-) -> None:
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only" tabIndex=0>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == {
-        "name": "",
-        "role": "generic",
-        "value": "Edit this image:",
-    }
-
-
-def test_accessibility_non_editable_textbox_with_role_and_tabIndex_and_label_should_not_have_children(
-    page: Page, is_chromium: bool, is_firefox: bool
-) -> None:
-    page.set_content(
-        """
-      <div role="textbox" tabIndex=0 aria-checked="true" aria-label="my favorite textbox">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-      </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content yo",
-        }
-    elif is_chromium:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content ",
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content  ",
-        }
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_checkbox_with_and_tabIndex_and_label_should_not_have_children(
-    page: Page,
-) -> None:
-    page.set_content(
-        """
-    <div role="checkbox" tabIndex=0 aria-checked="true" aria-label="my favorite checkbox">
-    this is the inner content
-    <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {"role": "checkbox", "name": "my favorite checkbox", "checked": True}
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_checkbox_without_label_should_not_have_children(
-    page: Page,
-) -> None:
-    page.set_content(
-        """
-      <div role="checkbox" aria-checked="true">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {
-        "role": "checkbox",
-        "name": "this is the inner content yo",
-        "checked": True,
-    }
-    snapshot = page.accessibility.snapshot()
-    assert snapshot
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_should_work_a_button(page: Page) -> None:
-    page.set_content("<button>My Button</button>")
-
-    button = page.query_selector("button")
-    assert page.accessibility.snapshot(root=button) == {
-        "role": "button",
-        "name": "My Button",
-    }
-
-
-def test_accessibility_should_work_an_input(page: Page) -> None:
-    page.set_content('<input title="My Input" value="My Value">')
-
-    input = page.query_selector("input")
-    assert page.accessibility.snapshot(root=input) == {
-        "role": "textbox",
-        "name": "My Input",
-        "value": "My Value",
-    }
-
-
-def test_accessibility_should_work_on_a_menu(
-    page: Page, is_webkit: bool, is_chromium: str, browser_channel: str
-) -> None:
-    page.set_content(
-        """
-        <div role="menu" title="My Menu">
-        <div role="menuitem">First Item</div>
-        <div role="menuitem">Second Item</div>
-        <div role="menuitem">Third Item</div>
-        </div>
-    """
-    )
-
-    menu = page.query_selector('div[role="menu"]')
-    golden = {
-        "role": "menu",
-        "name": "My Menu",
-        "children": [
-            {"role": "menuitem", "name": "First Item"},
-            {"role": "menuitem", "name": "Second Item"},
-            {"role": "menuitem", "name": "Third Item"},
-        ],
-    }
-    actual = page.accessibility.snapshot(root=menu)
-    assert actual
-    # Different per browser channel
-    if "orientation" in actual:
-        del actual["orientation"]
-    assert actual == golden
-
-
-def test_accessibility_should_return_null_when_the_element_is_no_longer_in_DOM(
-    page: Page,
-) -> None:
-    page.set_content("<button>My Button</button>")
-    button = page.query_selector("button")
-    page.eval_on_selector("button", "button => button.remove()")
-    assert page.accessibility.snapshot(root=button) is None
-
-
-def test_accessibility_should_show_uninteresting_nodes(page: Page) -> None:
-    page.set_content(
-        """
-        <div id="root" role="textbox">
-        <div>
-            hello
-            <div>
-            world
-            </div>
-        </div>
-        </div>
-    """
-    )
-
-    root = page.query_selector("#root")
-    assert root
-    snapshot = page.accessibility.snapshot(root=root, interesting_only=False)
-    assert snapshot
-    assert snapshot["role"] == "textbox"
-    assert "hello" in snapshot["value"]
-    assert "world" in snapshot["value"]
-    assert snapshot["children"]
diff --git a/tests/sync/test_assertions.py b/tests/sync/test_assertions.py
index d7180fc94..0199f67df 100644
--- a/tests/sync/test_assertions.py
+++ b/tests/sync/test_assertions.py
@@ -124,6 +124,32 @@ def test_assertions_locator_to_have_class(page: Page, server: Server) -> None:
         expect(page.locator("div.foobar")).to_have_class("oh-no", timeout=100)
 
 
+def test_assertions_locator_to_contain_class(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class='foo bar baz'></div>")
+    locator = page.locator("div")
+    expect(locator).to_contain_class("")
+    expect(locator).to_contain_class("bar")
+    expect(locator).to_contain_class("baz bar")
+    expect(locator).to_contain_class("  bar   foo ")
+    expect(locator).not_to_contain_class(
+        "  baz   not-matching "
+    )  # Strip whitespace and match individual classes
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_contain_class("does-not-exist", timeout=100)
+
+    assert excinfo.match("Locator expected to contain class 'does-not-exist'")
+    assert excinfo.match("Actual value: foo bar baz")
+    assert excinfo.match('Expect "to_contain_class" with timeout 100ms')
+
+    page.set_content(
+        '<div class="foo"></div><div class="hello bar"></div><div class="baz"></div>'
+    )
+    expect(locator).to_contain_class(["foo", "hello", "baz"])
+    expect(locator).not_to_contain_class(["not-there", "hello", "baz"])
+    expect(locator).not_to_contain_class(["foo", "hello"])
+
+
 def test_assertions_locator_to_have_count(page: Page, server: Server) -> None:
     page.goto(server.EMPTY_PAGE)
     page.set_content("<div class=foobar>kek</div><div class=foobar>kek</div>")
@@ -466,7 +492,7 @@ def test_to_have_values_fails_when_multiple_not_specified(
     )
     locator = page.locator("select")
     locator.select_option(["B"])
-    with pytest.raises(Error) as excinfo:
+    with pytest.raises(AssertionError) as excinfo:
         expect(locator).to_have_values(["R", "G"], timeout=500)
     assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
 
@@ -480,7 +506,7 @@ def test_to_have_values_fails_when_not_a_select_element(
     """
     )
     locator = page.locator("input")
-    with pytest.raises(Error) as excinfo:
+    with pytest.raises(AssertionError) as excinfo:
         expect(locator).to_have_values(["R", "G"], timeout=500)
     assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
 
@@ -490,18 +516,43 @@ def test_assertions_locator_to_be_checked(page: Page, server: Server) -> None:
     page.set_content("<input type=checkbox>")
     my_checkbox = page.locator("input")
     expect(my_checkbox).not_to_be_checked()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be checked"):
         expect(my_checkbox).to_be_checked(timeout=100)
     expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     with pytest.raises(AssertionError):
         expect(my_checkbox).to_be_checked(timeout=100, checked=True)
     my_checkbox.check()
     expect(my_checkbox).to_be_checked(timeout=100, checked=True)
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be unchecked"):
         expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     expect(my_checkbox).to_be_checked()
 
 
+def test_assertions_boolean_checked_with_intermediate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    expect(page.locator("input")).to_be_checked(indeterminate=True)
+
+
+def test_assertions_boolean_checked_with_intermediate_true_and_checked(
+    page: Page,
+) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    with pytest.raises(
+        AssertionError, match="Can't assert indeterminate and checked at the same time"
+    ):
+        expect(page.locator("input")).to_be_checked(checked=False, indeterminate=True)
+
+
+def test_assertions_boolean_fail_with_indeterminate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 1000ms'
+    ):
+        expect(page.locator("input")).to_be_checked(indeterminate=True, timeout=1000)
+
+
 def test_assertions_locator_to_be_disabled_enabled(page: Page, server: Server) -> None:
     page.goto(server.EMPTY_PAGE)
     page.set_content("<input type=checkbox>")
@@ -512,7 +563,7 @@ def test_assertions_locator_to_be_disabled_enabled(page: Page, server: Server) -
         expect(my_checkbox).to_be_disabled(timeout=100)
     my_checkbox.evaluate("e => e.disabled = true")
     expect(my_checkbox).to_be_disabled()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be enabled"):
         expect(my_checkbox).to_be_enabled(timeout=100)
 
 
@@ -521,6 +572,14 @@ def test_assertions_locator_to_be_enabled_with_true(page: Page) -> None:
     expect(page.locator("button")).to_be_enabled(enabled=True)
 
 
+def test_assertions_locator_to_be_enabled_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<button>Text</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be disabled"):
+        expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
 def test_assertions_locator_to_be_enabled_with_false(page: Page) -> None:
     page.set_content("<button disabled>Text</button>")
     expect(page.locator("button")).to_be_enabled(enabled=False)
@@ -559,11 +618,18 @@ def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page) -> Non
 
 def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
     page.goto(server.EMPTY_PAGE)
-    page.set_content("<input></input><button disabled>Text</button>")
-    expect(page.locator("button")).not_to_be_editable()
+    page.set_content("<input></input>")
     expect(page.locator("input")).to_be_editable()
-    with pytest.raises(AssertionError):
-        expect(page.locator("button")).to_be_editable(timeout=100)
+
+
+def test_assertions_locator_to_be_editable_throws(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        AssertionError,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        expect(page.locator("button")).not_to_be_editable()
 
 
 def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
@@ -576,6 +642,14 @@ def test_assertions_locator_to_be_editable_with_false(page: Page) -> None:
     expect(page.locator("input")).to_be_editable(editable=False)
 
 
+def test_assertions_locator_to_be_editable_with_false_and_throw_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<input></input>")
+    with pytest.raises(AssertionError, match="Locator expected to be readonly"):
+        expect(page.locator("input")).to_be_editable(editable=False)
+
+
 def test_assertions_locator_to_be_editable_with_not_and_false(page: Page) -> None:
     page.set_content("<input></input>")
     expect(page.locator("input")).not_to_be_editable(editable=False)
@@ -611,7 +685,7 @@ def test_assertions_locator_to_be_hidden_visible(page: Page, server: Server) ->
         expect(my_checkbox).to_be_hidden(timeout=100)
     my_checkbox.evaluate("e => e.style.display = 'none'")
     expect(my_checkbox).to_be_hidden()
-    with pytest.raises(AssertionError):
+    with pytest.raises(AssertionError, match="Locator expected to be visible"):
         expect(my_checkbox).to_be_visible(timeout=100)
 
 
@@ -625,6 +699,14 @@ def test_assertions_locator_to_be_visible_with_false(page: Page) -> None:
     expect(page.locator("button")).to_be_visible(visible=False)
 
 
+def test_assertions_locator_to_be_visible_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<button>hello</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be hidden"):
+        expect(page.locator("button")).to_be_visible(visible=False)
+
+
 def test_assertions_locator_to_be_visible_with_not_and_false(page: Page) -> None:
     page.set_content("<button>hello</button>")
     expect(page.locator("button")).not_to_be_visible(visible=False)
@@ -813,6 +895,15 @@ def test_should_be_attached_with_attached_false(page: Page) -> None:
     expect(locator).to_be_attached(attached=False)
 
 
+def test_should_be_attached_with_attached_false_and_throw_good_error(
+    page: Page,
+) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    with pytest.raises(AssertionError, match="Locator expected to be detached"):
+        expect(locator).to_be_attached(attached=False, timeout=1)
+
+
 def test_should_be_attached_with_not_and_attached_false(page: Page) -> None:
     page.set_content("<button>hello</button>")
     locator = page.locator("button")
@@ -838,7 +929,9 @@ def test_should_be_attached_eventually_with_not(page: Page) -> None:
 def test_should_be_attached_fail(page: Page) -> None:
     page.set_content("<button>Hello</button>")
     locator = page.locator("input")
-    with pytest.raises(AssertionError) as exc_info:
+    with pytest.raises(
+        AssertionError, match="Locator expected to be attached"
+    ) as exc_info:
         expect(locator).to_be_attached(timeout=1000)
     assert "locator resolved to" not in exc_info.value.args[0]
 
@@ -864,7 +957,7 @@ def test_should_be_attached_with_impossible_timeout_not(page: Page) -> None:
 def test_should_be_able_to_set_custom_timeout(page: Page) -> None:
     with pytest.raises(AssertionError) as exc_info:
         expect(page.locator("#a1")).to_be_visible(timeout=111)
-    assert "LocatorAssertions.to_be_visible with timeout 111ms" in str(exc_info.value)
+    assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
 
 
 def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
@@ -872,8 +965,105 @@ def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
         expect.set_options(timeout=111)
         with pytest.raises(AssertionError) as exc_info:
             expect(page.locator("#a1")).to_be_visible()
-        assert "LocatorAssertions.to_be_visible with timeout 111ms" in str(
-            exc_info.value
-        )
+        assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
     finally:
         expect.set_options(timeout=5_000)
+
+
+def test_to_have_accessible_name(page: Page) -> None:
+    page.set_content('<div role="button" aria-label="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_name("Hello")
+    expect(locator).not_to_have_accessible_name("hello")
+    expect(locator).to_have_accessible_name("hello", ignore_case=True)
+    expect(locator).to_have_accessible_name(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_name(re.compile(r"hello"))
+    expect(locator).to_have_accessible_name(re.compile(r"hello"), ignore_case=True)
+
+    page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+def test_to_have_accessible_error_message(page: Page) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    expect(locator).to_have_accessible_error_message("Hello")
+    expect(locator).not_to_have_accessible_error_message("hello")
+    expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
+
+def test_to_have_accessible_description(page: Page) -> None:
+    page.set_content('<div role="button" aria-description="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_description("Hello")
+    expect(locator).not_to_have_accessible_description("hello")
+    expect(locator).to_have_accessible_description("hello", ignore_case=True)
+    expect(locator).to_have_accessible_description(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_description(re.compile(r"hello"))
+    expect(locator).to_have_accessible_description(
+        re.compile(r"hello"), ignore_case=True
+    )
+
+    page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
+
+def test_to_have_role(page: Page) -> None:
+    page.set_content('<div role="button">Button!</div>')
+    expect(page.locator("div")).to_have_role("button")
+    expect(page.locator("div")).not_to_have_role("checkbox")
+    with pytest.raises(Error) as excinfo:
+        expect(page.locator("div")).to_have_role(re.compile(r"button|checkbox"))  # type: ignore
+    assert '"role" argument in to_have_role must be a string' in str(excinfo.value)
diff --git a/tests/sync/test_browsercontext_events.py b/tests/sync/test_browsercontext_events.py
index 315fff0dc..a100fb04a 100644
--- a/tests/sync/test_browsercontext_events.py
+++ b/tests/sync/test_browsercontext_events.py
@@ -16,7 +16,7 @@
 
 import pytest
 
-from playwright.sync_api import Dialog, Page
+from playwright.sync_api import BrowserContext, Dialog, Page
 
 from ..server import Server, TestServerRequest
 
@@ -172,23 +172,25 @@ def test_dialog_event_should_work_with_inline_script_tag(
 ) -> None:
     def handle_route(request: TestServerRequest) -> None:
         request.setHeader("content-type", "text/html")
-        request.write(b"""<script>window.result = prompt('hey?')</script>""")
+        request.write(b"<script>window.result = prompt('hey?')</script>")
         request.finish()
 
     server.set_route("/popup.html", handle_route)
     page.goto(server.EMPTY_PAGE)
     page.set_content("<a href='popup.html' target=_blank>Click me</a>")
 
-    def handle_dialog(dialog: Dialog) -> None:
-        assert dialog.message == "hey?"
-        assert dialog.page == popup
-        dialog.accept("hello")
+    with (
+        page.context.expect_event("dialog") as dialog_info,
+        page.expect_popup() as popup_info,
+    ):
+        page.click("a")
 
-    page.context.on("dialog", handle_dialog)
+    dialog: Dialog = dialog_info.value
+    popup: Page = popup_info.value
 
-    with page.expect_popup() as popup_info:
-        page.click("a")
-    popup = popup_info.value
+    assert dialog.message == "hey?"
+    assert dialog.page == popup
+    dialog.accept("hello")
     assert popup.evaluate("window.result") == "hello"
 
 
@@ -198,3 +200,11 @@ def test_console_event_should_work_with_context_manager(page: Page) -> None:
     message = cm_info.value
     assert message.text == "hello"
     assert message.page == page
+
+
+def test_weberror_event_should_work(context: BrowserContext, page: Page) -> None:
+    with context.expect_event("weberror") as error_info:
+        page.goto('data:text/html,<script>throw new Error("Test")</script>')
+    error = error_info.value
+    assert error.page == page
+    assert error.error.message == "Test"
diff --git a/tests/sync/test_browsercontext_storage_state.py b/tests/sync/test_browsercontext_storage_state.py
index c785b1479..6850de8a1 100644
--- a/tests/sync/test_browsercontext_storage_state.py
+++ b/tests/sync/test_browsercontext_storage_state.py
@@ -15,7 +15,8 @@
 import json
 from pathlib import Path
 
-from playwright.sync_api import Browser, BrowserContext
+from playwright.sync_api import Browser, BrowserContext, Page, StorageState
+from tests.server import Server
 
 
 def test_should_capture_local_storage(context: BrowserContext) -> None:
@@ -41,27 +42,58 @@ def test_should_capture_local_storage(context: BrowserContext) -> None:
 
 
 def test_should_set_local_storage(browser: Browser) -> None:
-    context = browser.new_context(
-        storage_state={
-            "origins": [
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = browser.new_context(storage_state=storage_state)
 
     page = context.new_page()
     page.route("**/*", lambda route: route.fulfill(body="<html></html>"))
     page.goto("https://www.example.com")
     local_storage = page.evaluate("window.localStorage")
     assert local_storage == {"name1": "value1"}
+
+    indexed_db = page.evaluate(
+        """async () => {
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open('db', 42);
+            openRequest.addEventListener('success', () => {
+                const db = openRequest.result;
+                const transaction = db.transaction('store', 'readonly');
+                const getRequest = transaction.objectStore('store').get('bar');
+                getRequest.addEventListener('success', () => resolve(getRequest.result));
+                getRequest.addEventListener('error', () => reject(getRequest.error));
+            });
+            openRequest.addEventListener('error', () => reject(openRequest.error));
+        });
+    }"""
+    )
+    assert indexed_db == "foo"
     context.close()
 
 
 def test_should_round_trip_through_the_file(
-    browser: Browser, context: BrowserContext, tmpdir: Path
+    browser: Browser, context: BrowserContext, tmp_path: Path
 ) -> None:
     page1 = context.new_page()
     page1.route(
@@ -77,7 +109,7 @@ def test_should_round_trip_through_the_file(
         }"""
     )
 
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     state = context.storage_state(path=path)
     with open(path, "r") as f:
         written = json.load(f)
@@ -95,3 +127,48 @@ def test_should_round_trip_through_the_file(
     cookie = page2.evaluate("document.cookie")
     assert cookie == "username=John Doe"
     context2.close()
+
+
+def test_should_serialise_indexed_db(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """async () => {
+            await new Promise((resolve, reject) => {
+                const openRequest = indexedDB.open('db', 42);
+                openRequest.onupgradeneeded = () => {
+                openRequest.result.createObjectStore('store');
+                };
+                openRequest.onsuccess = () => {
+                const request = openRequest.result.transaction('store', 'readwrite')
+                    .objectStore('store')
+                    .put('foo', 'bar');
+                request.addEventListener('success', resolve);
+                request.addEventListener('error', reject);
+                };
+            });
+        }"""
+    )
+    assert page.context.storage_state() == {"cookies": [], "origins": []}
+    assert page.context.storage_state(indexed_db=True) == {
+        "cookies": [],
+        "origins": [
+            {
+                "origin": f"http://localhost:{server.PORT}",
+                "localStorage": [],
+                "indexedDB": [
+                    {
+                        "name": "db",
+                        "version": 42,
+                        "stores": [
+                            {
+                                "name": "store",
+                                "autoIncrement": False,
+                                "records": [{"key": "bar", "value": "foo"}],
+                                "indexes": [],
+                            }
+                        ],
+                    }
+                ],
+            }
+        ],
+    }
diff --git a/tests/sync/test_console.py b/tests/sync/test_console.py
index 73cd9f659..8601ebbe5 100644
--- a/tests/sync/test_console.py
+++ b/tests/sync/test_console.py
@@ -109,7 +109,10 @@ def test_console_should_trigger_correct_Log(page: Page, server: Server) -> None:
     page.goto("about:blank")
     with page.expect_console_message() as message:
         page.evaluate("url => fetch(url).catch(e => {})", server.EMPTY_PAGE)
-    assert "Access-Control-Allow-Origin" in message.value.text
+    assert (
+        "Access-Control-Allow-Origin" in message.value.text
+        or "CORS" in message.value.text
+    )
     assert message.value.type == "error"
 
 
diff --git a/tests/sync/test_expect_misc.py b/tests/sync/test_expect_misc.py
index 042929fde..4d8b68cc0 100644
--- a/tests/sync/test_expect_misc.py
+++ b/tests/sync/test_expect_misc.py
@@ -56,7 +56,7 @@ def test_to_be_in_viewport_should_respect_ratio_option(
 
 def test_to_be_in_viewport_should_have_good_stack(page: Page, server: Server) -> None:
     with pytest.raises(AssertionError) as exc_info:
-        expect(page.locator("body")).not_to_be_in_viewport(timeout=100)
+        expect(page.locator("body")).not_to_be_in_viewport(timeout=1000)
     assert 'unexpected value "viewport ratio' in str(exc_info.value)
 
 
diff --git a/tests/sync/test_extension.py b/tests/sync/test_extension.py
new file mode 100644
index 000000000..2cb8aee77
--- /dev/null
+++ b/tests/sync/test_extension.py
@@ -0,0 +1,101 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Generator, List, Optional
+
+import pytest
+
+from playwright.sync_api import BrowserContext, BrowserType
+
+
+@pytest.fixture()
+def launch_persistent_context(
+    browser_type: BrowserType,
+    browser_channel: Optional[str],
+    tmp_path: Path,
+    launch_arguments: Dict[str, Any],
+    is_headless_shell: bool,
+) -> Generator[Callable[..., BrowserContext], None, None]:
+    if browser_channel and browser_channel.startswith("chrome"):
+        pytest.skip(
+            "--load-extension is not supported in Chrome anymore. https://groups.google.com/a/chromium.org/g/chromium-extensions/c/1-g8EFx2BBY/m/S0ET5wPjCAAJ"
+        )
+    if is_headless_shell:
+        pytest.skip("Headless Shell has no support for extensions")
+
+    contexts: List[BrowserContext] = []
+
+    def launch(extension_path: str, **kwargs: Any) -> BrowserContext:
+        context = browser_type.launch_persistent_context(
+            str(tmp_path),
+            **launch_arguments,
+            **kwargs,
+            args=[
+                f"--disable-extensions-except={extension_path}",
+                f"--load-extension={extension_path}",
+            ],
+        )
+        contexts.append(context)
+        return context
+
+    yield launch
+
+    for context in contexts:
+        context.close()
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_give_access_to_the_service_worker(
+    launch_persistent_context: Callable[..., BrowserContext],
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = launch_persistent_context(extension_path)
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not service_worker.evaluate("globalThis.MAGIC") == 42:
+        context.pages[0].wait_for_timeout(100)
+    context.close()
+    assert len(context.background_pages) == 0
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_give_access_to_the_service_worker_when_recording_video(
+    launch_persistent_context: Callable[..., BrowserContext],
+    tmp_path: Path,
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = launch_persistent_context(
+        extension_path, record_video_dir=(tmp_path / "videos")
+    )
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not service_worker.evaluate("globalThis.MAGIC") == 42:
+        context.pages[0].wait_for_timeout(100)
+    context.close()
+    assert len(context.background_pages) == 0
diff --git a/tests/sync/test_fetch_global.py b/tests/sync/test_fetch_global.py
index 5c25d4059..5cb3abc5b 100644
--- a/tests/sync/test_fetch_global.py
+++ b/tests/sync/test_fetch_global.py
@@ -19,7 +19,7 @@
 import pytest
 
 from playwright.sync_api import APIResponse, Error, Playwright, StorageState
-from tests.server import Server
+from tests.server import Server, TestServerRequest
 
 
 @pytest.mark.parametrize(
@@ -67,10 +67,19 @@ def test_should_support_global_timeout_option(
 ) -> None:
     request = playwright.request.new_context(timeout=100)
     server.set_route("/empty.html", lambda req: None)
-    with pytest.raises(Error, match="Request timed out after 100ms"):
+    with pytest.raises(Error, match="Timeout 100ms exceeded"):
         request.get(server.EMPTY_PAGE)
 
 
+def test_should_support_timeout_option_in_get_method(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context()
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="APIRequestContext.get: Timeout 123ms exceeded."):
+        request.get(server.EMPTY_PAGE, timeout=123)
+
+
 def test_should_propagate_extra_http_headers_with_redirects(
     playwright: Playwright, server: Server
 ) -> None:
@@ -236,7 +245,7 @@ def test_should_return_empty_body(playwright: Playwright, server: Server) -> Non
 
 
 def test_storage_state_should_round_trip_through_file(
-    playwright: Playwright, tmpdir: Path
+    playwright: Playwright, tmp_path: Path
 ) -> None:
     expected: StorageState = {
         "cookies": [
@@ -254,7 +263,7 @@ def test_storage_state_should_round_trip_through_file(
         "origins": [],
     }
     request = playwright.request.new_context(storage_state=expected)
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     actual = request.storage_state(path=path)
     assert actual == expected
 
@@ -323,3 +332,59 @@ def test_should_serialize_null_values_in_json(
     assert response.status == 200
     assert response.text() == '{"foo": null}'
     request.dispose()
+
+
+def test_should_throw_when_fail_on_status_code_is_true(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=True)
+    with pytest.raises(Error, match="404 Not Found"):
+        request.fetch(server.EMPTY_PAGE)
+    request.dispose()
+
+
+def test_should_not_throw_when_fail_on_status_code_is_false(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=False)
+    response = request.fetch(server.EMPTY_PAGE)
+    assert response.status == 404
+    request.dispose()
+
+
+def test_should_follow_max_redirects(playwright: Playwright, server: Server) -> None:
+    redirect_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal redirect_count
+        redirect_count += 1
+        req.setResponseCode(301)
+        req.setHeader("Location", server.EMPTY_PAGE)
+        req.finish()
+
+    server.set_route("/empty.html", _handle_request)
+    request = playwright.request.new_context(max_redirects=1)
+    with pytest.raises(Error, match="Max redirect count exceeded"):
+        request.fetch(server.EMPTY_PAGE)
+    assert redirect_count == 2
+    request.dispose()
diff --git a/tests/sync/test_har.py b/tests/sync/test_har.py
index 0644d3856..6ac848b8a 100644
--- a/tests/sync/test_har.py
+++ b/tests/sync/test_har.py
@@ -25,8 +25,8 @@
 from tests.server import Server
 
 
-def test_should_work(browser: Browser, server: Server, tmpdir: Path) -> None:
-    path = os.path.join(tmpdir, "log.har")
+def test_should_work(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path)
     page = context.new_page()
     page.goto(server.EMPTY_PAGE)
@@ -36,8 +36,8 @@ def test_should_work(browser: Browser, server: Server, tmpdir: Path) -> None:
         assert "log" in data
 
 
-def test_should_omit_content(browser: Browser, server: Server, tmpdir: Path) -> None:
-    path = os.path.join(tmpdir, "log.har")
+def test_should_omit_content(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path, record_har_content="omit")
     page = context.new_page()
     page.goto(server.PREFIX + "/har.html")
@@ -53,9 +53,9 @@ def test_should_omit_content(browser: Browser, server: Server, tmpdir: Path) ->
 
 
 def test_should_omit_content_legacy(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path, record_har_omit_content=True)
     page = context.new_page()
     page.goto(server.PREFIX + "/har.html")
@@ -70,8 +70,10 @@ def test_should_omit_content_legacy(
         assert "encoding" not in content1
 
 
-def test_should_attach_content(browser: Browser, server: Server, tmpdir: Path) -> None:
-    path = os.path.join(tmpdir, "log.har.zip")
+def test_should_attach_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har.zip")
     context = browser.new_context(
         record_har_path=path,
         record_har_content="attach",
@@ -127,8 +129,10 @@ def test_should_attach_content(browser: Browser, server: Server, tmpdir: Path) -
                 assert len(f.read()) == entries[2]["response"]["content"]["size"]
 
 
-def test_should_include_content(browser: Browser, server: Server, tmpdir: Path) -> None:
-    path = os.path.join(tmpdir, "log.har")
+def test_should_include_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path)
     page = context.new_page()
     page.goto(server.PREFIX + "/har.html")
@@ -144,9 +148,9 @@ def test_should_include_content(browser: Browser, server: Server, tmpdir: Path)
 
 
 def test_should_default_to_full_mode(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(
         record_har_path=path,
     )
@@ -161,9 +165,9 @@ def test_should_default_to_full_mode(
 
 
 def test_should_support_minimal_mode(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    path = os.path.join(tmpdir, "log.har")
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(
         record_har_path=path,
         record_har_mode="minimal",
@@ -178,8 +182,8 @@ def test_should_support_minimal_mode(
         assert log["entries"][0]["request"]["bodySize"] == -1
 
 
-def test_should_filter_by_glob(browser: Browser, server: Server, tmpdir: str) -> None:
-    path = os.path.join(tmpdir, "log.har")
+def test_should_filter_by_glob(browser: Browser, server: Server, tmp_path: str) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(
         base_url=server.PREFIX,
         record_har_path=path,
@@ -197,8 +201,10 @@ def test_should_filter_by_glob(browser: Browser, server: Server, tmpdir: str) ->
         assert log["entries"][0]["request"]["url"].endswith("one-style.css")
 
 
-def test_should_filter_by_regexp(browser: Browser, server: Server, tmpdir: str) -> None:
-    path = os.path.join(tmpdir, "log.har")
+def test_should_filter_by_regexp(
+    browser: Browser, server: Server, tmp_path: str
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(
         base_url=server.PREFIX,
         record_har_path=path,
@@ -270,9 +276,9 @@ def test_by_default_should_abort_requests_not_found_in_har(
 
 
 def test_fallback_continue_should_continue_requests_on_bad_har(
-    context: BrowserContext, server: Server, tmpdir: Path
+    context: BrowserContext, server: Server, tmp_path: Path
 ) -> None:
-    path_to_invalid_har = tmpdir / "invalid.har"
+    path_to_invalid_har = tmp_path / "invalid.har"
     with path_to_invalid_har.open("w") as f:
         json.dump({"log": {}}, f)
     context.route_from_har(har=path_to_invalid_har, not_found="fallback")
@@ -423,9 +429,9 @@ def test_should_fulfill_from_har_with_content_in_a_file(
 
 
 def test_should_round_trip_har_zip(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
     page_1 = context_1.new_page()
     page_1.goto(server.PREFIX + "/one-style.html")
@@ -437,10 +443,11 @@ def test_should_round_trip_har_zip(
     page_2.goto(server.PREFIX + "/one-style.html")
     assert "hello, world!" in page_2.content()
     expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
 
 
 def test_should_round_trip_har_with_post_data(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
     server.set_route(
         "/echo", lambda req: (req.write(cast(Any, req).post_body), req.finish())
@@ -451,7 +458,7 @@ def test_should_round_trip_har_with_post_data(
             return response.text();
         };
     """
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
     page_1 = context_1.new_page()
     page_1.goto(server.EMPTY_PAGE)
@@ -470,10 +477,11 @@ def test_should_round_trip_har_with_post_data(
     assert page_2.evaluate(fetch_function, "3") == "3"
     with pytest.raises(Exception):
         page_2.evaluate(fetch_function, "4")
+    context_2.close()
 
 
 def test_should_disambiguate_by_header(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
     server.set_route(
         "/echo",
@@ -493,7 +501,7 @@ def test_should_disambiguate_by_header(
             return response.text();
         };
     """
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
     page_1 = context_1.new_page()
     page_1.goto(server.EMPTY_PAGE)
@@ -511,12 +519,13 @@ def test_should_disambiguate_by_header(
     assert page_2.evaluate(fetch_function, "baz2") == "baz2"
     assert page_2.evaluate(fetch_function, "baz3") == "baz3"
     assert page_2.evaluate(fetch_function, "baz4") == "baz1"
+    context_2.close()
 
 
 def test_should_produce_extracted_zip(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.har"
+    har_path = tmp_path / "har.har"
     context = browser.new_context(
         record_har_mode="minimal", record_har_path=har_path, record_har_content="attach"
     )
@@ -536,12 +545,13 @@ def test_should_produce_extracted_zip(
     page_2.goto(server.PREFIX + "/one-style.html")
     assert "hello, world!" in page_2.content()
     expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
 
 
 def test_should_update_har_zip_for_context(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context = browser.new_context()
     context.route_from_har(har_path, update=True)
     page_1 = context.new_page()
@@ -556,12 +566,13 @@ def test_should_update_har_zip_for_context(
     page_2.goto(server.PREFIX + "/one-style.html")
     assert "hello, world!" in page_2.content()
     expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
 
 
 def test_should_update_har_zip_for_page(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context = browser.new_context()
     page_1 = context.new_page()
     page_1.route_from_har(har_path, update=True)
@@ -576,12 +587,13 @@ def test_should_update_har_zip_for_page(
     page_2.goto(server.PREFIX + "/one-style.html")
     assert "hello, world!" in page_2.content()
     expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
 
 
 def test_should_update_har_zip_for_page_with_different_options(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.zip"
+    har_path = tmp_path / "har.zip"
     context1 = browser.new_context()
     page1 = context1.new_page()
     page1.route_from_har(
@@ -600,9 +612,9 @@ def test_should_update_har_zip_for_page_with_different_options(
 
 
 def test_should_update_extracted_har_zip_for_page(
-    browser: Browser, server: Server, tmpdir: Path
+    browser: Browser, server: Server, tmp_path: Path
 ) -> None:
-    har_path = tmpdir / "har.har"
+    har_path = tmp_path / "har.har"
     context = browser.new_context()
     page_1 = context.new_page()
     page_1.route_from_har(har_path, update=True)
@@ -621,3 +633,4 @@ def test_should_update_extracted_har_zip_for_page(
     page_2.goto(server.PREFIX + "/one-style.html")
     assert "hello, world!" in page_2.content()
     expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
diff --git a/tests/sync/test_launcher.py b/tests/sync/test_launcher.py
index 8577fd200..2e5ec1573 100644
--- a/tests/sync/test_launcher.py
+++ b/tests/sync/test_launcher.py
@@ -14,7 +14,7 @@
 
 import os
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict
 
 import pytest
 
@@ -88,39 +88,3 @@ def test_browser_close_should_be_callable_twice(
     browser = browser_type.launch(**launch_arguments)
     browser.close()
     browser.close()
-
-
-@pytest.mark.only_browser("chromium")
-def test_browser_launch_should_return_background_pages(
-    browser_type: BrowserType,
-    tmpdir: Path,
-    browser_channel: Optional[str],
-    assetdir: Path,
-    launch_arguments: Dict,
-) -> None:
-    if browser_channel:
-        pytest.skip()
-
-    extension_path = str(assetdir / "simple-extension")
-    context = browser_type.launch_persistent_context(
-        str(tmpdir),
-        **{
-            **launch_arguments,
-            "headless": False,
-            "args": [
-                f"--disable-extensions-except={extension_path}",
-                f"--load-extension={extension_path}",
-            ],
-        },
-    )
-    background_page = None
-    if len(context.background_pages):
-        background_page = context.background_pages[0]
-    else:
-        background_page = context.wait_for_event("backgroundpage")
-    assert background_page
-    assert background_page in context.background_pages
-    assert background_page not in context.pages
-    context.close()
-    assert len(context.background_pages) == 0
-    assert len(context.pages) == 0
diff --git a/tests/sync/test_locators.py b/tests/sync/test_locators.py
index 4ed1b578a..49d4d46ae 100644
--- a/tests/sync/test_locators.py
+++ b/tests/sync/test_locators.py
@@ -126,7 +126,7 @@ def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> None:
     )
 
     div = page.locator("div")
-    assert div.is_enabled() is True
+    assert div.is_enabled()
     assert div.is_disabled() is False
 
     button1 = page.locator(':text("button1")')
@@ -134,7 +134,7 @@ def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> None:
     assert button1.is_disabled() is True
 
     button1 = page.locator(':text("button2")')
-    assert button1.is_enabled() is True
+    assert button1.is_enabled()
     assert button1.is_disabled() is False
 
 
@@ -327,6 +327,12 @@ def test_locators_should_upload_a_file(page: Page, server: Server) -> None:
     )
 
 
+def test_locators_upload_nonexistant_file(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/fileupload.html")
+    with pytest.raises(FileNotFoundError):
+        page.locator("input[type=file]").set_input_files("nonexistant.html")
+
+
 def test_locators_should_press(page: Page) -> None:
     page.set_content("<input type='text' />")
     page.locator("input").press("h")
@@ -493,6 +499,28 @@ def test_should_combine_visible_with_other_selectors(page: Page) -> None:
     )
 
 
+def test_should_support_filter_visible(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <div class="item" style="display: none">Hidden data0</div>
+    <div class="item">visible data1</div>
+    <div class="item" style="display: none">Hidden data1</div>
+    <div class="item">visible data2</div>
+    <div class="item" style="display: none">Hidden data2</div>
+    <div class="item">visible data3</div>
+    </div>
+    """
+    )
+    locator = page.locator(".item").filter(visible=True).nth(1)
+    expect(locator).to_have_text("visible data2")
+    expect(
+        page.locator(".item").filter(visible=True).get_by_text("data3")
+    ).to_have_text("visible data3")
+    expect(
+        page.locator(".item").filter(visible=False).get_by_text("data1")
+    ).to_have_text("Hidden data1")
+
+
 def test_locator_count_should_work_with_deleted_map_in_main_world(page: Page) -> None:
     page.evaluate("Map = 1")
     page.locator("#searchResultTableDiv .x-grid3-row").count()
@@ -975,3 +1003,12 @@ def test_locator_click_timeout_error_should_contain_call_log(page: Page) -> None
         "During handling of the above exception, another exception occurred"
         not in formatted_exception
     )
+
+
+def test_locator_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    page.set_content("<div>foo</div>")
+    div = page.locator("div")
+    assert div.is_hidden(timeout=10) is False
+    assert div.is_visible(timeout=10) is True
diff --git a/tests/sync/test_network.py b/tests/sync/test_network.py
index 2ec6d7da9..8c196affb 100644
--- a/tests/sync/test_network.py
+++ b/tests/sync/test_network.py
@@ -19,12 +19,12 @@
 
 
 def test_response_server_addr(page: Page, server: Server) -> None:
-    response = page.goto(f"http://127.0.0.1:{server.PORT}")
+    response = page.goto(server.EMPTY_PAGE)
     assert response
     server_addr = response.server_addr()
     assert server_addr
     assert server_addr["port"] == server.PORT
-    assert server_addr["ipAddress"] in ["127.0.0.1", "::1"]
+    assert server_addr["ipAddress"] in ["127.0.0.1", "[::1]"]
 
 
 def test_response_security_details(
@@ -92,7 +92,7 @@ def handle_request(route: Route) -> None:
     assert response.json() == {"foo": "bar"}
 
 
-def test_should_report_if_request_was_from_service_worker(
+def test_should_report_if_response_was_from_service_worker(
     page: Page, server: Server
 ) -> None:
     response = page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
@@ -102,3 +102,15 @@ def test_should_report_if_request_was_from_service_worker(
     with page.expect_response("**/example.txt") as response_info:
         page.evaluate("() => fetch('/example.txt')")
     assert response_info.value.from_service_worker
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_report_service_worker_request(page: Page, server: Server) -> None:
+    with page.context.expect_event("serviceworker") as worker_info:
+        page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
+        page.evaluate("() => window.activationPromise")
+    with page.context.expect_event(
+        "request", lambda r: r.service_worker is not None
+    ) as request_info:
+        page.evaluate("() => fetch('/example.txt')")
+    assert request_info.value.service_worker == worker_info.value
diff --git a/tests/sync/test_page.py b/tests/sync/test_page.py
index 7550a80d1..e29c7cabc 100644
--- a/tests/sync/test_page.py
+++ b/tests/sync/test_page.py
@@ -114,3 +114,11 @@ def test_page_pause_should_reset_custom_timeouts(
     server.set_route("/empty.html", lambda route: None)
     with pytest.raises(Error, match="Timeout 456ms exceeded."):
         page.goto(server.EMPTY_PAGE)
+
+
+def test_page_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    page.set_content("<div>foo</div>")
+    assert page.is_hidden("div", timeout=10) is False
+    assert page.is_visible("div", timeout=10) is True
diff --git a/tests/sync/test_page_add_locator_handler.py b/tests/sync/test_page_add_locator_handler.py
index b069520ec..7a2b6a438 100644
--- a/tests/sync/test_page_add_locator_handler.py
+++ b/tests/sync/test_page_add_locator_handler.py
@@ -29,7 +29,6 @@ def test_should_work(page: Page, server: Server) -> None:
     original_locator = page.get_by_text("This interstitial covers the button")
 
     def handler(locator: Locator) -> None:
-        nonlocal original_locator
         assert locator == original_locator
         nonlocal before_count
         nonlocal after_count
@@ -310,7 +309,7 @@ def _handler() -> None:
     with pytest.raises(Error) as exc_info:
         page.locator("#target").click(timeout=3000)
     assert page.evaluate("window.clicked") == 0
-    expect(page.locator("#interstitial")).to_be_visible()
+    assert page.locator("#interstitial").is_visible()
     assert called == 1
     assert (
         'locator handler has finished, waiting for get_by_role("button", name="close") to be hidden'
diff --git a/tests/sync/test_page_aria_snapshot.py b/tests/sync/test_page_aria_snapshot.py
new file mode 100644
index 000000000..17d722ae8
--- /dev/null
+++ b/tests/sync/test_page_aria_snapshot.py
@@ -0,0 +1,216 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+import pytest
+
+from playwright.sync_api import Locator, Page, expect
+
+
+def _unshift(snapshot: str) -> str:
+    lines = snapshot.split("\n")
+    whitespace_prefix_length = 100
+    for line in lines:
+        if not line.strip():
+            continue
+        match = re.match(r"^(\s*)", line)
+        if match and len(match[1]) < whitespace_prefix_length:
+            whitespace_prefix_length = len(match[1])
+    return "\n".join(
+        [line[whitespace_prefix_length:] for line in lines if line.strip()]
+    )
+
+
+def check_and_match_snapshot(locator: Locator, snapshot: str) -> None:
+    assert locator.aria_snapshot() == _unshift(snapshot)
+    expect(locator).to_match_aria_snapshot(snapshot)
+
+
+def test_should_snapshot(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+    """,
+    )
+
+
+def test_should_snapshot_list(page: Page) -> None:
+    page.set_content("<h1>title</h1><h1>title 2</h1>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+      - heading "title 2" [level=1]
+    """,
+    )
+
+
+def test_should_snapshot_list_with_list(page: Page) -> None:
+    page.set_content("<ul><li>one</li><li>two</li></ul>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+def test_should_snapshot_list_with_accessible_name(page: Page) -> None:
+    page.set_content('<ul aria-label="my list"><li>one</li><li>two</li></ul>')
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list "my list":
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+def test_should_snapshot_complex(page: Page) -> None:
+    page.set_content('<ul><li><a href="about:blank">link</a></li></ul>')
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem:
+          - link "link":
+            - /url: about:blank
+    """,
+    )
+
+
+def test_should_snapshot_with_unexpected_children_equal(page: Page) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>One</li>
+        <li>Two</li>
+        <li>Three</li>
+      </ul>
+    """
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem: One
+        - listitem: Three
+    """,
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: equal
+          - listitem: One
+          - listitem: Three
+      """,
+            timeout=1000,
+        )
+
+
+def test_should_snapshot_with_unexpected_children_deep_equal(page: Page) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem:
+          - list:
+            - listitem: 1.1
+    """,
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+          - list:
+            - /children: deep-equal
+            - listitem:
+              - list:
+                - listitem: 1.1
+        """,
+            timeout=1000,
+        )
+
+
+def test_should_snapshot_with_restored_contain_mode_inside_deep_equal(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+            timeout=1000,
+        )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - /children: contain
+              - listitem: 1.1
+      """,
+    )
+
+
+def test_match_values_both_against_regex_and_string(page: Page) -> None:
+    page.set_content('<a href="/auth?r=/">Log in</a>')
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - link "Log in":
+          - /url: /auth?r=/
+      """,
+    )
diff --git a/tests/sync/test_page_clock.py b/tests/sync/test_page_clock.py
index 025133b57..72d5e5a3e 100644
--- a/tests/sync/test_page_clock.py
+++ b/tests/sync/test_page_clock.py
@@ -392,7 +392,6 @@ def test_should_pause(self, page: Page) -> None:
         page.goto("data:text/html,")
         page.clock.pause_at(1)
         page.wait_for_timeout(1000)
-        page.clock.resume()
         now = page.evaluate("Date.now()")
         assert 0 <= now <= 1000
 
diff --git a/tests/sync/test_page_event_console.py b/tests/sync/test_page_event_console.py
new file mode 100644
index 000000000..0ab19eca7
--- /dev/null
+++ b/tests/sync/test_page_event_console.py
@@ -0,0 +1,36 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from playwright.sync_api import Page
+
+
+def test_console_messages_should_work(page: Page) -> None:
+    page.evaluate(
+        """() => {
+            for (let i = 0; i < 301; i++)
+                console.log('message' + i);
+        }"""
+    )
+
+    messages = page.console_messages()
+    objects = [{"text": m.text, "type": m.type, "page": m.page} for m in messages]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append({"text": f"message{i}", "type": "log", "page": page})
+
+    assert len(objects) >= 100, "should be at least 100 messages"
+    message_count = len(messages) - len(expected)
+    assert objects[message_count:] == expected, "should return last messages"
diff --git a/tests/sync/test_page_event_pageerror.py b/tests/sync/test_page_event_pageerror.py
new file mode 100644
index 000000000..9295cb1b0
--- /dev/null
+++ b/tests/sync/test_page_event_pageerror.py
@@ -0,0 +1,36 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import Page
+
+
+def test_page_errors_should_work(page: Page) -> None:
+    page.evaluate(
+        """async () => {
+            for (let i = 0; i < 301; i++)
+                window.setTimeout(() => { throw new Error('error' + i); }, 0);
+            await new Promise(f => window.setTimeout(f, 100));
+        }"""
+    )
+
+    errors = page.page_errors()
+    messages = [e.message for e in errors]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append(f"error{i}")
+
+    assert len(messages) >= 100, "should be at least 100 errors"
+    message_count = len(messages) - len(expected)
+    assert messages[message_count:] == expected, "should return last errors"
diff --git a/tests/sync/test_page_event_request.py b/tests/sync/test_page_event_request.py
new file mode 100644
index 000000000..77515091f
--- /dev/null
+++ b/tests/sync/test_page_event_request.py
@@ -0,0 +1,54 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import Page, Request, Route
+from tests.server import Server
+
+
+def test_should_return_last_requests(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/title.html")
+    for i in range(200):
+
+        def _handle_route(route: Route) -> None:
+            route.fulfill(
+                status=200,
+                body=f"url:{route.request.url}",
+            )
+
+        page.route(f"**/fetch?{i}", _handle_route)
+
+    # #0 is the navigation request, so start with #1.
+    for i in range(1, 100):
+        page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    first_100_requests_with_goto = page.requests()
+    first_100_requests = first_100_requests_with_goto[1:]
+
+    for i in range(100, 200):
+        page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    last_100_requests = page.requests()
+
+    all_requests = first_100_requests + last_100_requests
+
+    def gather_response(request: Request) -> dict:
+        response = request.response()
+        assert response
+        return {"text": response.text(), "url": request.url}
+
+    # All 199 requests are fully functional.
+    received = [gather_response(request) for request in all_requests]
+    expected = []
+    for i in range(1, 200):
+        url = server.PREFIX + f"/fetch?{i}"
+        expected.append({"url": url, "text": f"url:{url}"})
+    assert received == expected
diff --git a/tests/sync/test_page_request_gc.py b/tests/sync/test_page_request_gc.py
new file mode 100644
index 000000000..bfddc2320
--- /dev/null
+++ b/tests/sync/test_page_request_gc.py
@@ -0,0 +1,34 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import Page
+from tests.server import Server
+
+
+def test_should_work(page: Page, server: Server) -> None:
+    page.evaluate(
+        """() => {
+        globalThis.objectToDestroy = { hello: 'world' };
+        globalThis.weakRef = new WeakRef(globalThis.objectToDestroy);
+    }"""
+    )
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    page.evaluate("() => globalThis.objectToDestroy = null")
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") is None
diff --git a/tests/sync/test_page_request_intercept.py b/tests/sync/test_page_request_intercept.py
index 86cf21b63..1d3dd0f46 100644
--- a/tests/sync/test_page_request_intercept.py
+++ b/tests/sync/test_page_request_intercept.py
@@ -34,7 +34,7 @@ def _handle(request: TestServerRequest) -> None:
     def handle(route: Route) -> None:
         with pytest.raises(Error) as error:
             route.fetch(timeout=1000)
-        assert "Request timed out after 1000ms" in error.value.message
+        assert "Route.fetch: Timeout 1000ms exceeded." in error.value.message
 
     page.route("**/*", lambda route: handle(route))
     with pytest.raises(Error) as error:
diff --git a/tests/sync/test_page_request_timeout.py b/tests/sync/test_page_request_timeout.py
new file mode 100644
index 000000000..8b65da26d
--- /dev/null
+++ b/tests/sync/test_page_request_timeout.py
@@ -0,0 +1,36 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from playwright.sync_api import BrowserContext, Error, Page
+from tests.server import Server
+
+
+def test_context_request_should_support_timeout_option(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    # https://github.com/microsoft/playwright/issues/39220
+
+    server.set_route("/", lambda req: None)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        page.request.get(server.PREFIX, timeout=123)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        context.request.get(server.PREFIX, timeout=123)
+
+    context.set_default_timeout(123)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        page.request.get(server.PREFIX)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        context.request.get(server.PREFIX)
diff --git a/tests/sync/test_page_select_option.py b/tests/sync/test_page_select_option.py
index 3c746dc6c..7bb6ade85 100644
--- a/tests/sync/test_page_select_option.py
+++ b/tests/sync/test_page_select_option.py
@@ -43,6 +43,22 @@ def test_select_option_should_select_single_option_by_label(
     assert page.evaluate("result.onChange") == ["indigo"]
 
 
+def test_select_option_should_select_single_option_by_empty_label(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+        <select>
+            <option value="indigo">Indigo</option>
+            <option value="violet"></option>
+        </select>
+    """
+    )
+    assert page.locator("select").input_value() == "indigo"
+    page.select_option("select", label="")
+    assert page.locator("select").input_value() == "violet"
+
+
 def test_select_option_should_select_single_option_by_handle(
     server: Server, page: Page
 ) -> None:
@@ -61,6 +77,14 @@ def test_select_option_should_select_single_option_by_index(
     assert page.evaluate("result.onChange") == ["brown"]
 
 
+def test_select_option_should_select_single_option_by_index_0(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", index=0)
+    assert page.evaluate("result.onInput") == ["black"]
+
+
 def test_select_option_should_select_only_first_option(
     server: Server, page: Page
 ) -> None:
@@ -108,6 +132,23 @@ def test_select_option_should_select_multiple_options_with_attributes(
     assert page.evaluate("result.onChange") == ["blue", "gray", "green"]
 
 
+def test_select_option_should_select_option_with_empty_value(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content(
+        """
+        <select>
+            <option value="first">First</option>
+            <option value="">Second</option>
+        </select>
+    """
+    )
+    assert page.locator("select").input_value() == "first"
+    page.select_option("select", value="")
+    assert page.locator("select").input_value() == ""
+
+
 def test_select_option_should_respect_event_bubbling(
     server: Server, page: Page
 ) -> None:
diff --git a/tests/sync/test_pdf.py b/tests/sync/test_pdf.py
index 684f27268..552d0f6bf 100644
--- a/tests/sync/test_pdf.py
+++ b/tests/sync/test_pdf.py
@@ -21,8 +21,8 @@
 
 
 @pytest.mark.only_browser("chromium")
-def test_should_be_able_to_save_pdf_file(page: Page, tmpdir: Path) -> None:
-    output_file = tmpdir / "foo.png"
+def test_should_be_able_to_save_pdf_file(page: Page, tmp_path: Path) -> None:
+    output_file = tmp_path / "foo.png"
     page.pdf(path=str(output_file))
     assert os.path.getsize(output_file) > 0
 
diff --git a/tests/sync/test_request_intercept.py b/tests/sync/test_request_intercept.py
index 8df41c0c2..a54c0ad71 100644
--- a/tests/sync/test_request_intercept.py
+++ b/tests/sync/test_request_intercept.py
@@ -131,3 +131,17 @@ def handle_route(route: Route) -> None:
     assert request.uri.decode() == "/title.html"
     original = (assetdir / "title.html").read_text()
     assert response.text() == original
+
+
+def test_should_intercept_by_glob(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.route(
+        "http://localhos**?*oo",
+        lambda route: route.fulfill(body="intercepted", status=200),
+    )
+
+    result = page.evaluate(
+        "url => fetch(url).then(r => r.text())", server.PREFIX + "/?foo"
+    )
+
+    assert result == "intercepted"
diff --git a/tests/sync/test_resource_timing.py b/tests/sync/test_resource_timing.py
index dcfcc48df..a5bd8dd8a 100644
--- a/tests/sync/test_resource_timing.py
+++ b/tests/sync/test_resource_timing.py
@@ -15,7 +15,6 @@
 from typing import Dict
 
 import pytest
-from flaky import flaky
 
 from playwright.sync_api import Browser, Page
 from tests.server import Server
@@ -33,7 +32,6 @@ def test_should_work(page: Page, server: Server) -> None:
     assert timing["responseEnd"] < 10000
 
 
-@flaky
 def test_should_work_for_subresource(
     page: Page, server: Server, is_win: bool, is_mac: bool, is_webkit: bool
 ) -> None:
@@ -51,7 +49,6 @@ def test_should_work_for_subresource(
     assert timing["responseEnd"] < 10000
 
 
-@flaky  # Upstream flaky
 def test_should_work_for_ssl(
     browser: Browser, https_server: Server, is_mac: bool, is_webkit: bool
 ) -> None:
diff --git a/tests/sync/test_route_web_socket.py b/tests/sync/test_route_web_socket.py
new file mode 100644
index 000000000..0cc8eda5d
--- /dev/null
+++ b/tests/sync/test_route_web_socket.py
@@ -0,0 +1,374 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+import time
+from typing import Any, Awaitable, Callable, Literal, Optional, Union
+
+from playwright.sync_api import Browser, Frame, Page, WebSocketRoute
+from tests.server import Server, WebSocketProtocol
+
+
+def assert_equal(
+    actual_cb: Callable[[], Union[Any, Awaitable[Any]]], expected: Any
+) -> None:
+    __tracebackhide__ = True
+    start_time = time.time()
+    attempts = 0
+    while True:
+        actual = actual_cb()
+        if actual == expected:
+            return
+        attempts += 1
+        if time.time() - start_time > 10:
+            raise TimeoutError(f"Timed out after 10 seconds. Last actual was: {actual}")
+        time.sleep(0.1)
+
+
+def setup_ws(
+    target: Union[Page, Frame],
+    port: int,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    target.goto("about:blank")
+    target.evaluate(
+        """({ port, binaryType }) => {
+    window.log = [];
+    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
+    window.ws.binaryType = binaryType;
+    window.ws.addEventListener('open', () => window.log.push('open'));
+    window.ws.addEventListener('close', event => window.log.push(`close code=${event.code} reason=${event.reason} wasClean=${event.wasClean}`));
+    window.ws.addEventListener('error', event => window.log.push(`error`));
+    window.ws.addEventListener('message', async event => {
+      let data;
+      if (typeof event.data === 'string')
+        data = event.data;
+      else if (event.data instanceof Blob)
+        data = 'blob:' + event.data.text();
+      else
+        data = 'arraybuffer:' + (new Blob([event.data])).text();
+      window.log.push(`message: data=${data} origin=${event.origin} lastEventId=${event.lastEventId}`);
+    });
+    window.wsOpened = new Promise(f => window.ws.addEventListener('open', () => f()));
+  }""",
+        {"port": port, "binaryType": protocol},
+    )
+
+
+def test_should_work_with_ws_close(page: Page, server: Server) -> None:
+    route: Optional["WebSocketRoute"] = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.connect_to_server()
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+
+    with server.expect_websocket() as ws_task:
+        setup_ws(page, server.PORT, "blob")
+    page.evaluate("window.wsOpened")
+    ws = ws_task.value
+    assert route
+    route.send("hello")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    closed_event = []
+    ws.events.once("close", lambda code, reason: closed_event.append((code, reason)))
+    route.close(code=3009, reason="oops")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3009 reason=oops wasClean=true",
+        ],
+    )
+    assert_equal(lambda: closed_event, [(3009, "oops")])
+
+
+def test_should_pattern_match(page: Page, server: Server) -> None:
+    page.route_web_socket(re.compile(r".*/ws$"), lambda ws: ws.connect_to_server())
+    page.route_web_socket(
+        "**/mock-ws", lambda ws: ws.on_message(lambda message: ws.send("mock-response"))
+    )
+
+    page.goto("about:blank")
+    with server.expect_websocket() as ws_info:
+        page.evaluate(
+            """async ({ port }) => {
+                window.log = [];
+                window.ws1 = new WebSocket('ws://localhost:' + port + '/ws');
+                window.ws1.addEventListener('message', event => window.log.push(`ws1:${event.data}`));
+                window.ws2 = new WebSocket('ws://localhost:' + port + '/something/something/mock-ws');
+                window.ws2.addEventListener('message', event => window.log.push(`ws2:${event.data}`));
+                await Promise.all([
+                    new Promise(f => window.ws1.addEventListener('open', f)),
+                    new Promise(f => window.ws2.addEventListener('open', f)),
+                ]);
+            }""",
+            {"port": server.PORT},
+        )
+    ws = ws_info.value
+    ws.events.on("message", lambda payload, isBinary: ws.sendMessage(b"response"))
+
+    page.evaluate("window.ws1.send('request')")
+    assert_equal(lambda: page.evaluate("window.log"), ["ws1:response"])
+
+    page.evaluate("window.ws2.send('request')")
+    assert_equal(
+        lambda: page.evaluate("window.log"), ["ws1:response", "ws2:mock-response"]
+    )
+
+
+def test_should_work_with_server(page: Page, server: Server) -> None:
+    route = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        server = ws.connect_to_server()
+
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+                return
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                server.send("modified")
+                return
+            server.send(message)
+
+        ws.on_message(_ws_on_message)
+
+        def _server_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                ws.send("modified")
+                return
+            ws.send(message)
+
+        server.on_message(_server_on_message)
+        server.send("fake")
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+    log = []
+
+    def _once_web_socket_connection(ws: WebSocketProtocol) -> None:
+        ws.events.on(
+            "message", lambda data, is_binary: log.append(f"message: {data.decode()}")
+        )
+        ws.events.on(
+            "close",
+            lambda code, reason: log.append(f"close: code={code} reason={reason}"),
+        )
+
+    server.once_web_socket_connection(_once_web_socket_connection)
+
+    with server.expect_websocket() as ws_info:
+        setup_ws(page, server.PORT, "blob")
+    page.evaluate("window.wsOpened")
+    ws = ws_info.value
+    assert_equal(lambda: log, ["message: fake"])
+
+    ws.sendMessage(b"to-modify")
+    ws.sendMessage(b"to-block")
+    ws.sendMessage(b"pass-server")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.send('to-respond');
+        window.ws.send('to-modify');
+        window.ws.send('to-block');
+        window.ws.send('pass-client');
+    }"""
+    )
+    assert_equal(
+        lambda: log, ["message: fake", "message: modified", "message: pass-client"]
+    )
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    assert route
+    route.send("another")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.send('pass-client-2');
+    }"""
+    )
+    assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.close(3009, 'problem');
+    }"""
+    )
+    assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+            "close: code=3009 reason=problem",
+        ],
+    )
+
+
+def test_should_work_without_server(page: Page, server: Server) -> None:
+    route = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+
+        ws.on_message(_ws_on_message)
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+    setup_ws(page, server.PORT, "blob")
+
+    page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('to-respond');
+        window.ws.send('to-block');
+        window.ws.send('to-respond');
+    }"""
+    )
+
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    assert route
+    route.send("another")
+    # wait for the message to be processed
+    page.wait_for_timeout(100)
+    route.close(code=3008, reason="oops")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3008 reason=oops wasClean=true",
+        ],
+    )
+
+
+def test_should_work_with_base_url(browser: Browser, server: Server) -> None:
+    context = browser.new_context(base_url=f"http://localhost:{server.PORT}")
+    page = context.new_page()
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.on_message(lambda message: ws.send(message))
+
+    page.route_web_socket("/ws", _handle_ws)
+    setup_ws(page, server.PORT, "blob")
+
+    page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('echo');
+    }"""
+    )
+
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=echo origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    context.close()
+
+
+def test_should_work_with_no_trailing_slash(page: Page, server: Server) -> None:
+    log: list[str] = []
+
+    async def handle_ws(ws: WebSocketRoute) -> None:
+        def on_message(message: Union[str, bytes]) -> None:
+            assert isinstance(message, str)
+            log.append(message)
+            ws.send("response")
+
+        ws.on_message(on_message)
+
+    # No trailing slash in the route pattern
+    page.route_web_socket(f"ws://localhost:{server.PORT}", handle_ws)
+
+    page.goto("about:blank")
+    page.evaluate(
+        """({ port }) => {
+            window.log = [];
+            // No trailing slash in WebSocket URL
+            window.ws = new WebSocket('ws://localhost:' + port);
+            window.ws.addEventListener('message', event => window.log.push(event.data));
+        }""",
+        {"port": server.PORT},
+    )
+
+    assert_equal(lambda: page.evaluate("window.ws.readyState"), 1)  # WebSocket.OPEN
+    page.evaluate("window.ws.send('query')")
+    assert_equal(lambda: log, ["query"])
+    assert_equal(lambda: page.evaluate("window.log"), ["response"])
diff --git a/tests/sync/test_sync.py b/tests/sync/test_sync.py
index 64eace1e9..92d40c19a 100644
--- a/tests/sync/test_sync.py
+++ b/tests/sync/test_sync.py
@@ -346,3 +346,15 @@ def test_call_sync_method_after_playwright_close_with_own_loop(
     p.start()
     p.join()
     assert p.exitcode == 0
+
+
+def test_should_return_proper_api_name_on_error(page: Page) -> None:
+    try:
+        page.evaluate("does_not_exist")
+
+        assert (
+            False
+        ), "Accessing undefined JavaScript variable should have thrown exception"
+    except Exception as error:
+        # Each browser returns slightly different error messages, but they should all start with "Page.evaluate:", because that was the Playwright method where the error originated
+        assert str(error).startswith("Page.evaluate:")
diff --git a/tests/sync/test_tracing.py b/tests/sync/test_tracing.py
index eaef24e00..ce26600e5 100644
--- a/tests/sync/test_tracing.py
+++ b/tests/sync/test_tracing.py
@@ -13,12 +13,21 @@
 # limitations under the License.
 
 import re
+import threading
 from pathlib import Path
-from typing import Any, Dict, List
-
-from playwright.sync_api import Browser, BrowserContext, BrowserType, Page
+from typing import Callable, ContextManager
+
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    Page,
+    Response,
+    expect,
+)
 from tests.server import Server
-from tests.utils import get_trace_actions, parse_trace
+
+from .conftest import TraceViewerPage
 
 
 def test_browser_context_output_trace(
@@ -30,6 +39,14 @@ def test_browser_context_output_trace(
     page.goto(server.PREFIX + "/grid.html")
     context.tracing.stop(path=tmp_path / "trace.zip")
     assert Path(tmp_path / "trace.zip").exists()
+    context.close()
+
+
+def test_start_stop(browser: Browser) -> None:
+    context = browser.new_context()
+    context.tracing.start()
+    context.tracing.stop()
+    context.close()
 
 
 def test_browser_context_should_not_throw_when_stopping_without_start_but_not_exporting(
@@ -56,30 +73,64 @@ def test_browser_context_output_trace_chunk(
     button.click()
     context.tracing.stop_chunk(path=tmp_path / "trace2.zip")
     assert Path(tmp_path / "trace2.zip").exists()
+    context.close()
 
 
 def test_should_collect_sources(
-    context: BrowserContext, page: Page, server: Server, tmp_path: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
     context.tracing.start(sources=True)
     page.goto(server.EMPTY_PAGE)
     page.set_content("<button>Click</button>")
-    page.click("button")
+
+    def my_method_outer() -> None:
+        def my_method_inner() -> None:
+            page.get_by_text("Click").click()
+
+        my_method_inner()
+
+    my_method_outer()
     path = tmp_path / "trace.zip"
     context.tracing.stop(path=path)
 
-    (resources, events) = parse_trace(path)
-    current_file_content = Path(__file__).read_bytes()
-    found_current_file = False
-    for name, resource in resources.items():
-        if resource == current_file_content:
-            found_current_file = True
-            break
-    assert found_current_file
+    with show_trace_viewer(path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        trace_viewer.show_source_tab()
+        # Check that stack frames are shown (they might be anonymous in Python)
+        expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"my_method_inner"),
+                re.compile(r"my_method_outer"),
+                re.compile(r"test_should_collect_sources"),
+            ]
+        )
+
+        trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        expect(trace_viewer.page.locator(".source-tab-file-name")).to_have_attribute(
+            "title", re.compile(r".*test_.*\.py")
+        )
+        expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
 
 
 def test_should_collect_trace_with_resources_but_no_js(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
     context.tracing.start(screenshots=True, snapshots=True)
     page.goto(server.PREFIX + "/frames/frame.html")
@@ -87,95 +138,118 @@ def test_should_collect_trace_with_resources_but_no_js(
     page.click('"Click"')
     page.mouse.move(20, 20)
     page.mouse.dblclick(30, 30)
+    page.request.get(server.EMPTY_PAGE)
     page.keyboard.insert_text("abc")
     page.wait_for_timeout(2000)  # Give it some time to produce screenshots.
-    page.route(
-        "**/empty.html", lambda route: route.continue_()
-    )  # should produce a route.continue_ entry.
+    page.route("**/empty.html", lambda route: route.continue_())
     page.goto(server.EMPTY_PAGE)
-    page.goto(
-        server.PREFIX + "/one-style.html"
-    )  # should not produce a route.continue_ entry since we continue all routes if no match.
+    page.goto(server.PREFIX + "/one-style.html")
     page.close()
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.click",
-        "Mouse.move",
-        "Mouse.dblclick",
-        "Keyboard.insert_text",
-        "Page.wait_for_timeout",
-        "Page.route",
-        "Page.goto",
-        "Route.continue_",
-        "Page.goto",
-        "Page.close",
-    ]
-
-    assert len(list(filter(lambda e: e["type"] == "frame-snapshot", events))) >= 1
-    assert len(list(filter(lambda e: e["type"] == "screencast-frame", events))) >= 1
-    style = list(
-        filter(
-            lambda e: e["type"] == "resource-snapshot"
-            and e["snapshot"]["request"]["url"].endswith("style.css"),
-            events,
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/frames/frame\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+                re.compile(r"Mouse move"),
+                re.compile(r"Double click"),
+                re.compile(r"GET \"/empty\.html\""),
+                re.compile(r'Insert "abc"'),
+                re.compile(r"Wait for timeout"),
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Navigate to "/one-style\.html"'),
+                re.compile(r"Close"),
+            ]
         )
-    )[0]
-    assert style
-    assert style["snapshot"]["response"]["content"]["_sha1"]
-    script = list(
-        filter(
-            lambda e: e["type"] == "resource-snapshot"
-            and e["snapshot"]["request"]["url"].endswith("script.js"),
-            events,
+
+        trace_viewer.select_action("Set content")
+        expect(trace_viewer.page.locator(".browser-frame-address-bar")).to_have_text(
+            server.PREFIX + "/frames/frame.html"
+        )
+        frame = trace_viewer.snapshot_frame("Set content", 0, False)
+        expect(frame.locator("button")).to_have_text("Click")
+
+
+def test_should_correctly_determine_sync_apiname(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable,
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+
+    received_response = threading.Event()
+
+    def _handle_response(response: Response) -> None:
+        response.request.all_headers()
+        response.text()
+        received_response.set()
+
+    page.once("response", _handle_response)
+    page.goto(server.PREFIX + "/grid.html")
+    received_response.wait()
+
+    page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_file_path)
+
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/grid\.html"'),
+                re.compile(r"Close"),
+            ]
         )
-    )[0]
-    assert script
-    assert script["snapshot"]["response"]["content"].get("_sha1") is None
 
 
 def test_should_collect_two_traces(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
     context.tracing.start(screenshots=True, snapshots=True)
     page.goto(server.EMPTY_PAGE)
     page.set_content("<button>Click</button>")
     page.click('"Click"')
-    tracing1_path = tmpdir / "trace1.zip"
+    tracing1_path = tmp_path / "trace1.zip"
     context.tracing.stop(path=tracing1_path)
 
     context.tracing.start(screenshots=True, snapshots=True)
     page.dblclick('"Click"')
     page.close()
-    tracing2_path = tmpdir / "trace2.zip"
+    tracing2_path = tmp_path / "trace2.zip"
     context.tracing.stop(path=tracing2_path)
 
-    (_, events) = parse_trace(tracing1_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.click",
-    ]
-
-    (_, events) = parse_trace(tracing2_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == ["Page.dblclick", "Page.close"]
-
+    with show_trace_viewer(tracing1_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
 
-def test_should_not_throw_when_stopping_without_start_but_not_exporting(
-    context: BrowserContext,
-) -> None:
-    context.tracing.stop()
+    with show_trace_viewer(tracing2_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Double click"),
+                re.compile(r"Close"),
+            ]
+        )
 
 
 def test_should_work_with_playwright_context_managers(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
     context.tracing.start(screenshots=True, snapshots=True)
     page.goto(server.EMPTY_PAGE)
@@ -187,24 +261,29 @@ def test_should_work_with_playwright_context_managers(
 
     with page.expect_popup():
         page.evaluate("window._popup = window.open(document.location.href)")
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert events[0]["type"] == "context-options"
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.set_content",
-        "Page.expect_console_message",
-        "Page.evaluate",
-        "Page.click",
-        "Page.expect_popup",
-        "Page.evaluate",
-    ]
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r'Wait for event "page\.expect_event\(console\)"'),
+                re.compile(r"Evaluate"),
+                re.compile(r"Click"),
+                re.compile(r'Wait for event "page\.expect_event\(popup\)"'),
+                re.compile(r"Evaluate"),
+            ]
+        )
 
 
 def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
-    context: BrowserContext, page: Page, server: Server, tmpdir: Path
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
     context.tracing.start(screenshots=True, snapshots=True)
 
@@ -212,67 +291,100 @@ def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
     page.wait_for_load_state("load")
     page.wait_for_load_state("load")
 
-    trace_file_path = tmpdir / "trace.zip"
+    trace_file_path = tmp_path / "trace.zip"
     context.tracing.stop(path=trace_file_path)
 
-    (_, events) = parse_trace(trace_file_path)
-    assert get_trace_actions(events) == [
-        "Page.goto",
-        "Page.wait_for_load_state",
-        "Page.wait_for_load_state",
-    ]
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+            ]
+        )
 
 
 def test_should_respect_traces_dir_and_name(
     browser_type: BrowserType,
     server: Server,
-    tmpdir: Path,
-    launch_arguments: Any,
+    tmp_path: Path,
+    launch_arguments: dict,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
 ) -> None:
-    traces_dir = tmpdir / "traces"
+    traces_dir = tmp_path / "traces"
     browser = browser_type.launch(traces_dir=traces_dir, **launch_arguments)
     context = browser.new_context()
     page = context.new_page()
 
     context.tracing.start(name="name1", snapshots=True)
     page.goto(server.PREFIX + "/one-style.html")
-    context.tracing.stop_chunk(path=tmpdir / "trace1.zip")
+    context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
     assert (traces_dir / "name1.trace").exists()
     assert (traces_dir / "name1.network").exists()
 
     context.tracing.start_chunk(name="name2")
     page.goto(server.PREFIX + "/har.html")
-    context.tracing.stop(path=tmpdir / "trace2.zip")
+    context.tracing.stop(path=tmp_path / "trace2.zip")
     assert (traces_dir / "name2.trace").exists()
     assert (traces_dir / "name2.network").exists()
 
     browser.close()
 
-    def resource_names(resources: Dict[str, bytes]) -> List[str]:
-        return sorted(
+    with show_trace_viewer(tmp_path / "trace1.zip") as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/one-style\.html"'),
+            ]
+        )
+        frame = trace_viewer.snapshot_frame('Navigate to "/one-style.html"', 0, False)
+        expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        expect(frame.locator("body")).to_have_text("hello, world!")
+
+    with show_trace_viewer(tmp_path / "trace2.zip") as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
             [
-                re.sub(r"^resources/.*\.(html|css)$", r"resources/XXX.\g<1>", file)
-                for file in resources.keys()
+                re.compile(r'Navigate to "/har\.html"'),
             ]
         )
+        frame = trace_viewer.snapshot_frame('Navigate to "/har.html"', 0, False)
+        expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        expect(frame.locator("body")).to_have_text("hello, world!")
+
+
+def test_should_show_tracing_group_in_action_list(
+    context: BrowserContext,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start()
+    page = context.new_page()
 
-    (resources, events) = parse_trace(tmpdir / "trace1.zip")
-    assert get_trace_actions(events) == ["Page.goto"]
-    assert resource_names(resources) == [
-        "resources/XXX.css",
-        "resources/XXX.html",
-        "trace.network",
-        "trace.stacks",
-        "trace.trace",
-    ]
-
-    (resources, events) = parse_trace(tmpdir / "trace2.zip")
-    assert get_trace_actions(events) == ["Page.goto"]
-    assert resource_names(resources) == [
-        "resources/XXX.css",
-        "resources/XXX.html",
-        "resources/XXX.html",
-        "trace.network",
-        "trace.stacks",
-        "trace.trace",
-    ]
+    context.tracing.group("outer group")
+    page.goto("data:text/html,<!DOCTYPE html><body><div>Hello world</div></body>")
+    context.tracing.group("inner group 1")
+    page.locator("body").click()
+    context.tracing.group_end()
+    context.tracing.group("inner group 2")
+    page.get_by_text("Hello").is_visible()
+    context.tracing.group_end()
+    context.tracing.group_end()
+
+    trace_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_path)
+
+    with show_trace_viewer(trace_path) as trace_viewer:
+        trace_viewer.expand_action("inner group 1")
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Create page"),
+                re.compile(r"outer group"),
+                re.compile(r"Navigate to \"data:\""),
+                re.compile(r"inner group 1"),
+                re.compile(r"Click"),
+                re.compile(r"inner group 2"),
+            ]
+        )
diff --git a/tests/sync/test_video.py b/tests/sync/test_video.py
index ec45c1fad..3ae1daa21 100644
--- a/tests/sync/test_video.py
+++ b/tests/sync/test_video.py
@@ -23,85 +23,85 @@
 
 
 def test_should_expose_video_path(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
     page = browser.new_page(
-        record_video_dir=tmpdir, record_video_size={"width": 100, "height": 200}
+        record_video_dir=tmp_path, record_video_size={"width": 100, "height": 200}
     )
     page.goto(server.PREFIX + "/grid.html")
     video = page.video
     assert video
     path = video.path()
     assert repr(page.video) == f"<Video page={page}>"
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     page.wait_for_timeout(1000)
     page.context.close()
 
 
-def test_video_should_exist(browser: Browser, tmpdir: Path, server: Server) -> None:
-    page = browser.new_page(record_video_dir=tmpdir)
+def test_video_should_exist(browser: Browser, tmp_path: Path, server: Server) -> None:
+    page = browser.new_page(record_video_dir=tmp_path)
     page.goto(server.PREFIX + "/grid.html")
     video = page.video
     assert video
     path = video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     page.wait_for_timeout(1000)
     page.context.close()
     assert os.path.exists(path)
 
 
-def test_record_video_to_path(browser: Browser, tmpdir: Path, server: Server) -> None:
-    page = browser.new_page(record_video_dir=tmpdir)
+def test_record_video_to_path(browser: Browser, tmp_path: Path, server: Server) -> None:
+    page = browser.new_page(record_video_dir=tmp_path)
     page.goto(server.PREFIX + "/grid.html")
     video = page.video
     assert video
     path = video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     page.wait_for_timeout(1000)
     page.context.close()
     assert os.path.exists(path)
 
 
 def test_record_video_to_path_persistent(
-    browser_type: BrowserType, tmpdir: Path, server: Server, launch_arguments: Dict
+    browser_type: BrowserType, tmp_path: Path, server: Server, launch_arguments: Dict
 ) -> None:
     context = browser_type.launch_persistent_context(
-        tmpdir, **launch_arguments, record_video_dir=tmpdir
+        tmp_path, **launch_arguments, record_video_dir=tmp_path
     )
     page = context.pages[0]
     page.goto(server.PREFIX + "/grid.html")
     video = page.video
     assert video
     path = video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     page.wait_for_timeout(1000)
     context.close()
     assert os.path.exists(path)
 
 
 def test_record_video_can_get_video_path_immediately(
-    browser_type: BrowserType, tmpdir: Path, launch_arguments: Dict
+    browser_type: BrowserType, tmp_path: Path, launch_arguments: Dict
 ) -> None:
     context = browser_type.launch_persistent_context(
-        tmpdir, **launch_arguments, record_video_dir=tmpdir
+        tmp_path, **launch_arguments, record_video_dir=tmp_path
     )
     page = context.pages[0]
     video = page.video
     assert video
     path = video.path()
-    assert str(tmpdir) in str(path)
+    assert str(tmp_path) in str(path)
     page.wait_for_timeout(1000)
     context.close()
     assert os.path.exists(path)
 
 
 def test_should_error_if_page_not_closed_before_save_as(
-    browser: Browser, tmpdir: Path, server: Server
+    browser: Browser, tmp_path: Path, server: Server
 ) -> None:
-    page = browser.new_page(record_video_dir=tmpdir)
+    page = browser.new_page(record_video_dir=tmp_path)
     page.goto(server.PREFIX + "/grid.html")
     page.wait_for_timeout(1000)  # Give it some time to record.
-    out_path = tmpdir / "some-video.webm"
+    out_path = tmp_path / "some-video.webm"
     with pytest.raises(Error) as err:
         video = page.video
         assert video
diff --git a/tests/test_reference_count_async.py b/tests/test_reference_count_async.py
index cc1564aa6..5eb1c28a1 100644
--- a/tests/test_reference_count_async.py
+++ b/tests/test_reference_count_async.py
@@ -13,6 +13,8 @@
 # limitations under the License.
 
 import gc
+import os
+import tempfile
 from collections import defaultdict
 from typing import Any
 
@@ -59,6 +61,7 @@ def handle_network_response_received(event: Any) -> None:
 
     pw_objects: defaultdict = defaultdict(int)
     for o in objgraph.by_type("dict"):
+        assert isinstance(o, dict)
         name = o.get("_type")
         # https://github.com/microsoft/playwright-python/issues/1602
         if o.get("__pw__is_last_network_response_received_event", False):
@@ -70,3 +73,62 @@ def handle_network_response_received(event: Any) -> None:
     assert "Dialog" not in pw_objects
     assert "Request" not in pw_objects
     assert "Route" not in pw_objects
+
+
+@pytest.mark.asyncio
+async def test_tracing_should_not_leak_protocol_callbacks(browser_name: str) -> None:
+    """
+    Regression test for https://github.com/microsoft/playwright-python/issues/2977
+
+    This test ensures that ProtocolCallback objects don't accumulate when tracing is enabled.
+    The memory leak occurred because no_reply callbacks were created with circular references
+    but never cleaned up.
+    """
+
+    def count_protocol_callbacks() -> int:
+        """Count ProtocolCallback objects in memory."""
+        gc.collect()
+        count = 0
+        for obj in gc.get_objects():
+            if (
+                hasattr(obj, "__class__")
+                and obj.__class__.__name__ == "ProtocolCallback"
+            ):
+                count += 1
+        return count
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        trace_file = os.path.join(temp_dir, "test_trace.zip")
+
+        async with async_playwright() as p:
+            browser = await p[browser_name].launch()
+            context = await browser.new_context()
+
+            # Start tracing to trigger the creation of no_reply callbacks
+            await context.tracing.start(screenshots=True, snapshots=True)
+
+            initial_count = count_protocol_callbacks()
+
+            # Perform operations that would create tracing callbacks
+            for _ in range(3):
+                page = await context.new_page()
+                await page.goto("data:text/html,<h1>Test Page</h1>")
+                await page.wait_for_load_state("networkidle")
+                await page.evaluate(
+                    "document.querySelector('h1').textContent = 'Modified'"
+                )
+                await page.close()
+
+            # Stop tracing
+            await context.tracing.stop(path=trace_file)
+            await browser.close()
+
+    # Force garbage collection and check callback count
+    gc.collect()
+    final_count = count_protocol_callbacks()
+
+    # The key assertion: callback count should not have increased significantly
+    # Allow for a small number of legitimate callbacks but ensure no major leak
+    assert (
+        final_count - initial_count <= 5
+    ), f"ProtocolCallback leak detected: initial={initial_count}, final={final_count}, leaked={final_count - initial_count}"
diff --git a/tests/utils.py b/tests/utils.py
index c6c10a810..6a78eefaf 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -12,50 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
-import zipfile
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, TypeVar
-
-
-def parse_trace(path: Path) -> Tuple[Dict[str, bytes], List[Any]]:
-    resources: Dict[str, bytes] = {}
-    with zipfile.ZipFile(path, "r") as zip:
-        for name in zip.namelist():
-            resources[name] = zip.read(name)
-    action_map: Dict[str, Any] = {}
-    events: List[Any] = []
-    for name in ["trace.trace", "trace.network"]:
-        for line in resources[name].decode().splitlines():
-            if not line:
-                continue
-            event = json.loads(line)
-            if event["type"] == "before":
-                event["type"] = "action"
-                action_map[event["callId"]] = event
-                events.append(event)
-            elif event["type"] == "input":
-                pass
-            elif event["type"] == "after":
-                existing = action_map[event["callId"]]
-                existing["error"] = event.get("error", None)
-            else:
-                events.append(event)
-    return (resources, events)
-
-
-def get_trace_actions(events: List[Any]) -> List[str]:
-    action_events = sorted(
-        list(
-            filter(
-                lambda e: e["type"] == "action",
-                events,
-            )
-        ),
-        key=lambda e: e["startTime"],
-    )
-    return [e["apiName"] for e in action_events]
-
+from typing import Optional, TypeVar
 
 TARGET_CLOSED_ERROR_MESSAGE = "Target page, context or browser has been closed"
 
diff --git a/utils/docker/Dockerfile.focal b/utils/docker/Dockerfile.focal
deleted file mode 100644
index 247b58b49..000000000
--- a/utils/docker/Dockerfile.focal
+++ /dev/null
@@ -1,49 +0,0 @@
-FROM ubuntu:focal
-
-ARG DEBIAN_FRONTEND=noninteractive
-ARG TZ=America/Los_Angeles
-ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-focal"
-
-# === INSTALL Python ===
-
-RUN apt-get update && \
-    # Install Python
-    apt-get install -y python3 python3-distutils curl && \
-    update-alternatives --install /usr/bin/python python /usr/bin/python3 1 && \
-    curl -sSL https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
-    python get-pip.py && \
-    rm get-pip.py && \
-    # Feature-parity with node.js base images.
-    apt-get install -y --no-install-recommends git openssh-client gpg && \
-    # clean apt cache
-    rm -rf /var/lib/apt/lists/* && \
-    # Create the pwuser
-    adduser pwuser
-
-# === BAKE BROWSERS INTO IMAGE ===
-
-ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
-
-# 1. Add tip-of-tree Playwright package to install its browsers.
-#    The package should be built beforehand from tip-of-tree Playwright.
-COPY ./dist/*-manylinux*.whl /tmp/
-
-# 2. Bake in browsers & deps.
-#    Browsers will be downloaded in `/ms-playwright`.
-#    Note: make sure to set 777 to the registry so that any user can access
-#    registry.
-RUN mkdir /ms-playwright && \
-    mkdir /ms-playwright-agent && \
-    cd /ms-playwright-agent && \
-    pip install virtualenv && \
-    virtualenv venv && \
-    . venv/bin/activate && \
-    # if its amd64 then install the manylinux1_x86_64 pip package
-    if [ "$(uname -m)" = "x86_64" ]; then pip install /tmp/*manylinux1_x86_64*.whl; fi && \
-    # if its arm64 then install the manylinux1_aarch64 pip package
-    if [ "$(uname -m)" = "aarch64" ]; then pip install /tmp/*manylinux_2_17_aarch64*.whl; fi && \
-    playwright mark-docker-image "${DOCKER_IMAGE_NAME_TEMPLATE}" && \
-    playwright install --with-deps && rm -rf /var/lib/apt/lists/* && \
-    rm /tmp/*.whl && \
-    rm -rf /ms-playwright-agent && \
-    chmod -R 777 /ms-playwright
diff --git a/utils/docker/Dockerfile.jammy b/utils/docker/Dockerfile.jammy
index 8dab1e1d1..7692ad7c5 100644
--- a/utils/docker/Dockerfile.jammy
+++ b/utils/docker/Dockerfile.jammy
@@ -4,6 +4,9 @@ ARG DEBIAN_FRONTEND=noninteractive
 ARG TZ=America/Los_Angeles
 ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-jammy"
 
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
 # === INSTALL Python ===
 
 RUN apt-get update && \
diff --git a/utils/docker/Dockerfile.noble b/utils/docker/Dockerfile.noble
index 8262bf6a9..2458236a3 100644
--- a/utils/docker/Dockerfile.noble
+++ b/utils/docker/Dockerfile.noble
@@ -4,6 +4,9 @@ ARG DEBIAN_FRONTEND=noninteractive
 ARG TZ=America/Los_Angeles
 ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-noble"
 
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
 # === INSTALL Python ===
 
 RUN apt-get update && \
diff --git a/utils/docker/build.sh b/utils/docker/build.sh
index b28a4807a..98b0b0233 100755
--- a/utils/docker/build.sh
+++ b/utils/docker/build.sh
@@ -3,12 +3,12 @@ set -e
 set +x
 
 if [[ ($1 == '--help') || ($1 == '-h') || ($1 == '') || ($2 == '') ]]; then
-  echo "usage: $(basename $0) {--arm64,--amd64} {focal,jammy} playwright:localbuild-focal"
+  echo "usage: $(basename $0) {--arm64,--amd64} {jammy,noble} playwright:localbuild-noble"
   echo
-  echo "Build Playwright docker image and tag it as 'playwright:localbuild-focal'."
+  echo "Build Playwright docker image and tag it as 'playwright:localbuild-noble'."
   echo "Once image is built, you can run it with"
   echo ""
-  echo "  docker run --rm -it playwright:localbuild-focal /bin/bash"
+  echo "  docker run --rm -it playwright:localbuild-noble /bin/bash"
   echo ""
   echo "NOTE: this requires on Playwright PIP dependencies to be installed"
   echo ""
@@ -23,7 +23,9 @@ trap "cleanup; cd $(pwd -P)" EXIT
 cd "$(dirname "$0")"
 
 pushd ../../
-python setup.py bdist_wheel --all
+for wheel in $(python setup.py --list-wheels); do
+  PLAYWRIGHT_TARGET_WHEEL=$wheel python -m build --wheel
+done
 popd
 mkdir dist/
 cp ../../dist/*-manylinux*.whl dist/
diff --git a/utils/docker/publish_docker.sh b/utils/docker/publish_docker.sh
index 309edb63a..3af48306b 100755
--- a/utils/docker/publish_docker.sh
+++ b/utils/docker/publish_docker.sh
@@ -21,11 +21,6 @@ else
   exit 1
 fi
 
-# Ubuntu 20.04
-FOCAL_TAGS=(
-  "v${PW_VERSION}-focal"
-)
-
 # Ubuntu 22.04
 JAMMY_TAGS=(
   "v${PW_VERSION}-jammy"
@@ -69,14 +64,12 @@ install_oras_if_needed() {
 publish_docker_images_with_arch_suffix() {
   local FLAVOR="$1"
   local TAGS=()
-  if [[ "$FLAVOR" == "focal" ]]; then
-    TAGS=("${FOCAL_TAGS[@]}")
-  elif [[ "$FLAVOR" == "jammy" ]]; then
+  if [[ "$FLAVOR" == "jammy" ]]; then
     TAGS=("${JAMMY_TAGS[@]}")
   elif [[ "$FLAVOR" == "noble" ]]; then
     TAGS=("${NOBLE_TAGS[@]}")
   else
-    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'focal', or 'jammy'"
+    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'jammy', or 'noble'"
     exit 1
   fi
   local ARCH="$2"
@@ -97,14 +90,12 @@ publish_docker_images_with_arch_suffix() {
 publish_docker_manifest () {
   local FLAVOR="$1"
   local TAGS=()
-  if [[ "$FLAVOR" == "focal" ]]; then
-    TAGS=("${FOCAL_TAGS[@]}")
-  elif [[ "$FLAVOR" == "jammy" ]]; then
+  if [[ "$FLAVOR" == "jammy" ]]; then
     TAGS=("${JAMMY_TAGS[@]}")
   elif [[ "$FLAVOR" == "noble" ]]; then
     TAGS=("${NOBLE_TAGS[@]}")
   else
-    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'focal', or 'jammy'"
+    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'jammy', or 'noble'"
     exit 1
   fi
 
@@ -123,11 +114,6 @@ publish_docker_manifest () {
   done
 }
 
-# Focal
-publish_docker_images_with_arch_suffix focal amd64
-publish_docker_images_with_arch_suffix focal arm64
-publish_docker_manifest focal amd64 arm64
-
 # Jammy
 publish_docker_images_with_arch_suffix jammy amd64
 publish_docker_images_with_arch_suffix jammy arm64