diff --git a/.azure-pipelines/publish.yml b/.azure-pipelines/publish.yml
index 10d6ead8b..1a2e0e7a4 100644
--- a/.azure-pipelines/publish.yml
+++ b/.azure-pipelines/publish.yml
@@ -29,29 +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@4
+      - job: Publish
+        dependsOn: Build
+        templateContext:
+          type: releaseJob
+          isProduction: true
           inputs:
-            ConnectedServiceName: 'Playwright-ESRP'
-            Intent: 'PackageDistribution'
-            ContentType: 'PyPi'
-            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..9a6adbd03
--- /dev/null
+++ b/.claude/skills/playwright-roll/SKILL.md
@@ -0,0 +1,285 @@
+---
+name: playwright-roll
+description: Roll Playwright Python to a new driver version. Walks the upstream `docs/src/api/` commit range, ports each public-API change, suppresses the rest in `expected_api_mismatch.txt`, regenerates the typed surface, and adds tests.
+---
+
+# Rolling Playwright Python
+
+The goal of a roll is to move `driver_version` in `setup.py` to a new release, port every public API change introduced upstream during that interval, and suppress the rest, so that `./scripts/update_api.sh` runs clean and the test suite still passes.
+
+The previous human-facing summary lives in `../../../ROLLING.md`. This skill is the operational playbook — read it end to end before starting.
+
+## Mental model
+
+The Python port is hand-written code in `playwright/_impl/`, plus a generator (`scripts/generate_*.py`, `scripts/documentation_provider.py`) that:
+
+1. introspects the Python `_impl` classes via `inspect`,
+2. emits typed wrapper classes into `playwright/{async,sync}_api/_generated.py`, and
+3. diffs the introspected surface against `playwright/driver/package/api.json` (downloaded inside the new driver wheel).
+
+Anything in `api.json` that is missing or differently typed in `_impl/` causes generation to fail. Three resolutions:
+
+- **PORT** — the new API is intended for Python (no `langs.only` filter, or `langs.only` includes `"python"`). Implement it in `_impl/`.
+- **MISMATCH** — the API genuinely exists for Python but is shaped differently (a callback signature uses unions, a kwarg uses a legacy name, etc.) and there's a justified reason to keep the divergence. Add a precise line to `scripts/expected_api_mismatch.txt` with a comment explaining *why*.
+- **N/A** — the commit only touches docs, has `* langs: js` (or any other filter that excludes Python), is server-side, Electron-only, or was reverted later in the same release. No action.
+
+The upstream documentation source of truth is `docs/src/api/*.md` in the playwright repo. Every `## method:` / `## property:` / `## event:` / `### option:` / `### param:` block has an optional `* langs: js` (or `js, python`, etc.) filter. The Python doclint resolves these into `langs` fields on each member of `api.json`. **An empty `langs: {}` means "all languages including Python" — *implement it*, don't suppress it.**
+
+> **The mistake the 1.59 roll made twice over:** classifying things as "internal tooling, N/A for Python" based on the *name* of the API (Screencast, Debugger, pickLocator, clearConsoleMessages, artifactsDir, …). Almost all of those had empty `langs: {}` in `api.json` and were real Python APIs. Sounding tooling-y is not a `langs` filter. **The `langs` field on the member in `api.json` is the only authoritative signal.** When in doubt, dump it (see "Verifying classifications" below).
+
+## Pre-flight
+
+You will need two checkouts in the parent directory:
+- `~/code/playwright-python` — this repo.
+- `~/code/playwright` — the upstream playwright monorepo (used read-only for diffing).
+
+Bring upstream up to date and ensure release branches/tags are present:
+
+```sh
+git -C ~/code/playwright fetch --tags
+git -C ~/code/playwright fetch origin 'release-*:release-*'
+```
+
+There is sometimes no `vX.Y.0` tag for the latest release (the bots cut release branches first and tag later). Anchor on commits, not tags — see "Identify the commit range" below.
+
+## Process
+
+### 1. Set up the env
+
+`CONTRIBUTING.md` covers this. Notes from past rolls:
+
+- The repo says Python 3.9 is required, but 3.9+ works. If `python3.9` isn't available, use `python3` (3.12 is fine).
+- If `python3-venv` is missing system-wide, use `uv venv env` instead, then `uv pip install --python env/bin/python --upgrade pip`. Don't try to `apt install` — sudo is denied in the harness.
+- Always activate the venv before any `pip`, `pytest`, `mypy`, or `pre-commit` invocation.
+
+### 2. Bump the driver and download it
+
+```sh
+# Edit setup.py
+driver_version = "<new>"     # e.g. "1.59.1"
+
+source env/bin/activate
+python -m build --wheel       # downloads the new driver from cdn.playwright.dev
+playwright install chromium   # NOT --with-deps; sudo is denied
+```
+
+The wheel build prints `Fetching https://cdn.playwright.dev/builds/driver/playwright-<new>-linux.zip` and unpacks the driver under `playwright/driver/package/`. From this point, `playwright/driver/package/api.json` reflects the new release.
+
+### 3. Identify the commit range
+
+The diff range is "every commit on the new release branch since the previous release was cut". Anchor commits:
+
+- **Previous release end**: the `chore: bump version to vX.Y.0-next` commit on `main`. That commit is the first commit *after* the previous release (X.Y-1) was cut. Use its parent (`<sha>~1`) as the lower bound.
+  ```sh
+  git -C ~/code/playwright log --all --grep="bump version to v" --oneline | head
+  ```
+- **New release end**: the tip of `release-<new>` (or the matching tag if it exists).
+
+Save the commit list, oldest first, scoped to `docs/src/api/`:
+
+```sh
+git -C ~/code/playwright log <prev-anchor>~1..release-<new> --oneline --reverse -- docs/src/api > /tmp/roll-<new>-commits.md
+```
+
+A normal roll yields 50–100 commits. If you see 0 or thousands, the range is wrong.
+
+Format the file as a markdown checklist and add the standard preamble (status legend, where to look up `api.json` etc.) — see the file from the 1.58→1.59 roll for the template.
+
+### 4. Walk the commit list
+
+For each commit, in chronological order:
+
+```sh
+git -C ~/code/playwright show <sha> -- docs/src/api/
+```
+
+Look for:
+- `## (async )?method:` / `## property:` / `## event:` additions or removals;
+- `* langs: ...` lines on those blocks;
+- `### param:` / `### option:` additions or removals;
+- new `class-X.md` files (whole new classes — usually `langs: js`);
+- type changes in `- returns:` lines.
+
+Classify and act.
+
+#### Verifying classifications (do this before suppressing anything)
+
+Before tagging anything as MISMATCH or N/A based on appearance, dump the actual `langs` from `api.json`:
+
+```python
+import json
+data = json.load(open("playwright/driver/package/api.json"))
+classes = {c["name"]: c for c in data}
+for cls_name in ["Page", "BrowserContext", "Screencast", "Debugger"]:
+    cls = classes.get(cls_name)
+    if not cls:
+        continue
+    print(f"\n{cls_name}: cls_langs={cls.get('langs', {})}")
+    for m in cls["members"]:
+        print(f"  {m['name']} kind={m.get('kind')} langs={m.get('langs', {})}")
+```
+
+For options/params nested inside an `Object`-typed arg, walk one level deeper:
+
+```python
+for a in member.get("args", []):
+    if a["name"] == "options":
+        for prop in a.get("type", {}).get("properties", []):
+            print(prop["name"], prop.get("langs", {}))
+```
+
+A few rules of thumb that catch most "actually a PORT" cases:
+- If the *containing class* has empty `langs: {}` and the *member* has empty `langs: {}`, it's for Python — implement it.
+- If the member is empty but a single *option* has `langs: js`, the method is for Python and you only skip that option (e.g. `Screencast.start.size` is `langs: js` while `Screencast.start` itself isn't).
+- If you're about to add three or more `Method not implemented:` entries for the same class, stop — you almost certainly need to implement the class.
+
+#### PORT
+
+Implement the change in `playwright/_impl/<module>.py`. Use the upstream JS implementation as a reference: `~/code/playwright/packages/playwright-core/src/client/<module>.ts`. Translate idioms:
+
+| Upstream JS | Python |
+|---|---|
+| `async foo(): Promise<X>` | `async def foo(self) -> X:` |
+| `foo(): X` (sync getter, no args, no body) | `@property def foo(self) -> X:` (the doc generator treats argument-less sync getters as properties — see `documentation_provider.py:133`. If you make it a method instead, you'll get a "Method vs property mismatch" error.) |
+| `await this._channel.foo({ a, b })` | `await self._channel.send("foo", None, locals_to_params(locals()))` |
+| `(await this._channel.foo()).value` | `await self._channel.send("foo", None)` (Python's `send()` auto-unwraps single-key responses; only call `send_return_as_dict` when the protocol returns multiple keys.) |
+| `(await this._channel.foo()).artifact` (multi-key, may be empty) | `result = await self._channel.send_return_as_dict("foo", None); (result or {}).get("artifact")` — `send_return_as_dict` returns **`None`** (not `{}`) when the protocol response carries no fields. |
+| `try { ... } catch (e) { if (isTargetClosedError(e)) return; throw e; }` | `try: ...; except Exception as e: if is_target_closed_error(e): return; raise` (import from `playwright._impl._errors`) |
+| Inline `[Object]` return like `{endpoint: string}` | A `TypedDict` in `playwright/_impl/_api_structures.py` — *not* `Dict[str, str]`. The doc generator serializes TypedDicts as `{field: type, ...}` via `get_type_hints` and that matches the inline-object form exactly. See `RemoteAddr`, `BrowserBindResult`, `DebuggerPausedDetails`. |
+| `binary` event/return field | The Python channel layer hands you a base64 string. Decode with `base64.b64decode(value)` before exposing as `bytes`. See `Screencast._dispatch_frame`. |
+
+When implementing a new ChannelOwner subclass (one constructed by the protocol with `(parent, type, guid, initializer)`):
+1. Register it in `playwright/_impl/_object_factory.py:create_remote_object` — otherwise the guid resolves to `DummyObject` and downstream code breaks mysteriously.
+2. Import it and add it to `generated_types` in `scripts/generate_api.py`, plus add a `XxxImpl` import in the `header` string.
+
+When implementing a non-ChannelOwner wrapper class (a plain class that holds a Page/Context reference, like `Screencast`, `Clock`):
+- Set `self._loop = parent._loop` and `self._dispatcher_fiber = parent._dispatcher_fiber` in `__init__`. The generated `AsyncBase`/`SyncBase` wrappers read these; missing them gives `AttributeError: 'X' object has no attribute '_loop'` at first use.
+
+When adding a new TypedDict in `_api_structures.py`:
+- Add it to the `from playwright._impl._api_structures import …` line in `scripts/generate_api.py` so the generator can resolve it as a forward reference in type hints.
+- Re-export it from both `playwright/async_api/__init__.py` and `playwright/sync_api/__init__.py`: assignment line plus an entry in `__all__`. Same pattern as `ViewportSize`, `RemoteAddr`.
+
+If the new API was previously suppressed in `expected_api_mismatch.txt`, **remove that line** when implementing it.
+
+If a doc rename involves a *positional* parameter (no default, before any `*`), users almost certainly call it positionally — you can rename freely. The 1.59 `BrowserType.connect.wsEndpoint` → `endpoint` is the canonical example. Don't suppress this kind of rename; just rename in `_impl/`. **Important corollary:** when docs rename a param, the wire-protocol field usually also changed in `packages/protocol/src/protocol.yml` and the server-side dispatcher in `packages/playwright-core/src/server/dispatchers/*Dispatcher.ts`. If so, you must also update the channel-send dict key (e.g. `{"wsEndpoint": …}` → `{"endpoint": …}`). A "Parameter not documented" suppression for a renamed param is a code smell hiding a wire-protocol bug.
+
+#### MISMATCH
+
+A MISMATCH is a *justified, durable* divergence between the docs and the Python surface. Use it sparingly — most apparent mismatches turn out to be PORTs you skipped. Legitimate examples in the current `expected_api_mismatch.txt`:
+
+- Hidden internal kwargs (`Browser.new_context(default_browser_type=)`).
+- Callback signatures where Python explicitly unions one-arg and two-arg variants but the docs document only the canonical form (`Page.route(handler=)`, `WebSocketRoute.on_close(handler=)`).
+
+Add a precise line to `scripts/expected_api_mismatch.txt` with a `# comment` group header explaining *why* the divergence is intentional. The exact wording comes from the generator's error message. Examples:
+
+```
+# One vs two arguments in the callback, Python explicitly unions.
+Parameter type mismatch in Page.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+```
+
+The generator removes lines from `expected_api_mismatch.txt` that no longer match an error. If you see "No longer there: …" in the script's stderr, delete that line.
+
+**Do not suppress** these — they're PORTs in disguise:
+
+- "Internal tooling" classes/methods whose `langs` field is empty (`Screencast.*`, `Debugger.*`, `Page.pick_locator`, `BrowserContext.debugger`, `Browser.bind/unbind`, `Page.{clear,console}_*`). The 1.59 roll suppressed all of these initially, then had to walk every one back. Verify `langs` first.
+- A renamed positional parameter (`Parameter not documented: X.y(old_name=)` + `Parameter not implemented: X.y(new_name=)`). Just rename in `_impl/` and update the channel-send dict key.
+- A `Parameter type mismatch in X.y(return=): documented as {field: T}, code has Dict[str, T]`. Use a TypedDict.
+
+#### N/A
+
+Common N/A flavors:
+- Whole new class with `langs: js` (Disposable, Inspector/Screencast, Debugger, Overlay).
+- Members with `langs: js` (most "tooling" / MCP / agentic features).
+- Doc-only edits (typo fixes, "Improve `not` property sections", etc.).
+- Reverts that cancel an earlier add in the same range (always check the rest of the range before porting something that gets reverted).
+- Java/C# `langs:` blocks.
+- Electron-only changes (`docs/src/api/class-electron.md`).
+
+Tick the box in `/tmp/roll-<new>-commits.md` with one line: `[x] <sha> <subject> — <classification>: <one-liner>`.
+
+### 5. Regenerate
+
+```sh
+./scripts/update_api.sh
+```
+
+The script does, in order:
+1. `git checkout HEAD -- playwright/{async,sync}_api/_generated.py` (resets to last committed),
+2. runs `scripts/generate_{sync,async}_api.py` which dumps to `.x` then renames into place,
+3. invokes `pre-commit run --files` on the generated files.
+
+Failure modes and fixes:
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| `Method not implemented: X.y` | `api.json` documents `X.y`, no Python impl exists. | PORT it, or add a MISMATCH line. |
+| `Parameter not implemented: X.y(z=)` | New parameter on existing method. | Add the kwarg in `_impl/`, or MISMATCH. |
+| `Method vs property mismatch: X.y` | You implemented as a method but the doc treats it as a property (sync, no args, has return type). | Add `@property` in `_impl/`. |
+| `Method not documented: X.y` | Python has it but `api.json` doesn't. | The upstream removed the API; remove from `_impl/` and from `_generated.py` callers. |
+| `Parameter type mismatch in X.y(z=): documented as ..., code has ...` | Type signature doesn't line up. | Match the type in `_impl/`, or MISMATCH it for known historical divergences. |
+| `pyright … reportInconsistentOverload` (single-event class) | A class gained its first event in `api.json`, so the generator emits one `Literal[…]` overload + impl, which pyright wants ≥2 of. | The generator already handles this — `documentation_provider.print_events` emits a second `@typing.overload` with `event: str` plus a generic impl. If you regress this, see how 1.59 handled `CDPSession` getting a `close` event. |
+| `pre-commit` keeps reformatting `_generated.py` on each run | First run after regen always reformats once; rerun until idle. | `pre-commit run --all-files` to settle. |
+| `Parameter not documented: X.y(z=)` | Python has a kwarg the docs don't mention (e.g. legacy name from a doc rename). | If the param is positional with no default, just rename it in `_impl/`. Check `protocol.yml` and the server dispatcher — if the wire field renamed too, also update the channel-send dict key. Only MISMATCH for genuinely hidden internal kwargs (`default_browser_type`). |
+| `KeyError: 'templates'` deep in `inner_serialize_doc_type` | A `Promise<X>\|X` union upstream collapsed to a bare `Promise` with no templates in `api.json`. | `documentation_provider.inner_serialize_doc_type` should treat that as `Any` (`if "templates" not in type: return "Any"`). |
+| `"void" is not defined (reportUndefinedVariable)` in generated event handlers | `api.json` has a `void`-typed event payload that the serializer left as the literal string `"void"`. | `documentation_provider.inner_serialize_doc_type` should map `"void"` to `"None"` alongside `"null"`. |
+| `AttributeError: 'X' object has no attribute '_loop'` (or `_dispatcher_fiber`) at first use of a new wrapper class | The non-ChannelOwner wrapper isn't initializing the fields the generated `AsyncBase`/`SyncBase` reads. | In the wrapper's `__init__`, set `self._loop = parent._loop` and `self._dispatcher_fiber = parent._dispatcher_fiber`. |
+| `'NoneType' object has no attribute 'get'` after `send_return_as_dict` | Method's protocol response carries no fields and `send_return_as_dict` returned `None`. | `(result or {}).get(...)`. |
+| Frame/buffer payload arrives as a `str` instead of `bytes` | Protocol `binary` fields cross the wire as base64. | `base64.b64decode(value)` in the impl before exposing. |
+
+After the script settles, run `pre-commit run --all-files` once more to confirm everything is idle.
+
+### 6. Add tests
+
+For each PORT, add one async test and a matching sync test. Conventions:
+
+- Tests go in the existing topic file (`test_page_network_request.py`, `test_browsercontext.py`, `test_dialog.py`, …) — don't create new files unless there's no obvious home.
+- Use `from playwright.async_api import …`, **not** `from playwright._impl._page import Page` (the impl class doesn't have the public wrappers like `expect_console_message`).
+- For event-info objects, `await message_info.value` (it's an `async` property).
+- Don't write tests that hang the page (e.g. `page.evaluate(... fetch slow ...)` followed by `page.close()` from a fixture) — the request task gets a `TargetClosedError`. Use `page.on("event", handler)` to capture state at event time instead.
+- `playwright install chromium` (no `--with-deps`) is sufficient for the test suite under sandbox.
+
+### 7. Update existing high-touch artifacts
+
+- `setup.py`: already done in step 2.
+- `README.md`: gets the chromium/firefox/webkit version table updated automatically by `scripts/update_versions.py` (called from `update_api.sh`). Don't edit by hand.
+- The "Backport changes" tracking issue on GitHub (filed by `microsoft-playwright-automation`) is the *intent* tracker, but it's frequently out of sync with what's actually been ported. Treat it as a starting point, not the source of truth — the `docs/src/api/` commit walk is authoritative.
+
+### 8. Final verification
+
+```sh
+pre-commit run --all-files
+mypy playwright                 # 2 pre-existing errors in _json_pipe.py and _artifact.py are unrelated
+pytest --browser chromium tests/async/<files-you-touched> tests/sync/<files-you-touched>
+```
+
+Then a smoke regression on a few neighboring suites (`tests/async/test_browser*.py`, `test_cdp_session.py`, `test_tracing.py`, `test_dialog.py`, `test_page_*.py`) to make sure nothing inherent to the port shifted.
+
+## Reference: `expected_api_mismatch.txt` line forms
+
+Exact strings the generator emits (and that this file must contain to suppress):
+
+```
+Method not implemented: <Class>.<snake_method>
+Parameter not implemented: <Class>.<snake_method>(<snake_param>=)
+Parameter not documented: <Class>.<snake_method>(<snake_param>=)
+Method vs property mismatch: <Class>.<snake_method>
+Method not documented: <Class>.<snake_method>
+Parameter type mismatch in <Class>.<snake_method>(<arg>=): documented as <T1>, code has <T2>
+```
+
+Class names use the upstream PascalCase (`BrowserContext`, `BrowserType`); method/param names are converted to `snake_case` matching the Python surface.
+
+## Tips & gotchas
+
+- **`langs.only` is your filter — and the only filter.** Don't classify by name (`Screencast`, `Debugger`, `pickLocator`) or by intuition ("looks like internal tooling"). Always check `langs` in `api.json`. The 1.59 roll cost two extra audit passes by trusting names over `langs`.
+- **Audit your own classifications a second time.** After the first walk through the commit range, before opening the PR, re-read every line in `expected_api_mismatch.txt` you added during this roll and ask "is this divergence justified, or did I skip a port?" Run the `langs`-dump snippet on each suspicious entry. The 1.59 roll's first PR had ~20 wrong suppressions; the second pass cut them to 0.
+- **A cluster of suppressions on the same class is a smell.** If you're about to add five `Method not implemented: Foo.*` lines, you're almost certainly looking at a class that needs to be implemented. Implement the whole thing once and the suppressions disappear.
+- **Watch for revert pairs in the same range.** 1.59 added and reverted `Browser.isRemote` (#39613 / #39620) inside the same release. Walking chronologically lets you skip the add when you see the revert later.
+- **Watch for rename-revert pairs.** 1.59 had `Locator.normalize` → `Locator.toCode` (#39648) → `Locator.normalize` (#39754). Final state wins; only port the last.
+- **Doc renames almost always include a wire-protocol rename.** Whenever you see `### param: X.y.oldName` → `### param: X.y.newName` in a doc commit, also `git -C ~/code/playwright show <sha> -- packages/protocol/src/protocol.yml` and the corresponding `*Dispatcher.ts` file. If the wire field changed too, the channel-send dict key in `_impl/` must change. Suppressing the doc-side mismatch is hiding a real bug — the previous Python code is silently sending an unknown field that the new server ignores.
+- **TypedDicts beat `Dict[str, X]` for any structured return.** When the docs describe a return as `[Object]` with named fields (or even `[Object=Foo]`), define a `TypedDict` in `_api_structures.py`, re-export from both public `__init__.py` files, and use it. Zero runtime cost (it's still a `dict`), and the doc generator's type comparator matches by structure via `get_type_hints`.
+- **Positional renames are free.** A param with no default before any `*` separator is positional-or-keyword in Python, but realistic call sites pass it positionally. Renaming such a param doesn't break callers.
+- **The "Backport changes" GitHub issue can be misleading.** In the 1.59 roll its checkboxes were all marked `[x]` with annotations like "✅ IMPLEMENTED", but several of those features had not actually been merged into the Python port. Trust the `docs/src/api/` walk over the issue.
+- **`api.json` may carry doclint quirks.** 1.59 hit two: `Promise<X>|X` collapsed to a bare `Promise` with no `templates`, and `void`-typed events serialized as the literal string `"void"`. Both are upstream artifacts; patch `inner_serialize_doc_type` to handle them rather than fighting the api.json side.
+- **Don't edit `_generated.py` to fix lint or typing.** Fix `_impl/`, `documentation_provider.py`, or `expected_api_mismatch.txt` instead. Hand-editing the generated file is reverted on the next regen.
+- **`/tmp/roll-<new>-commits.md` is a working artifact, not a deliverable.** Don't commit it. The commit message and PR description are where the audit summary belongs.
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 c37bf348e..eb06caff0 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,20 @@ 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
+        exclude:
+        # WebKit on standard macOS-latest (currently macos-15-arm64) is unstable;
+        # upstream pins paid macos-15-xlarge for cross-browser webkit too.
         - os: macos-latest
+          browser: webkit
+        include:
+        - os: macos-15-xlarge
+          python-version: '3.9'
+          browser: webkit
+        - os: macos-15-xlarge
           python-version: '3.10'
-          browser: chromium
+          browser: webkit
         - os: windows-latest
           python-version: '3.11'
           browser: chromium
@@ -77,19 +80,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 +138,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,19 +171,27 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-12, windows-2019]
+        os: [ubuntu-22.04, macos-latest, windows-2022]
     runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        # `setup-miniconda` activates the env only for login shells; using
+        # `bash -el` (recommended by the action) ensures `conda` and the
+        # installed `conda-build` are on PATH on every OS, including Windows
+        # where the default shell is pwsh and skips the activation hooks.
+        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@v2
+        uses: conda-incubator/setup-miniconda@v3
         with:
-          python-version: 3.9
+          python-version: '3.12'
           channels: conda-forge
+          miniconda-version: latest
       - name: Prepare
-        run: conda install conda-build conda-verify
+        run: conda install -n base "conda-build>=26" conda-verify
       - name: Build
         run: conda build .
 
@@ -180,9 +202,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..e9a7048c5 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.12'
           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 -n base anaconda-client "conda-build>=26" 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 d69645bee..7494f1abc 100644
--- a/.github/workflows/publish_docker.yml
+++ b/.github/workflows/publish_docker.yml
@@ -2,12 +2,6 @@ name: "publish release - Docker"
 
 on:
   workflow_dispatch:
-    inputs:
-      is_release:
-        required: false
-        type: boolean
-        description: "Is this a release image?"
-
   release:
     types: [published]
 
@@ -16,27 +10,32 @@ jobs:
     name: "publish to DockerHub"
     runs-on: ubuntu-22.04
     if: github.repository == 'microsoft/playwright-python'
+    permissions:
+      id-token: write   # This is required for OIDC login (azure/login) to succeed
+      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:
+        client-id: ${{ secrets.AZURE_DOCKER_CLIENT_ID }}
+        tenant-id: ${{ secrets.AZURE_DOCKER_TENANT_ID }}
+        subscription-id: ${{ secrets.AZURE_DOCKER_SUBSCRIPTION_ID }}
+    - 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"
-    - uses: azure/docker-login@v1
-      with:
-        login-server: playwright.azurecr.io
-        username: playwright
-        password: ${{ secrets.DOCKER_PASSWORD }}
     - 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
-      if: (github.event_name != 'workflow_dispatch' && !github.event.release.prerelease) || (github.event_name == 'workflow_dispatch' && github.event.inputs.is_release == 'true')
-    - run: ./utils/docker/publish_docker.sh canary
-      if: (github.event_name != 'workflow_dispatch' && github.event.release.prerelease) || (github.event_name == 'workflow_dispatch' && github.event.inputs.is_release != 'true')
diff --git a/.github/workflows/test_docker.yml b/.github/workflows/test_docker.yml
index 5a3266197..464eb3b46 100644
--- a/.github/workflows/test_docker.yml
+++ b/.github/workflows/test_docker.yml
@@ -19,33 +19,40 @@ on:
 jobs:
   build:
     timeout-minutes: 120
-    runs-on: ubuntu-22.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/.gitignore b/.gitignore
index 919e041a6..8424e9bfc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,6 @@ coverage.xml
 junit/
 htmldocs/
 utils/docker/dist/
+Pipfile
+Pipfile.lock
+.venv/
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/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..1cbaf3e1a
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,98 @@
+# CLAUDE.md
+
+Guidance for Claude when working in this repository.
+
+## What this is
+
+Python bindings for [Playwright](https://playwright.dev). The Python client talks JSON over a pipe to the Node-based driver bundled in `playwright/driver/`. The pipe protocol is defined upstream in `packages/protocol/src/protocol.yml`.
+
+## Layout
+
+- `playwright/_impl/` — hand-written client implementation (one module per object: `_browser.py`, `_page.py`, `_locator.py`, `_network.py`, etc.). Edit these to add or change behavior.
+- `playwright/async_api/_generated.py`, `playwright/sync_api/_generated.py` — **auto-generated**. Never edit by hand; rerun `./scripts/update_api.sh` after changing `_impl/` or the driver.
+- `scripts/generate_api.py`, `scripts/generate_async_api.py`, `scripts/generate_sync_api.py`, `scripts/documentation_provider.py` — codegen and validation. They diff the Python implementation against the driver's `playwright/driver/package/api.json` and abort if either side is out of sync.
+- `scripts/expected_api_mismatch.txt` — explicit allowlist of "documented in JS, not in Python" or "named differently in Python" gaps. Lines that no longer apply must be removed.
+- `tests/async/`, `tests/sync/` — pytest suites. Most new tests are added to the async file with a sync mirror.
+- `setup.py` — `driver_version = "X.Y.Z"` is the source of truth for which driver build is downloaded from `cdn.playwright.dev`.
+- `ROLLING.md`, `CONTRIBUTING.md` — human-facing setup and roll docs.
+
+## Setup
+
+`CONTRIBUTING.md` has the full sequence. The short version:
+
+```sh
+python3 -m venv env && source env/bin/activate
+pip install --upgrade pip
+pip install -r local-requirements.txt
+pip install -e .
+python -m build --wheel        # downloads the driver listed in setup.py
+pre-commit install
+```
+
+If the system lacks `python3-venv`, `uv venv env` is an acceptable substitute (then `uv pip install --python env/bin/python --upgrade pip`).
+
+## Common commands
+
+- Regenerate `_generated.py`: `./scripts/update_api.sh` (runs codegen + pre-commit on the generated files).
+- Lint everything: `pre-commit run --all-files`.
+- Type-check: `mypy playwright`.
+- Run tests: `pytest --browser chromium [-k name]`. Browsers are installed via `playwright install chromium` (do **not** use `--with-deps`, which requires sudo).
+
+When changing public API, edit `_impl/`, then run `./scripts/update_api.sh`. The script regenerates `_generated.py` and validates against the driver's `api.json`. If validation fails, fix the mismatch in `_impl/`, in `expected_api_mismatch.txt`, or in `documentation_provider.py` — not by hand-editing `_generated.py`.
+
+## Rolling Playwright to a new version
+
+This is the recurring high-stakes task. Use the dedicated skill:
+
+→ **[`.claude/skills/playwright-roll/SKILL.md`](.claude/skills/playwright-roll/SKILL.md)**
+
+It documents the full process: the upstream commit-range diff over `docs/src/api/`, how to classify each commit (PORT / MISMATCH / N/A), how to handle the `langs:` filter, the recurring failure modes, and the tests/sync-mirroring conventions.
+
+## Working on PRs
+
+- Never post comments, replies, or reviews on GitHub PRs/issues under my account without my explicit approval. Draft the proposed text and wait for me to approve before sending.
+
+## House style
+
+- Don't hand-edit generated files.
+- Don't add `# type: ignore` or modify `_generated.py` to silence pyright; fix the source of the mismatch.
+- New public methods on impl classes need a sync test mirror under `tests/sync/`.
+- Keep `expected_api_mismatch.txt` minimal — every entry needs a one-line rationale comment above it.
+- Prefer `locals_to_params(locals())` for forwarding optional kwargs to channel sends, matching the rest of the codebase.
+
+## Commit Convention
+
+Before committing, run `mypy playwright` and fix errors.
+
+Semantic commit messages: `label(scope): description`
+
+Labels: `fix`, `feat`, `chore`, `docs`, `test`, `devops`
+
+```bash
+git checkout -b fix-12345
+# ... make changes ...
+git add <changed-files>
+git commit -m "$(cat <<'EOF'
+fix(asyncio): do not deadlock in atexit handler
+
+Fixes: https://github.com/microsoft/playwright-python/issues/12345
+EOF
+)"
+git push origin fix-12345
+gh pr create --repo microsoft/playwright-python --head username:fix-12345 \
+  --title "fix(asyncio): do not deadlock in atexit handler" \
+  --body "$(cat <<'EOF'
+## Summary
+- <describe the change very! briefly>
+
+Fixes https://github.com/microsoft/playwright-python/issues/12345
+EOF
+)"
+```
+
+Never add Co-Authored-By agents in commit message.
+Never add "Generated with" in commit message.
+Never add test plan to PR description. Keep PR description short — a few bullet points at most.
+Branch naming for issue fixes: `fix-<issue-number>`
+
+**Never `git push` without an explicit instruction to push.** Applies even when a PR is already open for the branch — additional commits are immediately visible to reviewers. Commit locally, report what was committed, and wait. Only push when the user's message contains "push", "upload", "create PR", "ship it", or equivalent.
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 bdf616079..f0a4fc423 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 -->124.0.6367.29<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->17.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->124.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->147.0.7727.15<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| WebKit <!-- GEN:webkit-version -->26.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->148.0.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 
diff --git a/ROLLING.md b/ROLLING.md
index 5cd3240fa..811d7fcb3 100644
--- a/ROLLING.md
+++ b/ROLLING.md
@@ -5,12 +5,21 @@
     * 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
+
+
+## Fix typing issues with Playwright ToT
+
+1. `cd playwright`
+1. `API_JSON_MODE=1 node utils/doclint/generateApiJson.js > ../playwright-python/playwright/driver/package/api.json`
+1. `./scripts/update_api.sh`
diff --git a/SUPPORT.md b/SUPPORT.md
new file mode 100644
index 000000000..0fd849315
--- /dev/null
+++ b/SUPPORT.md
@@ -0,0 +1,17 @@
+# Support
+
+## How to file issues and get help
+
+This project uses GitHub issues to track bugs and feature requests. Please search the [existing issues][gh-issues] before filing new ones to avoid duplicates. For new issues, file your bug or feature request as a new issue using corresponding template.
+
+For help and questions about using this project, please see the [docs site for Playwright for Python][docs].
+
+Join our community [Discord Server][discord-server] to connect with other developers using Playwright and ask questions in our 'help-playwright' forum.
+
+## Microsoft Support Policy
+
+Support for Playwright for Python is limited to the resources listed above.
+
+[gh-issues]: https://github.com/microsoft/playwright-python/issues/
+[docs]: https://playwright.dev/python/
+[discord-server]: https://aka.ms/playwright/discord
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 51250c00b..5735ae2a0 100644
--- a/local-requirements.txt
+++ b/local-requirements.txt
@@ -1,24 +1,23 @@
-auditwheel==6.0.0
+asyncio-atexit==1.0.1
 autobahn==23.1.2
-black==24.3.0
-flake8==7.0.0
-flaky==3.8.1
-mypy==1.9.0
-objgraph==3.6.1
-Pillow==10.3.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.1.0
-pytest==8.1.1
-pytest-asyncio==0.21.1
-pytest-cov==5.0.0
-pytest-repeat==0.9.3
-pytest-timeout==2.3.1
-pytest-xdist==3.5.0
-requests==2.31.0
-service_identity==24.1.0
-setuptools==69.2.0
-twisted==24.3.0
-types-pyOpenSSL==24.0.0.20240311
-types-requests==2.31.0.20240406
-wheel==0.42.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.4.20250809
diff --git a/meta.yaml b/meta.yaml
index 98b774490..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 ==11.0.1
+    - 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 f06a6247e..256b59435 100644
--- a/playwright/_impl/_api_structures.py
+++ b/playwright/_impl/_api_structures.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, Union
 
 # These are the structures that we like keeping in a JSON form for their potential
@@ -31,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.
@@ -44,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):
@@ -63,6 +77,7 @@ class HttpCredentials(TypedDict, total=False):
     username: str
     password: str
     origin: Optional[str]
+    send: Optional[Literal["always", "unauthorized"]]
 
 
 class LocalStorageEntry(TypedDict):
@@ -95,10 +110,21 @@ class ProxySettings(TypedDict, total=False):
 
 
 class StorageState(TypedDict, total=False):
-    cookies: List[Cookie]
+    cookies: List[StorageStateCookie]
     origins: List[OriginState]
 
 
+class ClientCertificate(TypedDict, total=False):
+    origin: str
+    certPath: Optional[Union[str, Path]]
+    cert: Optional[bytes]
+    keyPath: Optional[Union[str, Path]]
+    key: Optional[bytes]
+    pfxPath: Optional[Union[str, Path]]
+    pfx: Optional[bytes]
+    passphrase: Optional[str]
+
+
 class ResourceTiming(TypedDict):
     startTime: float
     domainLookupStart: float
@@ -140,6 +166,10 @@ class RemoteAddr(TypedDict):
     port: int
 
 
+class BrowserBindResult(TypedDict):
+    endpoint: str
+
+
 class SecurityDetails(TypedDict):
     issuer: Optional[str]
     protocol: Optional[str]
@@ -192,6 +222,7 @@ class FrameExpectResult(TypedDict):
     matches: bool
     received: Any
     log: List[str]
+    errorMessage: Optional[str]
 
 
 AriaRole = Literal[
@@ -278,3 +309,24 @@ class FrameExpectResult(TypedDict):
     "treegrid",
     "treeitem",
 ]
+
+
+class TracingGroupLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class DebuggerLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class DebuggerPausedDetails(TypedDict):
+    location: DebuggerLocation
+    title: str
+
+
+class ScreencastFrame(TypedDict):
+    data: bytes
diff --git a/playwright/_impl/_artifact.py b/playwright/_impl/_artifact.py
index 63833fe04..a08294cbe 100644
--- a/playwright/_impl/_artifact.py
+++ b/playwright/_impl/_artifact.py
@@ -33,24 +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]:
-        return patch_error_message(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 2c895e527..aea37d35c 100644
--- a/playwright/_impl/_assertions.py
+++ b/playwright/_impl/_assertions.py
@@ -16,7 +16,12 @@
 from typing import Any, List, Optional, Pattern, Sequence, Union
 from urllib.parse import urljoin
 
-from playwright._impl._api_structures import ExpectedTextValue, FrameExpectOptions
+from playwright._impl._api_structures import (
+    AriaRole,
+    ExpectedTextValue,
+    FrameExpectOptions,
+    FrameExpectResult,
+)
 from playwright._impl._connection import format_call_log
 from playwright._impl._errors import Error
 from playwright._impl._fetch import APIResponse
@@ -41,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
@@ -56,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:
@@ -67,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'))}"
             )
 
 
@@ -83,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(
@@ -92,15 +115,16 @@ def _not(self) -> "PageAssertions":
     async def to_have_title(
         self, titleOrRegExp: Union[Pattern[str], str], timeout: float = None
     ) -> None:
+        __tracebackhide__ = True
         expected_values = to_expected_text_values(
             [titleOrRegExp], normalize_white_space=True
         )
-        __tracebackhide__ = True
         await self._expect_impl(
             "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(
@@ -110,25 +134,32 @@ async def not_to_have_title(
         await self._not.to_have_title(titleOrRegExp, timeout)
 
     async def to_have_url(
-        self, urlOrRegExp: Union[str, Pattern[str]], timeout: float = None
+        self,
+        urlOrRegExp: Union[str, Pattern[str]],
+        timeout: float = None,
+        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])
+        expected_text = to_expected_text_values([urlOrRegExp], ignoreCase=ignoreCase)
         await self._expect_impl(
             "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(
-        self, urlOrRegExp: Union[Pattern[str], str], timeout: float = None
+        self,
+        urlOrRegExp: Union[Pattern[str], str],
+        timeout: float = None,
+        ignoreCase: bool = None,
     ) -> None:
         __tracebackhide__ = True
-        await self._not.to_have_url(urlOrRegExp, timeout)
+        await self._not.to_have_url(urlOrRegExp, timeout, ignoreCase)
 
 
 class LocatorAssertions(AssertionsBase):
@@ -142,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(
@@ -180,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(
@@ -197,6 +235,7 @@ async def to_contain_text(
                 ),
                 expected,
                 "Locator expected to contain text",
+                'Expect "to_contain_text"',
             )
 
     async def not_to_contain_text(
@@ -231,6 +270,7 @@ async def to_have_attribute(
             ),
             value,
             "Locator expected to have attribute",
+            'Expect "to_have_attribute"',
         )
 
     async def not_to_have_attribute(
@@ -266,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])
@@ -274,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(
@@ -290,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,
@@ -301,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(
@@ -326,6 +410,7 @@ async def to_have_css(
             ),
             value,
             "Locator expected to have CSS",
+            'Expect "to_have_css"',
         )
 
     async def not_to_have_css(
@@ -349,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(
@@ -373,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(
@@ -396,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(
@@ -420,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(
@@ -463,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(
@@ -477,6 +567,7 @@ async def to_have_text(
                 ),
                 expected,
                 "Locator expected to have text",
+                'Expect "to_have_text"',
             )
 
     async def not_to_have_text(
@@ -501,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(
@@ -550,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(
@@ -567,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(
@@ -592,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(
@@ -609,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(
@@ -634,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(
@@ -651,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(
@@ -676,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(
@@ -696,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(
@@ -704,6 +818,124 @@ async def not_to_be_in_viewport(
         __tracebackhide__ = True
         await self._not.to_be_in_viewport(ratio=ratio, timeout=timeout)
 
+    async def to_have_accessible_description(
+        self,
+        description: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        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(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_description(name, ignoreCase, timeout)
+
+    async def to_have_accessible_name(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        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(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_name(name, ignoreCase, timeout)
+
+    async def to_have_role(self, role: AriaRole, timeout: float = None) -> None:
+        __tracebackhide__ = True
+        if isinstance(role, Pattern):
+            raise Error('"role" argument in to_have_role must be a string')
+        expected_values = to_expected_text_values([role])
+        await self._expect_impl(
+            "to.have.role",
+            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__(
@@ -778,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 8a248f703..6454f8c3f 100644
--- a/playwright/_impl/_browser.py
+++ b/playwright/_impl/_browser.py
@@ -12,12 +12,23 @@
 # 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 (
+    BrowserBindResult,
+    ClientCertificate,
     Geolocation,
     HttpCredentials,
     ProxySettings,
@@ -31,17 +42,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
 from playwright._impl._page import Page
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -57,28 +66,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:
@@ -106,6 +148,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,
@@ -120,13 +163,21 @@ async def new_context(
         recordHarUrlFilter: Union[Pattern[str], str] = None,
         recordHarMode: HarMode = None,
         recordHarContent: HarContentPolicy = None,
+        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(
@@ -150,6 +201,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,
@@ -165,6 +217,7 @@ async def new_page(
         recordHarUrlFilter: Union[Pattern[str], str] = None,
         recordHarMode: HarMode = None,
         recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
     ) -> Page:
         params = locals_to_params(locals())
 
@@ -175,7 +228,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
@@ -183,7 +236,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
@@ -193,7 +246,21 @@ 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 bind(
+        self,
+        title: str,
+        workspaceDir: str = None,
+        host: str = None,
+        port: int = None,
+    ) -> BrowserBindResult:
+        return await self._channel.send_return_as_dict(
+            "startServer", None, locals_to_params(locals())
+        )
+
+    async def unbind(self) -> None:
+        await self._channel.send("stopServer", None)
 
     async def start_tracing(
         self,
@@ -208,10 +275,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:
@@ -220,36 +289,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"
diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
index c540ce4c0..6839d7c7f 100644
--- a/playwright/_impl/_browser_context.py
+++ b/playwright/_impl/_browser_context.py
@@ -39,13 +39,16 @@
 )
 from playwright._impl._artifact import Artifact
 from playwright._impl._cdp_session import CDPSession
+from playwright._impl._clock import Clock
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
     from_nullable_channel,
 )
 from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable, DisposableStub
 from playwright._impl._errors import Error, TargetClosedError
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._fetch import APIRequestContext
@@ -60,15 +63,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
@@ -81,6 +90,7 @@
 
 class BrowserContext(ChannelOwner):
     Events = SimpleNamespace(
+        # Deprecated in v1.56, never emitted anymore.
         BackgroundPage="backgroundpage",
         Close="close",
         Console="console",
@@ -98,22 +108,27 @@ 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._debugger: Debugger = cast(Debugger, from_channel(initializer["debugger"]))
         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",
             lambda params: self._on_binding(from_channel(params["binding"])),
@@ -130,10 +145,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(
@@ -203,7 +221,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}>"
@@ -220,7 +238,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
@@ -242,10 +260,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:
@@ -257,19 +289,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]:
@@ -279,29 +304,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,
@@ -311,58 +352,61 @@ 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
-    ) -> None:
+    ) -> Disposable:
         if path:
             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))
+        return from_channel(
+            await self._channel.send("addInitScript", None, dict(source=script))
+        )
 
     async def expose_binding(
         self, name: str, callback: Callable, handle: bool = None
-    ) -> None:
+    ) -> Disposable:
         for page in self._pages:
             if name in page._bindings:
                 raise Error(
@@ -371,26 +415,30 @@ async def expose_binding(
         if name in self._bindings:
             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)
+        return from_channel(
+            await self._channel.send(
+                "exposeBinding", None, dict(name=name, needsHandle=handle or False)
+            )
         )
 
-    async def expose_function(self, name: str, callback: Callable) -> None:
-        await self.expose_binding(name, lambda source, *args: callback(*args))
+    async def expose_function(self, name: str, callback: Callable) -> Disposable:
+        return await self.expose_binding(name, lambda source, *args: callback(*args))
 
     async def route(
         self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
-    ) -> None:
+    ) -> DisposableStub:
         self._routes.insert(
             0,
             RouteHandler(
-                URLMatcher(self._options.get("baseURL"), url),
+                self._base_url,
+                url,
                 handler,
                 True if self._dispatcher_fiber else False,
                 times,
             ),
         )
         await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler), self)
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
@@ -398,7 +446,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)
@@ -411,10 +459,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:
@@ -435,22 +491,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(
@@ -483,7 +542,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(
@@ -506,24 +573,40 @@ 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)
 
+    def is_closed(self) -> bool:
+        return self._closing_or_closed
+
     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.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.
@@ -542,15 +625,28 @@ 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
 
+    async def set_storage_state(
+        self, storageState: Union[StorageState, str, Path]
+    ) -> None:
+        if isinstance(storageState, (str, Path)):
+            state = json.loads(await async_readfile(storageState))
+        else:
+            state = storageState
+        await self._channel.send("setStorageState", None, {"storageState": state})
+
     def _effective_close_reason(self) -> Optional[str]:
         if self._close_reason:
             return self._close_reason
@@ -579,10 +675,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)
@@ -617,10 +709,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)
@@ -638,7 +733,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)
 
@@ -654,7 +752,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]:
@@ -669,12 +767,20 @@ 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:
         return self._tracing
 
+    @property
+    def debugger(self) -> Debugger:
+        return self._debugger
+
     @property
     def request(self) -> "APIRequestContext":
         return self._request
+
+    @property
+    def clock(self) -> Clock:
+        return self._clock
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
index 8393d69ee..88ea5fc52 100644
--- a/playwright/_impl/_browser_type.py
+++ b/playwright/_impl/_browser_type.py
@@ -13,37 +13,39 @@
 # limitations under the License.
 
 import asyncio
+import json
 import pathlib
+import sys
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Optional, Pattern, Sequence, Union, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
 
 from playwright._impl._api_structures import (
+    ClientCertificate,
     Geolocation,
     HttpCredentials,
     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:
@@ -80,20 +82,27 @@ 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,
         tracesDir: Union[pathlib.Path, str] = None,
+        artifactsDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
     ) -> Browser:
         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(
@@ -109,7 +118,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,
@@ -133,8 +141,10 @@ 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,
+        artifactsDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
         recordHarPath: Union[Path, str] = None,
@@ -147,50 +157,70 @@ async def launch_persistent_context(
         recordHarUrlFilter: Union[Pattern[str], str] = None,
         recordHarMode: HarMode = None,
         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(
         self,
-        wsEndpoint: str,
+        endpoint: str,
         timeout: float = None,
         slowMo: float = None,
         headers: Dict[str, str] = None,
         exposeNetwork: str = None,
     ) -> Browser:
-        if timeout is None:
-            timeout = 30000
         if slowMo is None:
             slowMo = 0
 
@@ -199,11 +229,12 @@ async def connect(
         pipe_channel = (
             await local_utils._channel.send_return_as_dict(
                 "connect",
+                None,
                 {
-                    "wsEndpoint": wsEndpoint,
+                    "endpoint": endpoint,
                     "headers": headers,
                     "slowMo": slowMo,
-                    "timeout": timeout,
+                    "timeout": timeout if timeout is not None else 0,
                     "exposeNetwork": exposeNetwork,
                 },
             )
@@ -218,11 +249,35 @@ async def connect(
             local_utils=self._connection.local_utils,
         )
         connection.mark_as_remote()
+
+        browser = None
+
+        def handle_transport_close(reason: Optional[str]) -> None:
+            if browser:
+                for context in browser.contexts:
+                    for page in context.pages:
+                        page._on_close()
+                    context._on_close()
+                browser._on_close()
+            connection.cleanup(reason)
+            # TODO: Backport https://github.com/microsoft/playwright/commit/d8d5289e8692c9b1265d23ee66988d1ac5122f33
+            # Give a chance to any API call promises to reject upon page/context closure.
+            # This happens naturally when we receive page.onClose and browser.onClose from the server
+            # in separate tasks. However, upon pipe closure we used to dispatch them all synchronously
+            # here and promises did not have a chance to reject.
+            # The order of rejects vs closure is a part of the API contract and our test runner
+            # relies on it to attribute rejections to the right test.
+
+        transport.once("close", handle_transport_close)
+
         connection._is_sync = self._connection._is_sync
         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,
@@ -237,28 +292,59 @@ async def connect(
         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
-
-        def handle_transport_close() -> None:
-            for context in browser.contexts:
-                for page in context.pages:
-                    page._on_close()
-                context._on_close()
-            browser._on_close()
-            connection.cleanup()
-
-        transport.once("close", handle_transport_close)
+        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:
@@ -271,9 +357,13 @@ def normalize_launch_params(params: Dict) -> None:
         if params["ignoreDefaultArgs"] is True:
             params["ignoreAllDefaultArgs"] = True
             del params["ignoreDefaultArgs"]
+        elif params["ignoreDefaultArgs"] is False:
+            del params["ignoreDefaultArgs"]
     if "executablePath" in params:
         params["executablePath"] = str(Path(params["executablePath"]))
     if "downloadsPath" in params:
         params["downloadsPath"] = str(Path(params["downloadsPath"]))
     if "tracesDir" in params:
         params["tracesDir"] = str(Path(params["tracesDir"]))
+    if "artifactsDir" in params:
+        params["artifactsDir"] = str(Path(params["artifactsDir"]))
diff --git a/playwright/_impl/_cdp_session.py b/playwright/_impl/_cdp_session.py
index a6af32b90..07d291ae2 100644
--- a/playwright/_impl/_cdp_session.py
+++ b/playwright/_impl/_cdp_session.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import SimpleNamespace
 from typing import Any, Dict
 
 from playwright._impl._connection import ChannelOwner
@@ -19,17 +20,27 @@
 
 
 class CDPSession(ChannelOwner):
+    Events = SimpleNamespace(
+        Event="event",
+        Close="close",
+    )
+
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._channel.on("event", lambda params: self._on_event(params))
+        self._channel.on("close", lambda _: self.emit(CDPSession.Events.Close, self))
 
     def _on_event(self, params: Any) -> None:
-        self.emit(params["method"], params["params"])
+        self.emit(params["method"], params.get("params"))
+        self.emit(CDPSession.Events.Event, 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
new file mode 100644
index 000000000..f6eb7c42d
--- /dev/null
+++ b/playwright/_impl/_clock.py
@@ -0,0 +1,104 @@
+# 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 datetime
+from typing import TYPE_CHECKING, Dict, Union
+
+if TYPE_CHECKING:
+    from playwright._impl._browser_context import BrowserContext
+
+
+class Clock:
+    def __init__(self, browser_context: "BrowserContext") -> None:
+        self._browser_context = browser_context
+        self._loop = browser_context._loop
+        self._dispatcher_fiber = browser_context._dispatcher_fiber
+
+    async def install(self, time: Union[float, str, datetime.datetime] = None) -> None:
+        await self._browser_context._channel.send(
+            "clockInstall",
+            None,
+            parse_time(time) if time is not None else {},
+        )
+
+    async def fast_forward(
+        self,
+        ticks: Union[int, str],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockFastForward",
+            None,
+            parse_ticks(ticks),
+        )
+
+    async def pause_at(
+        self,
+        time: Union[float, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockPauseAt",
+            None,
+            parse_time(time),
+        )
+
+    async def resume(
+        self,
+    ) -> None:
+        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",
+            None,
+            parse_ticks(ticks),
+        )
+
+    async def set_fixed_time(
+        self,
+        time: Union[float, str, datetime.datetime],
+    ) -> None:
+        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",
+            None,
+            parse_time(time),
+        )
+
+
+def parse_time(
+    time: Union[float, str, datetime.datetime],
+) -> Dict[str, Union[int, str]]:
+    if isinstance(time, (float, int)):
+        return {"timeNumber": int(time * 1_000)}
+    if isinstance(time, str):
+        return {"timeString": time}
+    return {"timeNumber": int(time.timestamp() * 1_000)}
+
+
+def parse_ticks(ticks: Union[int, str]) -> Dict[str, Union[int, str]]:
+    if isinstance(ticks, int):
+        return {"ticksNumber": ticks}
+    return {"ticksString": ticks}
diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
index 937ab3f8b..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
@@ -284,15 +324,18 @@ async def stop_async(self) -> None:
         await self._transport.wait_until_stopped()
         self.cleanup()
 
-    def cleanup(self, cause: Exception = None) -> None:
-        self._closed_error = (
-            TargetClosedError(str(cause)) if cause else TargetClosedError()
-        )
+    def cleanup(self, cause: str = None) -> None:
+        self._closed_error = TargetClosedError(cause) if cause else TargetClosedError()
         if self._init_task and not self._init_task.done():
             self._init_task.cancel()
         for ws_connection in self._child_ws_connections:
             ws_connection._transport.dispose()
         for callback in self._callbacks.values():
+            # 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")
@@ -302,7 +345,7 @@ def call_on_object_with_known_name(
     ) -> None:
         self._waiting_for_object[guid] = callback
 
-    def set_in_tracing(self, is_tracing: bool) -> None:
+    def set_is_tracing(self, is_tracing: bool) -> None:
         if is_tracing:
             self._tracing_count += 1
         else:
@@ -319,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 = (
@@ -345,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,
@@ -355,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
 
@@ -377,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"))
@@ -499,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()
@@ -515,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()
@@ -549,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 = ""
@@ -586,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:
@@ -598,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..d98901d34 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
@@ -54,6 +76,14 @@ def args(self) -> List[JSHandle]:
     def location(self) -> SourceLocation:
         return self._event["location"]
 
+    @property
+    def timestamp(self) -> float:
+        return self._event["timestamp"]
+
     @property
     def page(self) -> Optional["Page"]:
         return self._page
+
+    @property
+    def worker(self) -> Optional["Worker"]:
+        return self._worker
diff --git a/playwright/_impl/_debugger.py b/playwright/_impl/_debugger.py
new file mode 100644
index 000000000..36e4bd989
--- /dev/null
+++ b/playwright/_impl/_debugger.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 types import SimpleNamespace
+from typing import Any, Dict, Optional
+
+from playwright._impl._api_structures import DebuggerLocation, DebuggerPausedDetails
+from playwright._impl._connection import ChannelOwner
+
+
+class Debugger(ChannelOwner):
+    Events = SimpleNamespace(
+        PausedStateChanged="pausedstatechanged",
+    )
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._paused_details: Optional[DebuggerPausedDetails] = None
+        self._channel.on(
+            "pausedStateChanged", lambda params: self._on_paused_state_changed(params)
+        )
+
+    def _on_paused_state_changed(self, params: Dict[str, Any]) -> None:
+        self._paused_details = params.get("pausedDetails")
+        self.emit(Debugger.Events.PausedStateChanged)
+
+    async def request_pause(self) -> None:
+        await self._channel.send("requestPause", None)
+
+    async def resume(self) -> None:
+        await self._channel.send("resume", None)
+
+    async def next(self) -> None:
+        await self._channel.send("next", None)
+
+    async def run_to(self, location: DebuggerLocation) -> None:
+        await self._channel.send("runTo", None, {"location": location})
+
+    @property
+    def paused_details(self) -> Optional[DebuggerPausedDetails]:
+        return self._paused_details
diff --git a/playwright/_impl/_dialog.py b/playwright/_impl/_dialog.py
index a0c6ca77f..f6750e396 100644
--- a/playwright/_impl/_dialog.py
+++ b/playwright/_impl/_dialog.py
@@ -15,6 +15,7 @@
 from typing import TYPE_CHECKING, Dict, Optional
 
 from playwright._impl._connection import ChannelOwner, from_nullable_channel
+from playwright._impl._errors import is_target_closed_error
 from playwright._impl._helper import locals_to_params
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -48,7 +49,15 @@ 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")
+        try:
+            await self._channel.send(
+                "dismiss",
+                None,
+            )
+        except Exception as e:
+            if is_target_closed_error(e):
+                return
+            raise
diff --git a/playwright/_impl/_disposable.py b/playwright/_impl/_disposable.py
new file mode 100644
index 000000000..c0b7e85a1
--- /dev/null
+++ b/playwright/_impl/_disposable.py
@@ -0,0 +1,93 @@
+# 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 inspect
+import traceback
+from typing import Awaitable, Callable, Dict
+
+import greenlet
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import Error, is_target_closed_error
+
+
+class Disposable(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def dispose(self) -> None:
+        try:
+            await self._channel.send(
+                "dispose",
+                None,
+            )
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
+
+
+class DisposableStub:
+    def __init__(
+        self,
+        dispose_fn: Callable[[], Awaitable[None]],
+        parent: ChannelOwner,
+    ) -> None:
+        self._dispose_fn = dispose_fn
+        self._loop = parent._loop
+        self._dispatcher_fiber = parent._dispatcher_fiber
+
+    async def dispose(self) -> None:
+        await self._dispose_fn()
+
+    async def __aenter__(self) -> "DisposableStub":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.dispose()
+
+    def __enter__(self) -> "DisposableStub":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self._sync(self.dispose())
+
+    def _sync(self, coro: object) -> object:
+        __tracebackhide__ = True
+        if self._loop.is_closed():
+            coro.close()  # type: ignore
+            raise Error("Event loop is closed! Is Playwright already stopped?")
+        g_self = greenlet.getcurrent()
+        task = self._loop.create_task(coro)  # type: ignore
+        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():
+            self._dispatcher_fiber.switch()  # type: ignore
+        asyncio._set_running_loop(self._loop)
+        return task.result()
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
diff --git a/playwright/_impl/_driver.py b/playwright/_impl/_driver.py
index 9e8cdc1e7..22b53b8e7 100644
--- a/playwright/_impl/_driver.py
+++ b/playwright/_impl/_driver.py
@@ -26,7 +26,10 @@ def compute_driver_executable() -> Tuple[str, str]:
     driver_path = Path(inspect.getfile(playwright)).parent / "driver"
     cli_path = str(driver_path / "package" / "cli.js")
     if sys.platform == "win32":
-        return (str(driver_path / "node.exe"), cli_path)
+        return (
+            os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node.exe")),
+            cli_path,
+        )
     return (os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node")), cli_path)
 
 
diff --git a/playwright/_impl/_element_handle.py b/playwright/_impl/_element_handle.py
index 74e5bdff9..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,
@@ -157,12 +173,11 @@ async def select_option(
         params = locals_to_params(
             dict(
                 timeout=timeout,
-                noWaitAfter=noWaitAfter,
                 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,
@@ -173,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,
@@ -182,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,
@@ -204,15 +227,15 @@ async def set_input_files(
         converted = await convert_input_files(files, frame.page.context)
         await self._channel.send(
             "setInputFiles",
+            self._frame._timeout,
             {
                 "timeout": timeout,
-                "noWaitAfter": noWaitAfter,
                 **converted,
             },
         )
 
     async def focus(self) -> None:
-        await self._channel.send("focus")
+        await self._channel.send("focus", None)
 
     async def type(
         self,
@@ -221,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,
@@ -230,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,
@@ -246,7 +273,6 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 trial=trial,
             )
         else:
@@ -254,7 +280,6 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 trial=trial,
             )
 
@@ -266,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,
@@ -276,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,
@@ -297,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(
@@ -310,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)
@@ -319,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)
+                ),
             )
         )
 
@@ -339,6 +374,7 @@ async def eval_on_selector(
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
@@ -356,6 +392,7 @@ async def eval_on_selector_all(
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
@@ -371,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,
@@ -381,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())
+            )
         )
 
 
@@ -396,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))
@@ -414,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 53c457ba7..50bf4ad4a 100644
--- a/playwright/_impl/_fetch.py
+++ b/playwright/_impl/_fetch.py
@@ -21,6 +21,7 @@
 
 import playwright._impl._network as network
 from playwright._impl._api_structures import (
+    ClientCertificate,
     FilePayload,
     FormField,
     Headers,
@@ -34,6 +35,8 @@
 from playwright._impl._helper import (
     Error,
     NameValue,
+    TargetClosedError,
+    TimeoutSettings,
     async_readfile,
     async_writefile,
     is_file_payload,
@@ -41,7 +44,7 @@
     object_to_array,
     to_impl,
 )
-from playwright._impl._network import serialize_headers
+from playwright._impl._network import serialize_headers, to_client_certificates_protocol
 from playwright._impl._tracing import Tracing
 
 if typing.TYPE_CHECKING:
@@ -51,7 +54,7 @@
 FormType = Dict[str, Union[bool, float, str]]
 DataType = Union[Any, bytes, str]
 MultipartType = Dict[str, Union[bytes, bool, float, str, FilePayload]]
-ParamsType = Dict[str, Union[bool, float, str]]
+ParamsType = Union[Dict[str, Union[bool, float, str]], str]
 
 
 class APIRequest:
@@ -70,6 +73,9 @@ async def new_context(
         userAgent: str = None,
         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:
@@ -80,10 +86,16 @@ async def new_context(
                 )
         if "extraHTTPHeaders" in params:
             params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
+        params["clientCertificates"] = await to_client_certificates_protocol(
+            params.get("clientCertificates")
+        )
         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
 
 
@@ -93,9 +105,18 @@ def __init__(
     ) -> None:
         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) -> None:
-        await self._channel.send("dispose")
+    async def dispose(self, reason: str = None) -> None:
+        self._close_reason = reason
+        try:
+            await self._channel.send("dispose", None, {"reason": reason})
+        except Error as e:
+            if is_target_closed_error(e):
+                return
+            raise e
+        self._tracing._reset_stack_counter()
 
     async def delete(
         self,
@@ -109,6 +130,7 @@ async def delete(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -122,6 +144,7 @@ async def delete(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def head(
@@ -136,6 +159,7 @@ async def head(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -149,6 +173,7 @@ async def head(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def get(
@@ -163,6 +188,7 @@ async def get(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -176,6 +202,7 @@ async def get(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def patch(
@@ -190,6 +217,7 @@ async def patch(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -203,6 +231,7 @@ async def patch(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def put(
@@ -217,6 +246,7 @@ async def put(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -230,6 +260,7 @@ async def put(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def post(
@@ -244,6 +275,7 @@ async def post(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         return await self.fetch(
             url,
@@ -257,6 +289,7 @@ async def post(
             failOnStatusCode=failOnStatusCode,
             ignoreHTTPSErrors=ignoreHTTPSErrors,
             maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
         )
 
     async def fetch(
@@ -272,6 +305,7 @@ async def fetch(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
         url = urlOrRequest if isinstance(urlOrRequest, str) else None
         request = (
@@ -295,6 +329,7 @@ async def fetch(
             failOnStatusCode,
             ignoreHTTPSErrors,
             maxRedirects,
+            maxRetries,
         )
 
     async def _inner_fetch(
@@ -311,13 +346,19 @@ async def _inner_fetch(
         failOnStatusCode: bool = None,
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
     ) -> "APIResponse":
+        if self._close_reason:
+            raise TargetClosedError(self._close_reason)
         assert (
             (1 if data else 0) + (1 if form else 0) + (1 if multipart else 0)
         ) <= 1, "Only one of 'data', 'form' or 'multipart' can be specified"
         assert (
             maxRedirects is None or maxRedirects >= 0
         ), "'max_redirects' must be greater than or equal to '0'"
+        assert (
+            maxRetries is None or maxRetries >= 0
+        ), "'max_retries' must be greater than or equal to '0'"
         url = url or (request.url if request else url)
         method = method or (request.method if request else "GET")
         # Cannot call allHeaders() here as the request may be paused inside route handler.
@@ -327,7 +368,7 @@ async def _inner_fetch(
         form_data: Optional[List[NameValue]] = None
         multipart_data: Optional[List[FormField]] = None
         post_data_buffer: Optional[bytes] = None
-        if data:
+        if data is not None:
             if isinstance(data, str):
                 if is_json_content_type(serialized_headers):
                     json_data = data if is_json_parsable(data) else json.dumps(data)
@@ -368,27 +409,34 @@ async def _inner_fetch(
 
         response = await self._channel.send(
             "fetch",
+            self._timeout_settings.timeout,
             {
                 "url": url,
-                "params": object_to_array(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,
+                "maxRetries": maxRetries,
             },
         )
         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
@@ -439,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")
@@ -464,6 +516,7 @@ async def json(self) -> Any:
     async def dispose(self) -> None:
         await self._request._channel.send(
             "disposeAPIResponse",
+            None,
             {
                 "fetchUid": self._fetch_uid,
             },
@@ -476,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 bfeef1489..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,
@@ -670,13 +773,12 @@ async def select_option(
             dict(
                 selector=selector,
                 timeout=timeout,
-                noWaitAfter=noWaitAfter,
                 strict=strict,
                 force=force,
                 **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,
@@ -684,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,
@@ -699,11 +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,
-                "noWaitAfter": noWaitAfter,
+                "timeout": self._timeout(timeout),
                 **converted,
             },
         )
@@ -717,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,
@@ -728,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,
@@ -740,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,
@@ -752,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,
@@ -770,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,
@@ -792,7 +898,6 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 strict=strict,
                 trial=trial,
             )
@@ -802,10 +907,9 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 strict=strict,
                 trial=trial,
             )
 
     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 0e6b91cd2..dc0a2479d 100644
--- a/playwright/_impl/_helper.py
+++ b/playwright/_impl/_helper.py
@@ -22,6 +22,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
@@ -29,35 +30,48 @@
     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 Error, TargetClosedError, TimeoutError
-from playwright._impl._glob import glob_to_regex
+from playwright._impl._errors import (
+    Error,
+    TargetClosedError,
+    TimeoutError,
+    is_target_closed_error,
+    rewrite_error,
+)
+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]]
-URLMatchResponse = Union[str, Pattern[str], Callable[["Response"], bool]]
+URLMatchRequest = Union[
+    str, Pattern[str], Callable[["Request"], Union[bool, Awaitable[bool]]]
+]
+URLMatchResponse = Union[
+    str, Pattern[str], Callable[["Response"], Union[bool, Awaitable[bool]]]
+]
 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", "Meta", "Shift"]
+KeyboardModifier = Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]
 MouseButton = Literal["left", "middle", "right"]
 ServiceWorkersPolicy = Literal["allow", "block"]
 HarMode = Literal["full", "minimal"]
@@ -135,27 +149,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):
@@ -167,7 +285,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
@@ -183,7 +315,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]
@@ -196,12 +328,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:
@@ -229,7 +365,7 @@ def patch_error_message(message: str) -> str:
     if match:
         message = to_snake_case(match.group(1)) + match.group(2)
     message = message.replace(
-        "Pass { acceptDownloads: true }", "Pass { accept_downloads: True }"
+        "Pass { acceptDownloads: true }", "Pass 'accept_downloads=True'"
     )
     return message
 
@@ -240,7 +376,11 @@ def locals_to_params(args: Dict) -> Dict:
         if key == "self":
             continue
         if args[key] is not None:
-            copy[key] = args[key]
+            copy[key] = (
+                args[key]
+                if not isinstance(args[key], Dict)
+                else locals_to_params(args[key])
+            )
     return copy
 
 
@@ -260,12 +400,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
@@ -274,7 +416,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(
@@ -287,6 +429,14 @@ async def handle(self, route: "Route") -> bool:
             # If the handler was stopped (without waiting for completion), we ignore all exceptions.
             if self._ignore_exception:
                 return False
+            if is_target_closed_error(e):
+                # We are failing in the handler because the target has closed.
+                # Give user a hint!
+                optional_async_prefix = "await " if not self._is_sync else ""
+                raise rewrite_error(
+                    e,
+                    f"\"{str(e)}\" while running route callback.\nConsider awaiting `{optional_async_prefix}page.unroute_all(behavior='ignoreErrors')`\nbefore the end of the test to ignore remaining routes in flight.",
+                )
             raise e
         finally:
             handler_invocation.complete.set_result(None)
@@ -343,13 +493,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 415d79a76..84ef40d18 100644
--- a/playwright/_impl/_js_handle.py
+++ b/playwright/_impl/_js_handle.py
@@ -12,15 +12,18 @@
 # 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
 from urllib.parse import ParseResult, urlparse, urlunparse
 
 from playwright._impl._connection import Channel, ChannelOwner, from_channel
-from playwright._impl._errors import is_target_closed_error
+from playwright._impl._errors import Error, is_target_closed_error
 from playwright._impl._map import Map
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -68,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),
@@ -81,6 +85,7 @@ async def evaluate_handle(
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -90,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"]:
@@ -104,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(
@@ -140,6 +156,24 @@ def serialize_value(
                 value.astimezone(datetime.timezone.utc), "%Y-%m-%dT%H:%M:%S.%fZ"
             )
         }
+    if isinstance(value, Exception):
+        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)
+                    )
+                ),
+            }
+        }
     if isinstance(value, bool):
         return {"b": value}
     if isinstance(value, (int, float)):
@@ -207,6 +241,12 @@ def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
         if "bi" in value:
             return int(value["bi"])
 
+        if "e" in value:
+            error = Error(value["e"]["m"])
+            error._name = value["e"]["n"]
+            error._stack = value["e"]["s"]
+            return error
+
         if "a" in value:
             a: List = []
             refs[value["id"]] = a
@@ -235,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 12d3a886f..41973b8c7 100644
--- a/playwright/_impl/_json_pipe.py
+++ b/playwright/_impl/_json_pipe.py
@@ -13,11 +13,12 @@
 # limitations under the License.
 
 import asyncio
-from typing import Dict, cast
+from typing import Dict, Optional, cast
 
 from pyee.asyncio import AsyncIOEventEmitter
 
 from playwright._impl._connection import Channel
+from playwright._impl._errors import TargetClosedError
 from playwright._impl._helper import Error, ParsedMessagePayload
 from playwright._impl._transport import Transport
 
@@ -32,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()
@@ -53,8 +53,10 @@ def handle_message(message: Dict) -> None:
                 return
             self.on_message(cast(ParsedMessagePayload, message))
 
-        def handle_closed() -> None:
-            self.emit("close")
+        def handle_closed(reason: Optional[str]) -> None:
+            self.emit("close", reason)
+            if reason:
+                self.on_error_future.set_exception(TargetClosedError(reason))
             self._stopped_future.set_result(None)
 
         self._pipe_channel.on(
@@ -63,7 +65,7 @@ def handle_closed() -> None:
         )
         self._pipe_channel.on(
             "closed",
-            lambda _: handle_closed(),
+            lambda params: handle_closed(params.get("reason")),
         )
 
     async def run(self) -> None:
@@ -72,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..cd8fd8343 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,30 @@ 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:
+    async def tracing_started(
+        self, tracesDir: Optional[str], traceName: str, live: bool = False
+    ) -> 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 c5e92d874..5f1b8f29a 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:
@@ -116,6 +121,9 @@ async def _with_element(
         finally:
             await handle.dispose()
 
+    def _equals(self, locator: "Locator") -> bool:
+        return self._frame == locator._frame and self._selector == locator._selector
+
     @property
     def page(self) -> "Page":
         return self._frame.page
@@ -148,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,
@@ -162,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)
@@ -210,7 +220,8 @@ async def clear(
         noWaitAfter: bool = None,
         force: bool = None,
     ) -> None:
-        await self.fill("", timeout=timeout, noWaitAfter=noWaitAfter, force=force)
+        params = locals_to_params(locals())
+        await self._frame._fill(self._selector, value="", title="Clear", **params)
 
     def locator(
         self,
@@ -329,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,
@@ -343,6 +375,7 @@ def filter(
             has_not_text=hasNotText,
             has=has,
             has_not=hasNot,
+            visible=visible,
         )
 
     def or_(self, locator: "Locator") -> "Locator":
@@ -368,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,
@@ -397,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"]
@@ -478,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(
@@ -531,6 +564,29 @@ async def screenshot(
             ),
         )
 
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        depth: int = None,
+        mode: Literal["ai", "default"] = None,
+    ) -> str:
+        return await self._frame._channel.send(
+            "ariaSnapshot",
+            self._frame._timeout,
+            {
+                "selector": self._selector,
+                **locals_to_params(locals()),
+            },
+        )
+
+    async def normalize(self) -> "Locator":
+        result = await self._frame._channel.send(
+            "resolveSelector",
+            None,
+            {"selector": self._selector},
+        )
+        return Locator(self._frame, result)
+
     async def scroll_into_view_if_needed(
         self,
         timeout: float = None,
@@ -628,7 +684,7 @@ async def press_sequentially(
         timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self.type(text, delay=delay, timeout=timeout, noWaitAfter=noWaitAfter)
+        await self.type(text, delay=delay, timeout=timeout)
 
     async def uncheck(
         self,
@@ -682,7 +738,6 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 trial=trial,
             )
         else:
@@ -690,26 +745,16 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 trial=trial,
             )
 
     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 1fe436c80..06bf88267 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
@@ -36,6 +37,7 @@
 from urllib import parse
 
 from playwright._impl._api_structures import (
+    ClientCertificate,
     Headers,
     HeadersArray,
     RemoteAddr,
@@ -50,14 +52,21 @@
 )
 from playwright._impl._errors import Error
 from playwright._impl._event_context_manager import EventContextManagerImpl
-from playwright._impl._helper import 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):
@@ -83,6 +92,40 @@ def serialize_headers(headers: Dict[str, str]) -> HeadersArray:
     ]
 
 
+async def to_client_certificates_protocol(
+    clientCertificates: Optional[List[ClientCertificate]],
+) -> Optional[List[Dict[str, str]]]:
+    if not clientCertificates:
+        return None
+    out = []
+    for clientCertificate in clientCertificates:
+        out_record = {
+            "origin": clientCertificate["origin"],
+        }
+        if passphrase := clientCertificate.get("passphrase"):
+            out_record["passphrase"] = passphrase
+        if pfx := clientCertificate.get("pfx"):
+            out_record["pfx"] = base64.b64encode(pfx).decode()
+        if pfx_path := clientCertificate.get("pfxPath"):
+            out_record["pfx"] = base64.b64encode(
+                await async_readfile(pfx_path)
+            ).decode()
+        if cert := clientCertificate.get("cert"):
+            out_record["cert"] = base64.b64encode(cert).decode()
+        if cert_path := clientCertificate.get("certPath"):
+            out_record["cert"] = base64.b64encode(
+                await async_readfile(cert_path)
+            ).decode()
+        if key := clientCertificate.get("key"):
+            out_record["key"] = base64.b64encode(key).decode()
+        if key_path := clientCertificate.get("keyPath"):
+            out_record["key"] = base64.b64encode(
+                await async_readfile(key_path)
+            ).decode()
+        out.append(out_record)
+    return out
+
+
 class Request(ChannelOwner):
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
@@ -111,11 +154,7 @@ def __init__(
         self._fallback_overrides: SerializedFallbackOverrides = (
             SerializedFallbackOverrides()
         )
-        base64_post_data = initializer.get("postData")
-        if base64_post_data is not None:
-            self._fallback_overrides.post_data_buffer = base64.b64decode(
-                base64_post_data
-            )
+        self._response: Optional["Response"] = None
 
     def __repr__(self) -> str:
         return f"<Request url={self.url!r} method={self.method!r}>"
@@ -146,6 +185,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"])
@@ -154,14 +200,20 @@ 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]:
         data = self._fallback_overrides.post_data_buffer
-        if not data:
-            return None
-        return data.decode()
+        if data:
+            return data.decode()
+        base64_post_data = self._initializer.get("postData")
+        if base64_post_data is not None:
+            return base64.b64decode(base64_post_data).decode()
+        return None
 
     @property
     def post_data_json(self) -> Optional[Any]:
@@ -178,10 +230,23 @@ def post_data_json(self) -> Optional[Any]:
 
     @property
     def post_data_buffer(self) -> Optional[bytes]:
-        return self._fallback_overrides.post_data_buffer
+        if self._fallback_overrides.post_data_buffer:
+            return self._fallback_overrides.post_data_buffer
+        if self._initializer.get("postData"):
+            return base64.b64decode(self._initializer["postData"])
+        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 existing_response(self) -> Optional["Response"]:
+        return self._response
 
     @property
     def frame(self) -> "Frame":
@@ -246,7 +311,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
 
@@ -303,9 +370,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"],
                     },
                 )
             )
@@ -388,9 +455,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()
@@ -408,6 +474,7 @@ async def fetch(
         headers: Dict[str, str] = None,
         postData: Union[Any, str, bytes] = None,
         maxRedirects: int = None,
+        maxRetries: int = None,
         timeout: float = None,
     ) -> "APIResponse":
         return await self._connection.wrap_api_call(
@@ -418,6 +485,7 @@ async def fetch(
                 headers,
                 postData,
                 maxRedirects=maxRedirects,
+                maxRetries=maxRetries,
                 timeout=timeout,
             )
         )
@@ -445,48 +513,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})
             )
         )
 
@@ -496,7 +552,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(
@@ -509,12 +565,246 @@ 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
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._request: Request = from_channel(self._initializer["request"])
+        self._request._response = self
         timing = self._initializer["timing"]
         self._request._timing["startTime"] = timing["startTime"]
         self._request._timing["domainLookupStart"] = timing["domainLookupStart"]
@@ -575,15 +865,33 @@ 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 http_version(self) -> str:
+        return await self._channel.send(
+            "httpVersion",
+            None,
+        )
 
     async def finished(self) -> None:
         async def on_finished() -> None:
@@ -602,7 +910,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..7911ddb30 100644
--- a/playwright/_impl/_object_factory.py
+++ b/playwright/_impl/_object_factory.py
@@ -20,16 +20,23 @@
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._cdp_session import CDPSession
 from playwright._impl._connection import ChannelOwner
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable
 from playwright._impl._element_handle import ElementHandle
 from playwright._impl._fetch import APIRequestContext
 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
@@ -59,8 +66,12 @@ def create_remote_object(
         return BrowserContext(parent, type, guid, initializer)
     if type == "CDPSession":
         return CDPSession(parent, type, guid, initializer)
+    if type == "Debugger":
+        return Debugger(parent, type, guid, initializer)
     if type == "Dialog":
         return Dialog(parent, type, guid, initializer)
+    if type == "Disposable":
+        return Disposable(parent, type, guid, initializer)
     if type == "ElementHandle":
         return ElementHandle(parent, type, guid, initializer)
     if type == "Frame":
@@ -88,10 +99,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 db6cf13b8..5a8444624 100644
--- a/playwright/_impl/_page.py
+++ b/playwright/_impl/_page.py
@@ -22,6 +22,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
@@ -33,7 +34,6 @@
     cast,
 )
 
-from playwright._impl._accessibility import Accessibility
 from playwright._impl._api_structures import (
     AriaRole,
     FilePayload,
@@ -43,14 +43,16 @@
     ViewportSize,
 )
 from playwright._impl._artifact import Artifact
+from playwright._impl._clock import Clock
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
     from_nullable_channel,
 )
 from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._disposable import Disposable, DisposableStub
 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
@@ -59,6 +61,7 @@
 from playwright._impl._har_router import HarRouter
 from playwright._impl._helper import (
     ColorScheme,
+    Contrast,
     DocumentLoadState,
     ForcedColors,
     HarMode,
@@ -70,14 +73,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 (
@@ -87,7 +92,15 @@
     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._screencast import Screencast
 from playwright._impl._video import Video
 from playwright._impl._waiter import Waiter
 
@@ -98,6 +111,25 @@
     from playwright._impl._network import WebSocket
 
 
+class LocatorHandler:
+    locator: "Locator"
+    handler: Union[Callable[["Locator"], Any], Callable[..., Any]]
+    times: Union[int, None]
+
+    def __init__(
+        self, locator: "Locator", handler: Callable[..., Any], times: Union[int, None]
+    ) -> None:
+        self.locator = locator
+        self._handler = handler
+        self.times = times
+
+    def __call__(self) -> Any:
+        arg_count = len(inspect.signature(self._handler).parameters)
+        if arg_count == 0:
+            return self._handler()
+        return self._handler(self.locator)
+
+
 class Page(ChannelOwner):
     Events = SimpleNamespace(
         Close="close",
@@ -120,7 +152,6 @@ class Page(ChannelOwner):
         WebSocket="websocket",
         Worker="worker",
     )
-    accessibility: Accessibility
     keyboard: Keyboard
     mouse: Mouse
     touchscreen: Touchscreen
@@ -130,7 +161,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)
@@ -143,16 +173,21 @@ 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
         )
-        self._video: Optional[Video] = None
+        self._video: Video = Video(
+            self,
+            cast(Optional[Artifact], from_nullable_channel(initializer.get("video"))),
+        )
+        self._screencast: Screencast = Screencast(self)
         self._opener = cast("Page", from_nullable_channel(initializer.get("opener")))
         self._close_reason: Optional[str] = None
         self._close_was_called = False
         self._har_routers: List[HarRouter] = []
-        self._locator_handlers: Dict[str, Callable] = {}
+        self._locator_handlers: Dict[str, LocatorHandler] = {}
 
         self._channel.on(
             "bindingCall",
@@ -190,7 +225,13 @@ def __init__(
                 self._on_route(from_channel(params["route"]))
             ),
         )
-        self._channel.on("video", lambda params: self._on_video(params))
+        self._channel.on(
+            "webSocketRoute",
+            lambda params: self._loop.create_task(
+                self._on_web_socket_route(from_channel(params["webSocketRoute"]))
+            ),
+        )
+        self._channel.on("viewportSizeChanged", self._on_viewport_size_changed)
         self._channel.on(
             "webSocket",
             lambda params: self.emit(
@@ -250,7 +291,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
@@ -278,6 +319,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:
@@ -293,8 +348,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)
 
@@ -309,14 +362,17 @@ def _on_download(self, params: Any) -> None:
             Page.Events.Download, Download(self, url, suggested_filename, artifact)
         )
 
-    def _on_video(self, params: Any) -> None:
-        artifact = from_channel(params["artifact"])
-        cast(Video, self.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
 
+    @property
+    def clock(self) -> Clock:
+        return self._browser_context.clock
+
     async def opener(self) -> Optional["Page"]:
         if self._opener and self._opener.is_closed():
             return None
@@ -327,16 +383,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
@@ -345,13 +397,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,
@@ -395,12 +443,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,
@@ -453,12 +503,12 @@ async def add_style_tag(
     ) -> ElementHandle:
         return await self._main_frame.add_style_tag(**locals_to_params(locals()))
 
-    async def expose_function(self, name: str, callback: Callable) -> None:
-        await self.expose_binding(name, lambda source, *args: callback(*args))
+    async def expose_function(self, name: str, callback: Callable) -> Disposable:
+        return await self.expose_binding(name, lambda source, *args: callback(*args))
 
     async def expose_binding(
         self, name: str, callback: Callable, handle: bool = None
-    ) -> None:
+    ) -> Disposable:
         if name in self._bindings:
             raise Error(f'Function "{name}" has been already registered')
         if name in self._browser_context._bindings:
@@ -466,13 +516,19 @@ async def expose_binding(
                 f'Function "{name}" has been already registered in the browser context'
             )
         self._bindings[name] = callback
-        await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+        return from_channel(
+            await self._channel.send(
+                "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
@@ -505,7 +561,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(
@@ -536,7 +596,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(
@@ -545,15 +609,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:
@@ -570,43 +642,55 @@ 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
-    ) -> None:
+    ) -> Disposable:
         if path:
             script = add_source_url_to_script(
                 (await async_readfile(path)).decode(), path
             )
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=script))
+        return from_channel(
+            await self._channel.send("addInitScript", None, dict(source=script))
+        )
 
     async def route(
         self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
-    ) -> None:
+    ) -> DisposableStub:
         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,
             ),
         )
         await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler), self)
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
@@ -614,7 +698,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)
@@ -627,15 +711,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:
@@ -678,7 +770,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(
@@ -699,6 +803,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(
@@ -712,7 +818,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)
@@ -722,11 +830,23 @@ async def screenshot(
     async def title(self) -> str:
         return await self._main_frame.title()
 
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        depth: int = None,
+        mode: Literal["ai", "default"] = None,
+    ) -> str:
+        return await self._main_frame._channel.send(
+            "ariaSnapshot",
+            self._main_frame._timeout,
+            locals_to_params(locals()),
+        )
+
     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:
@@ -750,7 +870,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,
@@ -913,6 +1033,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()))
 
@@ -1025,7 +1146,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,
@@ -1057,7 +1180,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)
@@ -1065,13 +1188,17 @@ async def pdf(
         return decoded_binary
 
     @property
-    def video(
-        self,
-    ) -> Optional[Video]:
-        if not self._video:
-            self._video = Video(self)
+    def video(self) -> Optional[Video]:
+        # Video is only exposed when the page actually produced a recording artifact.
+        # The initializer carries the artifact; if absent, no video was recorded.
+        if not self._video._artifact:
+            return None
         return self._video
 
+    @property
+    def screencast(self) -> Screencast:
+        return self._screencast
+
     def _close_error_with_reason(self) -> TargetClosedError:
         return TargetClosedError(
             self._close_reason or self._browser_context._effective_close_reason()
@@ -1152,21 +1279,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
+        def my_predicate(request: Request) -> Union[bool, Awaitable[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 request {trimmed_url}" if trimmed_url else None
@@ -1191,21 +1311,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) -> Union[bool, Awaitable[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
@@ -1247,7 +1360,6 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 strict=strict,
                 trial=trial,
             )
@@ -1257,61 +1369,130 @@ async def set_checked(
                 position=position,
                 timeout=timeout,
                 force=force,
-                noWaitAfter=noWaitAfter,
                 strict=strict,
                 trial=trial,
             )
 
-    async def add_locator_handler(self, locator: "Locator", handler: Callable) -> None:
+    async def add_locator_handler(
+        self,
+        locator: "Locator",
+        handler: Union[Callable[["Locator"], Any], Callable[[], Any]],
+        noWaitAfter: bool = None,
+        times: int = None,
+    ) -> None:
         if locator._frame != self._main_frame:
             raise Error("Locator must belong to the main frame of this page")
+        if times == 0:
+            return
         uid = await self._channel.send(
             "registerLocatorHandler",
+            None,
             {
                 "selector": locator._selector,
+                "noWaitAfter": noWaitAfter,
             },
         )
-        self._locator_handlers[uid] = handler
+        self._locator_handlers[uid] = LocatorHandler(
+            handler=handler, times=times, locator=locator
+        )
 
     async def _on_locator_handler_triggered(self, uid: str) -> None:
+        remove = False
         try:
-            if self._dispatcher_fiber:
-                handler_finished_future = self._loop.create_future()
-
-                def _handler() -> None:
-                    try:
-                        self._locator_handlers[uid]()
-                        handler_finished_future.set_result(None)
-                    except Exception as e:
-                        handler_finished_future.set_exception(e)
-
-                g = LocatorHandlerGreenlet(_handler)
-                g.switch()
-                await handler_finished_future
-            else:
-                coro_or_future = self._locator_handlers[uid]()
-                if coro_or_future:
-                    await coro_or_future
-
+            handler = self._locator_handlers.get(uid)
+            if handler and handler.times != 0:
+                if handler.times is not None:
+                    handler.times -= 1
+                if self._dispatcher_fiber:
+                    handler_finished_future = self._loop.create_future()
+
+                    def _handler() -> None:
+                        try:
+                            handler()
+                            handler_finished_future.set_result(None)
+                        except Exception as e:
+                            handler_finished_future.set_exception(e)
+
+                    g = LocatorHandlerGreenlet(_handler)
+                    g.switch()
+                    await handler_finished_future
+                else:
+                    coro_or_future = handler()
+                    if coro_or_future:
+                        await coro_or_future
+                remove = handler.times == 0
         finally:
+            if remove:
+                del self._locator_handlers[uid]
             try:
                 await self._connection.wrap_api_call(
                     lambda: self._channel.send(
-                        "resolveLocatorHandlerNoReply", {"uid": uid}
+                        "resolveLocatorHandlerNoReply",
+                        None,
+                        {"uid": uid, "remove": remove},
                     ),
                     is_internal=True,
                 )
             except Error:
                 pass
 
+    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",
+                    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, filter: Literal["all", "since-navigation"] = None
+    ) -> List[ConsoleMessage]:
+        message_dicts = await self._channel.send(
+            "consoleMessages", None, locals_to_params(locals())
+        )
+        return [
+            ConsoleMessage(
+                {**event, "page": self._channel}, self._loop, self._dispatcher_fiber
+            )
+            for event in message_dicts
+        ]
+
+    async def page_errors(
+        self, filter: Literal["all", "since-navigation"] = None
+    ) -> List[Error]:
+        error_objects = await self._channel.send(
+            "pageErrors", None, locals_to_params(locals())
+        )
+        return [parse_error(error["error"]) for error in error_objects]
+
+    async def clear_console_messages(self) -> None:
+        await self._channel.send("clearConsoleMessages", None)
+
+    async def clear_page_errors(self) -> None:
+        await self._channel.send("clearPageErrors", None)
+
+    async def pick_locator(self) -> "Locator":
+        selector = await self._channel.send("pickLocator", None, {})
+        return self.locator(selector)
+
+    async def cancel_pick_locator(self) -> None:
+        await self._channel.send("cancelPickLocator", None, {})
+
 
 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
@@ -1334,6 +1515,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),
@@ -1347,6 +1529,7 @@ async def evaluate_handle(
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
                     arg=serialize_argument(arg),
@@ -1354,6 +1537,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__(
@@ -1372,12 +1580,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/_screencast.py b/playwright/_impl/_screencast.py
new file mode 100644
index 000000000..1f1da3c4f
--- /dev/null
+++ b/playwright/_impl/_screencast.py
@@ -0,0 +1,140 @@
+# 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 base64
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union
+
+from playwright._impl._api_structures import ScreencastFrame
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import from_nullable_channel
+from playwright._impl._disposable import DisposableStub
+from playwright._impl._errors import Error
+from playwright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
+
+ScreencastFrameCallback = Callable[[ScreencastFrame], Any]
+ScreencastPosition = Literal[
+    "bottom",
+    "bottom-left",
+    "bottom-right",
+    "top",
+    "top-left",
+    "top-right",
+]
+
+
+class Screencast:
+    def __init__(self, page: "Page") -> None:
+        self._page = page
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._started = False
+        self._save_path: Optional[Union[str, Path]] = None
+        self._on_frame: Optional[ScreencastFrameCallback] = None
+        self._artifact: Optional[Artifact] = None
+        page._channel.on("screencastFrame", lambda params: self._dispatch_frame(params))
+
+    def _dispatch_frame(self, params: dict) -> None:
+        if not self._on_frame:
+            return
+        data = params["data"]
+        if isinstance(data, str):
+            data = base64.b64decode(data)
+        result = self._on_frame({"data": data})
+        if hasattr(result, "__await__"):
+            self._page._loop.create_task(result)
+
+    async def start(
+        self,
+        onFrame: ScreencastFrameCallback = None,
+        path: Union[str, Path] = None,
+        quality: int = None,
+    ) -> DisposableStub:
+        if self._started:
+            raise Error("Screencast is already started")
+        self._started = True
+        self._on_frame = onFrame
+        result = await self._page._channel.send_return_as_dict(
+            "screencastStart",
+            None,
+            {
+                "quality": quality,
+                "sendFrames": bool(onFrame),
+                "record": bool(path),
+            },
+        )
+        artifact_channel = (result or {}).get("artifact")
+        if artifact_channel:
+            self._artifact = from_nullable_channel(artifact_channel)
+            self._save_path = path
+        return DisposableStub(lambda: self.stop(), self._page)
+
+    async def stop(self) -> None:
+        self._started = False
+        self._on_frame = None
+        await self._page._channel.send("screencastStop", None)
+        if self._save_path and self._artifact:
+            await self._artifact.save_as(self._save_path)
+        self._artifact = None
+        self._save_path = None
+
+    async def show_actions(
+        self,
+        duration: float = None,
+        position: ScreencastPosition = None,
+        fontSize: int = None,
+    ) -> DisposableStub:
+        await self._page._channel.send(
+            "screencastShowActions", None, locals_to_params(locals())
+        )
+        return DisposableStub(lambda: self.hide_actions(), self._page)
+
+    async def hide_actions(self) -> None:
+        await self._page._channel.send("screencastHideActions", None)
+
+    async def show_overlay(self, html: str, duration: float = None) -> DisposableStub:
+        result = await self._page._channel.send_return_as_dict(
+            "screencastShowOverlay", None, locals_to_params(locals())
+        )
+        overlay_id = (result or {}).get("id")
+        return DisposableStub(
+            lambda: self._page._channel.send(
+                "screencastRemoveOverlay", None, {"id": overlay_id}
+            ),
+            self._page,
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        description: str = None,
+        duration: float = None,
+    ) -> None:
+        await self._page._channel.send(
+            "screencastChapter", None, locals_to_params(locals())
+        )
+
+    async def show_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": True}
+        )
+
+    async def hide_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": False}
+        )
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 e47946be7..65307e0a2 100644
--- a/playwright/_impl/_set_input_files_helpers.py
+++ b/playwright/_impl/_set_input_files_helpers.py
@@ -14,8 +14,19 @@
 import base64
 import collections.abc
 import os
+import stat
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, TypedDict, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    cast,
+)
 
 from playwright._impl._connection import Channel, from_channel
 from playwright._impl._helper import Error
@@ -31,10 +42,20 @@
 
 class InputFilesList(TypedDict, total=False):
     streams: Optional[List[Channel]]
+    directoryStream: Optional[Channel]
+    localDirectory: Optional[str]
     localPaths: Optional[List[str]]
     payloads: Optional[List[Dict[str, Union[str, bytes]]]]
 
 
+def _list_files(directory: str) -> List[str]:
+    files = []
+    for root, _, filenames in os.walk(directory):
+        for filename in filenames:
+            files.append(os.path.join(root, filename))
+    return files
+
+
 async def convert_input_files(
     files: Union[
         str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
@@ -50,31 +71,52 @@ async def convert_input_files(
     if any([isinstance(item, (str, Path)) for item in items]):
         if not all([isinstance(item, (str, Path)) for item in items]):
             raise Error("File paths cannot be mixed with buffers")
+
+        (local_paths, local_directory) = resolve_paths_and_directory_for_input_files(
+            cast(Sequence[Union[str, Path]], items)
+        )
+
         if context._channel._connection.is_remote:
+            files_to_stream = cast(
+                List[str],
+                (_list_files(local_directory) if local_directory else local_paths),
+            )
             streams = []
-            for item in items:
-                assert isinstance(item, (str, Path))
-                last_modified_ms = int(os.path.getmtime(item) * 1000)
-                stream: WritableStream = from_channel(
-                    await context._connection.wrap_api_call(
-                        lambda: context._channel.send(
-                            "createTempFile",
-                            {
-                                "name": os.path.basename(cast(str, item)),
-                                "lastModifiedMs": last_modified_ms,
-                            },
-                        )
-                    )
+            result = await context._connection.wrap_api_call(
+                lambda: context._channel.send_return_as_dict(
+                    "createTempFiles",
+                    None,
+                    {
+                        "rootDirName": (
+                            os.path.basename(local_directory)
+                            if local_directory
+                            else None
+                        ),
+                        "items": list(
+                            map(
+                                lambda file: dict(
+                                    name=(
+                                        os.path.relpath(file, local_directory)
+                                        if local_directory
+                                        else os.path.basename(file)
+                                    ),
+                                    lastModifiedMs=int(os.path.getmtime(file) * 1000),
+                                ),
+                                files_to_stream,
+                            )
+                        ),
+                    },
                 )
-                await stream.copy(item)
+            )
+            for i, file in enumerate(result["writableStreams"]):
+                stream: WritableStream = from_channel(file)
+                await stream.copy(files_to_stream[i])
                 streams.append(stream._channel)
-            return InputFilesList(streams=streams)
-        return InputFilesList(
-            localPaths=[
-                str(Path(cast(Union[str, Path], item)).absolute().resolve())
-                for item in items
-            ]
-        )
+            return InputFilesList(
+                streams=None if local_directory else streams,
+                directoryStream=result.get("rootDir"),
+            )
+        return InputFilesList(localPaths=local_paths, localDirectory=local_directory)
 
     file_payload_exceeds_size_limit = (
         sum([len(f.get("buffer", "")) for f in items if not isinstance(f, (str, Path))])
@@ -95,3 +137,22 @@ async def convert_input_files(
             for item in cast(List[FilePayload], items)
         ]
     )
+
+
+def resolve_paths_and_directory_for_input_files(
+    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:
+        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())
+        else:
+            local_paths = local_paths or []
+            local_paths.append(str(Path(item).resolve()))
+    if local_paths and local_directory:
+        raise Error("File paths must be all files or a single directory")
+    return (local_paths, local_directory)
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 7f7972372..2798b89d9 100644
--- a/playwright/_impl/_tracing.py
+++ b/playwright/_impl/_tracing.py
@@ -15,8 +15,10 @@
 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._disposable import DisposableStub
 from playwright._impl._helper import locals_to_params
 
 
@@ -26,6 +28,7 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._include_sources: bool = False
+        self._is_live: bool = False
         self._stacks_id: Optional[str] = None
         self._is_tracing: bool = False
         self._traces_dir: Optional[str] = None
@@ -37,50 +40,56 @@ async def start(
         snapshots: bool = None,
         screenshots: bool = None,
         sources: bool = None,
+        live: bool = None,
     ) -> None:
         params = locals_to_params(locals())
         self._include_sources = bool(sources)
+        self._is_live = bool(live)
 
-        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,
+            {
+                "name": name,
+                "snapshots": snapshots,
+                "screenshots": screenshots,
+                "live": live,
+            },
+        )
+        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:
         if not self._is_tracing:
             self._is_tracing = True
-            self._connection.set_in_tracing(True)
+            self._connection.set_is_tracing(True)
         self._stacks_id = await self._connection.local_utils.tracing_started(
-            self._traces_dir, trace_name
+            self._traces_dir, trace_name, self._is_live
         )
 
     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:
-        if self._is_tracing:
-            self._is_tracing = False
-            self._connection.set_in_tracing(False)
+        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
@@ -89,7 +98,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(
                 {
@@ -104,6 +113,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",
             },
@@ -133,3 +143,20 @@ async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> No
                 "includeSources": self._include_sources,
             }
         )
+
+    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
+    ) -> DisposableStub:
+        await self._channel.send("tracingGroup", None, locals_to_params(locals()))
+        return DisposableStub(lambda: self.group_end(), self)
+
+    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 f07d31dcd..3cc029e18 100644
--- a/playwright/_impl/_transport.py
+++ b/playwright/_impl/_transport.py
@@ -105,9 +105,9 @@ async def connect(self) -> None:
         self._stopped_future: asyncio.Future = asyncio.Future()
 
         try:
-            # For pyinstaller
+            # For pyinstaller and Nuitka
             env = get_driver_env()
-            if getattr(sys, "frozen", False):
+            if getattr(sys, "frozen", False) or globals().get("__compiled__"):
                 env.setdefault("PLAYWRIGHT_BROWSERS_PATH", "0")
 
             startupinfo = None
@@ -137,38 +137,44 @@ async def connect(self) -> None:
     async def run(self) -> None:
         assert self._proc.stdout
         assert self._proc.stdin
-        while not self._stopped:
-            try:
-                buffer = await self._proc.stdout.readexactly(4)
-                if self._stopped:
-                    break
-                length = int.from_bytes(buffer, byteorder="little", signed=False)
-                buffer = bytes(0)
-                while length:
-                    to_read = min(length, 32768)
-                    data = await self._proc.stdout.readexactly(to_read)
+        try:
+            while not self._stopped:
+                try:
+                    buffer = await self._proc.stdout.readexactly(4)
+                    if self._stopped:
+                        break
+                    length = int.from_bytes(buffer, byteorder="little", signed=False)
+                    buffer = bytes(0)
+                    while length:
+                        to_read = min(length, 32768)
+                        data = await self._proc.stdout.readexactly(to_read)
+                        if self._stopped:
+                            break
+                        length -= to_read
+                        if len(buffer):
+                            buffer = buffer + data
+                        else:
+                            buffer = data
                     if self._stopped:
                         break
-                    length -= to_read
-                    if len(buffer):
-                        buffer = buffer + data
-                    else:
-                        buffer = data
-                if self._stopped:
-                    break
 
-                obj = self.deserialize_message(buffer)
-                self.on_message(obj)
-            except asyncio.IncompleteReadError:
-                if not self._stopped:
-                    self.on_error_future.set_exception(
-                        Exception("Connection closed while reading from the driver")
-                    )
-                break
-            await asyncio.sleep(0)
-
-        await self._proc.wait()
-        self._stopped_future.set_result(None)
+                    obj = self.deserialize_message(buffer)
+                    self.on_message(obj)
+                except asyncio.IncompleteReadError:
+                    if not self._stopped:
+                        self.on_error_future.set_exception(
+                            Exception("Connection closed while reading from the driver")
+                        )
+                    break
+                await asyncio.sleep(0)
+
+            await self._proc.communicate()
+        finally:
+            # Release waiters on wait_until_stopped() even if this task was
+            # cancelled before reaching the end (e.g. by asyncio.run()'s
+            # task-cancellation phase that runs before asyncio-atexit hooks).
+            if not self._stopped_future.done():
+                self._stopped_future.set_result(None)
 
     def send(self, message: Dict) -> None:
         assert self._output
diff --git a/playwright/_impl/_video.py b/playwright/_impl/_video.py
index 68dedf6f8..e991803e3 100644
--- a/playwright/_impl/_video.py
+++ b/playwright/_impl/_video.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import pathlib
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from playwright._impl._artifact import Artifact
 from playwright._impl._helper import Error
@@ -23,49 +23,34 @@
 
 
 class Video:
-    def __init__(self, page: "Page") -> None:
+    def __init__(self, page: "Page", artifact: Optional[Artifact]) -> None:
         self._loop = page._loop
         self._dispatcher_fiber = page._dispatcher_fiber
         self._page = page
-        self._artifact_future = page._loop.create_future()
-        if page.is_closed():
-            self._page_closed()
-        else:
-            page.on("close", lambda page: self._page_closed())
+        self._is_remote = page._connection.is_remote
+        self._artifact = artifact
 
     def __repr__(self) -> str:
         return f"<Video page={self._page}>"
 
-    def _page_closed(self) -> None:
-        if not self._artifact_future.done():
-            self._artifact_future.set_exception(Error("Page closed"))
-
-    def _artifact_ready(self, artifact: Artifact) -> None:
-        if not self._artifact_future.done():
-            self._artifact_future.set_result(artifact)
-
     async def path(self) -> pathlib.Path:
-        if self._page._connection.is_remote:
+        if self._is_remote:
             raise Error(
                 "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
             )
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        return artifact.absolute_path
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        return self._artifact.absolute_path
 
     async def save_as(self, path: Union[str, pathlib.Path]) -> None:
         if self._page._connection._is_sync and not self._page._is_closed:
             raise Error(
                 "Page is not yet closed. Close the page prior to calling save_as"
             )
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        await artifact.save_as(path)
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        await self._artifact.save_as(path)
 
     async def delete(self) -> None:
-        artifact = await self._artifact_future
-        if not artifact:
-            raise Error("Page did not produce any video frames")
-        await artifact.delete()
+        if self._artifact:
+            await self._artifact.delete()
diff --git a/playwright/_impl/_waiter.py b/playwright/_impl/_waiter.py
index 7b0ad2cc6..b5bf53382 100644
--- a/playwright/_impl/_waiter.py
+++ b/playwright/_impl/_waiter.py
@@ -13,10 +13,11 @@
 # limitations under the License.
 
 import asyncio
+import inspect
 import math
 import uuid
 from asyncio.tasks import Task
-from typing import Any, Callable, List, Tuple, Union
+from typing import Any, Callable, List, Optional, Tuple, Union
 
 from pyee import EventEmitter
 
@@ -38,6 +39,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 +53,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,
@@ -69,9 +72,11 @@ def reject_on_event(
         error: Union[Error, Callable[..., Error]],
         predicate: Callable = None,
     ) -> None:
+        def on_match() -> None:
+            self._reject(error() if callable(error) else error)
+
         def listener(event_data: Any = None) -> None:
-            if not predicate or predicate(event_data):
-                self._reject(error() if callable(error) else error)
+            self._evaluate_predicate(predicate, event_data, on_match)
 
         emitter.on(event, listener)
         self._registered_listeners.append((emitter, event, listener))
@@ -115,12 +120,43 @@ def wait_for_event(
         predicate: Callable = None,
     ) -> None:
         def listener(event_data: Any = None) -> None:
-            if not predicate or predicate(event_data):
-                self._fulfill(event_data)
+            self._evaluate_predicate(
+                predicate, event_data, lambda: self._fulfill(event_data)
+            )
 
         emitter.on(event, listener)
         self._registered_listeners.append((emitter, event, listener))
 
+    def _evaluate_predicate(
+        self,
+        predicate: Optional[Callable],
+        event_data: Any,
+        on_match: Callable[[], None],
+    ) -> None:
+        if predicate is None:
+            on_match()
+            return
+        try:
+            result = predicate(event_data)
+        except Exception as e:
+            self._reject(e)
+            return
+        if inspect.iscoroutine(result):
+
+            async def _await_predicate(coro: Any) -> None:
+                try:
+                    matched = await coro
+                except Exception as e:
+                    self._reject(e)
+                    return
+                if matched and not self._result.done():
+                    on_match()
+
+            self._pending_tasks.append(self._loop.create_task(_await_predicate(result)))
+            return
+        if result:
+            on_match()
+
     def result(self) -> asyncio.Future:
         return self._result
 
@@ -130,6 +166,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..6508994c3 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,
 )
 
@@ -71,12 +72,17 @@
 FloatRect = playwright._impl._api_structures.FloatRect
 Geolocation = playwright._impl._api_structures.Geolocation
 HttpCredentials = playwright._impl._api_structures.HttpCredentials
+BrowserBindResult = playwright._impl._api_structures.BrowserBindResult
+DebuggerLocation = playwright._impl._api_structures.DebuggerLocation
+DebuggerPausedDetails = playwright._impl._api_structures.DebuggerPausedDetails
 PdfMargins = playwright._impl._api_structures.PdfMargins
 Position = playwright._impl._api_structures.Position
 ProxySettings = playwright._impl._api_structures.ProxySettings
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
+ScreencastFrame = playwright._impl._api_structures.ScreencastFrame
 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 +113,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,11 +153,11 @@ def __call__(
 __all__ = [
     "expect",
     "async_playwright",
-    "Accessibility",
     "APIRequest",
     "APIRequestContext",
     "APIResponse",
     "Browser",
+    "BrowserBindResult",
     "BrowserContext",
     "BrowserType",
     "CDPSession",
@@ -174,6 +179,8 @@ def __call__(
     "Keyboard",
     "Locator",
     "Mouse",
+    "DebuggerLocation",
+    "DebuggerPausedDetails",
     "Page",
     "PdfMargins",
     "Position",
@@ -183,13 +190,17 @@ def __call__(
     "ResourceTiming",
     "Response",
     "Route",
+    "ScreencastFrame",
     "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 244a891e3..9e8737c12 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -13,13 +13,17 @@
 # limitations under the License.
 
 
+import datetime
 import pathlib
 import typing
 from typing import Literal
 
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
 from playwright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
     Cookie,
+    DebuggerLocation,
+    DebuggerPausedDetails,
     FilePayload,
     FloatRect,
     Geolocation,
@@ -31,10 +35,12 @@
     RemoteAddr,
     RequestSizes,
     ResourceTiming,
+    ScreencastFrame,
     SecurityDetails,
     SetCookieParam,
     SourceLocation,
     StorageState,
+    TracingGroupLocation,
     ViewportSize,
 )
 from playwright._impl._assertions import (
@@ -52,8 +58,11 @@
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
 from playwright._impl._errors import Error
@@ -72,9 +81,11 @@
 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
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
 from playwright._impl._tracing import Tracing as TracingImpl
 from playwright._impl._video import Video as VideoImpl
@@ -82,6 +93,7 @@
 
 
 class Request(AsyncBase):
+
     @property
     def url(self) -> str:
         """Request.url
@@ -108,6 +120,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
@@ -159,6 +189,21 @@ def post_data_buffer(self) -> typing.Optional[bytes]:
         """
         return mapping.from_maybe_impl(self._impl_obj.post_data_buffer)
 
+    @property
+    def existing_response(self) -> typing.Optional["Response"]:
+        """Request.existing_response
+
+        Returns the `Response` object if the response has already been received, `null` otherwise.
+
+        Unlike `request.response()`, this method does not wait for the response to arrive. It returns immediately
+        with the response object if the response has been received, or `null` if the response has not been received yet.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.existing_response)
+
     @property
     def frame(self) -> "Frame":
         """Request.frame
@@ -363,7 +408,7 @@ async def headers_array(self) -> typing.List[NameValue]:
     async def header_value(self, name: str) -> typing.Optional[str]:
         """Request.header_value
 
-        Returns the value of the header matching the name. The name is case insensitive.
+        Returns the value of the header matching the name. The name is case-insensitive.
 
         Parameters
         ----------
@@ -382,6 +427,7 @@ async def header_value(self, name: str) -> typing.Optional[str]:
 
 
 class Response(AsyncBase):
+
     @property
     def url(self) -> str:
         """Response.url
@@ -510,7 +556,7 @@ async def headers_array(self) -> typing.List[NameValue]:
     async def header_value(self, name: str) -> typing.Optional[str]:
         """Response.header_value
 
-        Returns the value of the header matching the name. The name is case insensitive. If multiple headers have the same
+        Returns the value of the header matching the name. The name is case-insensitive. If multiple headers have the same
         name (except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\\n` separator is
         used. If no headers are found, `null` is returned.
 
@@ -529,7 +575,7 @@ async def header_value(self, name: str) -> typing.Optional[str]:
     async def header_values(self, name: str) -> typing.List[str]:
         """Response.header_values
 
-        Returns all values of the headers matching the name, for example `set-cookie`. The name is case insensitive.
+        Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.
 
         Parameters
         ----------
@@ -567,6 +613,18 @@ async def security_details(self) -> typing.Optional[SecurityDetails]:
 
         return mapping.from_impl_nullable(await self._impl_obj.security_details())
 
+    async def http_version(self) -> str:
+        """Response.http_version
+
+        Returns the http version used by the response.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.http_version())
+
     async def finished(self) -> None:
         """Response.finished
 
@@ -618,6 +676,7 @@ async def json(self) -> typing.Any:
 
 
 class Route(AsyncBase):
+
     @property
     def request(self) -> "Request":
         """Route.request
@@ -666,9 +725,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
 
@@ -731,7 +790,8 @@ async def fetch(
         headers: typing.Optional[typing.Dict[str, str]] = None,
         post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
         max_redirects: typing.Optional[int] = None,
-        timeout: typing.Optional[float] = None
+        max_retries: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
     ) -> "APIResponse":
         """Route.fetch
 
@@ -771,6 +831,9 @@ async def handle(route):
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
@@ -786,6 +849,7 @@ async def handle(route):
                 headers=mapping.to_impl(headers),
                 postData=mapping.to_impl(post_data),
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
                 timeout=timeout,
             )
         )
@@ -796,17 +860,20 @@ 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
 
+        Continues route's request with optional overrides. The method is similar to `route.continue_()` with the
+        difference that other matching handlers will be invoked before sending the request.
+
+        **Usage**
+
         When several routes match the given pattern, they run in the order opposite to their registration. That way the
         last registered route can always override all the previous ones. In the example below, request will be handled by
         the bottom-most handler first, then it'll fall back to the previous one and in the end will be aborted by the first
         registered route.
 
-        **Usage**
-
         ```py
         await page.route(\"**/*\", lambda route: route.abort())  # Runs last.
         await page.route(\"**/*\", lambda route: route.fallback())  # Runs second.
@@ -853,6 +920,9 @@ async def handle(route, request):
         await page.route(\"**/*\", handle)
         ```
 
+        Use `route.continue_()` to immediately send the request to the network, other matching handlers won't be
+        invoked in that case.
+
         Parameters
         ----------
         url : Union[str, None]
@@ -881,11 +951,11 @@ 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_
 
-        Continues route's request with optional overrides.
+        Sends route's request to the network with optional overrides.
 
         **Usage**
 
@@ -904,9 +974,18 @@ 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
         ----------
@@ -934,6 +1013,7 @@ async def handle(route, request):
 
 
 class WebSocket(AsyncBase):
+
     @typing.overload
     def on(
         self,
@@ -1040,12 +1120,61 @@ def url(self) -> str:
         """
         return mapping.from_maybe_impl(self._impl_obj.url)
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["str"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
     def expect_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager:
         """WebSocket.expect_event
 
@@ -1073,12 +1202,61 @@ def expect_event(
             ).future
         )
 
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "str": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
     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:
         """WebSocket.wait_for_event
 
@@ -1125,7 +1303,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
 
@@ -1140,7 +1446,8 @@ async def down(self, key: str) -> None:
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -1246,7 +1553,8 @@ async def press(self, key: str, *, delay: typing.Optional[float] = None) -> None
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -1287,6 +1595,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:
@@ -1297,9 +1606,12 @@ async def move(
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         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))
@@ -1308,7 +1620,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
 
@@ -1330,7 +1642,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
 
@@ -1355,7 +1667,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
 
@@ -1364,7 +1676,9 @@ async def click(
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
         button : Union["left", "middle", "right", None]
@@ -1385,7 +1699,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
 
@@ -1395,7 +1709,9 @@ async def dblclick(
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
         button : Union["left", "middle", "right", None]
@@ -1409,7 +1725,8 @@ async def dblclick(
     async def wheel(self, delta_x: float, delta_y: float) -> None:
         """Mouse.wheel
 
-        Dispatches a `wheel` event.
+        Dispatches a `wheel` event. This method is usually used to manually scroll the page. See
+        [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
 
         **NOTE** Wheel events may cause scrolling if they are not handled, and this method does not wait for the scrolling
         to finish before returning.
@@ -1431,6 +1748,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
 
@@ -1441,7 +1759,9 @@ async def tap(self, x: float, y: float) -> None:
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         """
 
         return mapping.from_maybe_impl(await self._impl_obj.tap(x=x, y=y))
@@ -1451,6 +1771,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:
@@ -1606,6 +1927,7 @@ async def json_value(self) -> typing.Any:
 
 
 class ElementHandle(JSHandle):
+
     def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
@@ -1831,6 +2153,8 @@ async def scroll_into_view_if_needed(
         Throws when `elementHandle` does not point to an element
         [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
 
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
+
         Parameters
         ----------
         timeout : Union[float, None]
@@ -1846,13 +2170,13 @@ async def hover(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -1860,7 +2184,6 @@ async def hover(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -1869,9 +2192,10 @@ async def hover(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -1879,9 +2203,8 @@ async def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         trial : Union[bool, None]
@@ -1904,7 +2227,7 @@ async def click(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -1913,7 +2236,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
 
@@ -1930,9 +2254,10 @@ async def click(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -1951,9 +2276,13 @@ async def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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.
+        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(
@@ -1967,6 +2296,7 @@ async def click(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -1974,7 +2304,7 @@ async def dblclick(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -1982,7 +2312,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
 
@@ -1990,8 +2321,6 @@ async def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -2002,9 +2331,10 @@ async def dblclick(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -2018,12 +2348,14 @@ async def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
+        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(
@@ -2036,6 +2368,7 @@ async def dblclick(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -2050,7 +2383,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
 
@@ -2095,9 +2428,8 @@ async def select_option(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
 
         Returns
         -------
@@ -2120,13 +2452,13 @@ async def tap(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -2134,7 +2466,6 @@ async def tap(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -2145,9 +2476,10 @@ async def tap(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -2157,9 +2489,8 @@ async def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2182,7 +2513,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
 
@@ -2204,9 +2535,8 @@ async def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -2221,7 +2551,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
 
@@ -2280,12 +2610,13 @@ 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
 
         Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then
-        they are resolved relative to the current working directory. For empty array, clears the selected files.
+        they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs
+        with a `[webkitdirectory]` attribute, only a single directory path is supported.
 
         This method expects `ElementHandle` to point to an
         [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside
@@ -2299,9 +2630,8 @@ async def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -2324,7 +2654,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
 
@@ -2345,9 +2675,8 @@ async def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -2362,7 +2691,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
 
@@ -2377,7 +2706,8 @@ async def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -2400,6 +2730,7 @@ async def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -2416,7 +2747,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
 
@@ -2427,7 +2758,6 @@ async def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -2446,9 +2776,8 @@ async def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2472,7 +2801,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
 
@@ -2482,7 +2811,6 @@ async def check(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -2501,9 +2829,8 @@ async def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2526,7 +2853,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
 
@@ -2536,7 +2863,6 @@ async def uncheck(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -2555,9 +2881,8 @@ async def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2608,7 +2933,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,
@@ -2616,7 +2941,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
 
@@ -2663,7 +2988,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`.
@@ -2829,7 +3156,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
 
@@ -2869,7 +3196,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
 
@@ -2926,77 +3253,13 @@ 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`.
+class FileChooser(AsyncBase):
 
-        **Usage**
+    @property
+    def page(self) -> "Page":
+        """FileChooser.page
 
-        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
-
-        Returns page this file chooser belongs to.
+        Returns page this file chooser belongs to.
 
         Returns
         -------
@@ -3039,7 +3302,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
 
@@ -3053,9 +3316,8 @@ async def set_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -3069,6 +3331,7 @@ async def set_files(
 
 
 class Frame(AsyncBase):
+
     @property
     def page(self) -> "Page":
         """Frame.page
@@ -3140,7 +3403,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
 
@@ -3205,7 +3468,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
 
@@ -3230,7 +3493,7 @@ def expect_navigation(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str, None]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -3265,7 +3528,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
 
@@ -3281,7 +3544,7 @@ async def wait_for_url(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -3311,7 +3574,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
 
@@ -3321,6 +3584,9 @@ async def wait_for_load_state(
         committed when this method is called. If current document has already reached the required state, resolves
         immediately.
 
+        **NOTE** Most of the time, this method is not needed because Playwright
+        [auto-waits before every action](https://playwright.dev/python/docs/actionability).
+
         **Usage**
 
         ```py
@@ -3544,7 +3810,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
 
@@ -3617,7 +3883,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
 
@@ -3651,7 +3917,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
 
@@ -3685,7 +3951,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
 
@@ -3719,7 +3985,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
 
@@ -3749,11 +4015,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
 
@@ -3768,8 +4030,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
         -------
@@ -3777,17 +4037,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
 
@@ -3802,8 +4056,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
         -------
@@ -3811,9 +4063,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(
@@ -3823,7 +4073,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
 
@@ -3893,7 +4143,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
 
@@ -3999,7 +4249,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
 
@@ -4047,9 +4297,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
 
@@ -4067,7 +4317,7 @@ async def add_script_tag(
         content : Union[str, None]
             Raw JavaScript content to be injected into frame.
         type : Union[str, None]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See
+            Script type. Use 'module' in order to load a JavaScript ES6 module. See
             [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.
 
         Returns
@@ -4085,8 +4335,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
 
@@ -4119,7 +4369,7 @@ async def click(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -4129,7 +4379,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
 
@@ -4149,9 +4399,10 @@ async def click(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4170,12 +4421,15 @@ async def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         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.
         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(
@@ -4199,7 +4453,7 @@ async def dblclick(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -4208,7 +4462,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
 
@@ -4217,8 +4471,7 @@ async def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `force` option is set. If
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
-        1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
+        1. Use `page.mouse` to double click in the center of the element, or the specified `position`. if
            the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -4231,9 +4484,10 @@ async def dblclick(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4247,15 +4501,16 @@ async def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -4278,14 +4533,14 @@ async def tap(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -4295,7 +4550,6 @@ async def tap(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -4307,9 +4561,10 @@ async def tap(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4319,15 +4574,16 @@ async def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -4351,7 +4607,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
 
@@ -4377,9 +4633,8 @@ async def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -4402,10 +4657,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
 
@@ -4463,7 +4718,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
 
@@ -4500,7 +4755,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
 
@@ -4541,7 +4796,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
 
@@ -4670,10 +4925,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
 
@@ -4694,7 +4949,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -4727,6 +4982,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`.
 
@@ -4793,7 +5049,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         await page.get_by_test_id(\"directions\").click()
@@ -4820,7 +5076,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
 
@@ -4884,7 +5140,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
 
@@ -4952,7 +5208,7 @@ async def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.focus
 
@@ -4983,7 +5239,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
 
@@ -5017,7 +5273,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
 
@@ -5051,7 +5307,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
 
@@ -5086,7 +5342,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
 
@@ -5122,14 +5378,14 @@ async def hover(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -5139,7 +5395,6 @@ async def hover(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -5149,9 +5404,10 @@ async def hover(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -5159,9 +5415,8 @@ async def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -5169,7 +5424,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(
@@ -5196,7 +5453,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
 
@@ -5217,9 +5475,8 @@ async def drag_and_drop(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5229,6 +5486,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(
@@ -5242,6 +5502,7 @@ async def drag_and_drop(
                 strict=strict,
                 timeout=timeout,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -5258,7 +5519,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
 
@@ -5303,9 +5564,8 @@ async def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5336,7 +5596,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
 
@@ -5382,7 +5642,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
 
@@ -5407,9 +5667,8 @@ async def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -5430,7 +5689,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
 
@@ -5457,9 +5716,8 @@ async def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -5481,7 +5739,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
 
@@ -5494,7 +5752,8 @@ async def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -5523,6 +5782,7 @@ async def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -5545,7 +5805,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
 
@@ -5557,7 +5817,6 @@ async def check(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5577,9 +5836,8 @@ async def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5609,7 +5867,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
 
@@ -5621,7 +5879,6 @@ async def uncheck(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5641,9 +5898,8 @@ async def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5688,7 +5944,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
 
@@ -5775,7 +6031,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
 
@@ -5787,7 +6043,6 @@ async def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5809,9 +6064,8 @@ async def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5838,6 +6092,7 @@ async def set_checked(
 
 
 class FrameLocator(AsyncBase):
+
     @property
     def first(self) -> "FrameLocator":
         """FrameLocator.first
@@ -5876,7 +6131,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()
@@ -5892,10 +6147,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
 
@@ -5950,7 +6205,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
 
@@ -5987,7 +6242,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
 
@@ -6028,7 +6283,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
 
@@ -6157,10 +6412,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
 
@@ -6181,7 +6436,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -6214,6 +6469,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`.
 
@@ -6280,7 +6536,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         await page.get_by_test_id(\"directions\").click()
@@ -6307,7 +6563,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
 
@@ -6371,7 +6627,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
 
@@ -6445,6 +6701,8 @@ def nth(self, index: int) -> "FrameLocator":
 
 
 class Worker(AsyncBase):
+
+    @typing.overload
     def on(
         self,
         event: Literal["close"],
@@ -6453,8 +6711,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"],
@@ -6463,6 +6740,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
@@ -6540,18 +6835,87 @@ async def evaluate_handle(
             )
         )
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager:
+        """Worker.expect_event
+
+        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**
+
+        ```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
 
@@ -6641,41 +7005,235 @@ def set_test_id_attribute(self, attribute_name: str) -> None:
 mapping.register(SelectorsImpl, Selectors)
 
 
-class ConsoleMessage(AsyncBase):
-    @property
-    def type(self) -> str:
-        """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'`.
+class Clock(AsyncBase):
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.type)
+    async def install(
+        self,
+        *,
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
+    ) -> None:
+        """Clock.install
 
-    @property
-    def text(self) -> str:
-        """ConsoleMessage.text
+        Install fake implementations for the following time-related functions:
+        - `Date`
+        - `setTimeout`
+        - `clearTimeout`
+        - `setInterval`
+        - `clearInterval`
+        - `requestAnimationFrame`
+        - `cancelAnimationFrame`
+        - `requestIdleCallback`
+        - `cancelIdleCallback`
+        - `performance`
 
-        The text of the console message.
+        Fake timers are used to manually control the flow of time in tests. They allow you to advance time, fire timers,
+        and control the behavior of time-dependent functions. See `clock.run_for()` and
+        `clock.fast_forward()` for more information.
 
-        Returns
-        -------
-        str
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str, None]
+            Time to initialize with, current system time by default.
         """
-        return mapping.from_maybe_impl(self._impl_obj.text)
 
-    @property
-    def args(self) -> typing.List["JSHandle"]:
-        """ConsoleMessage.args
+        return mapping.from_maybe_impl(await self._impl_obj.install(time=time))
 
-        List of arguments passed to a `console` function call. See also `page.on('console')`.
+    async def fast_forward(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.fast_forward
 
-        Returns
-        -------
+        Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user
+        closing the laptop lid for a while and reopening it later, after given time.
+
+        **Usage**
+
+        ```py
+        await page.clock.fast_forward(1000)
+        await page.clock.fast_forward(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are
+            "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.fast_forward(ticks=ticks))
+
+    async def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.pause_at
+
+        Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers are fired
+        unless `clock.run_for()`, `clock.fast_forward()`, `clock.pause_at()` or
+        `clock.resume()` is called.
+
+        Only fires due timers at most once. This is equivalent to user closing the laptop lid for a while and reopening it
+        at the specified time and pausing.
+
+        **Usage**
+
+        ```py
+        await page.clock.pause_at(datetime.datetime(2020, 2, 2))
+        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]
+            Time to pause at.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.pause_at(time=time))
+
+    async def resume(self) -> None:
+        """Clock.resume
+
+        Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.resume())
+
+    async def run_for(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.run_for
+
+        Advance the clock, firing all the time-related callbacks.
+
+        **Usage**
+
+        ```py
+        await page.clock.run_for(1000);
+        await page.clock.run_for(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are
+            "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.run_for(ticks=ticks))
+
+    async def set_fixed_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.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
+        await page.clock.set_fixed_time(datetime.datetime.now())
+        await page.clock.set_fixed_time(datetime.datetime(2020, 2, 2))
+        await page.clock.set_fixed_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.set_fixed_time(time=time))
+
+    async def set_system_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.set_system_time
+
+        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**
+
+        ```py
+        await page.clock.set_system_time(datetime.datetime.now())
+        await page.clock.set_system_time(datetime.datetime(2020, 2, 2))
+        await page.clock.set_system_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.set_system_time(time=time))
+
+
+mapping.register(ClockImpl, Clock)
+
+
+class ConsoleMessage(AsyncBase):
+
+    @property
+    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
+
+        Returns
+        -------
+        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)
+
+    @property
+    def text(self) -> str:
+        """ConsoleMessage.text
+
+        The text of the console message.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.text)
+
+    @property
+    def args(self) -> typing.List["JSHandle"]:
+        """ConsoleMessage.args
+
+        List of arguments passed to a `console` function call. See also `page.on('console')`.
+
+        Returns
+        -------
         List[JSHandle]
         """
         return mapping.from_impl_list(self._impl_obj.args)
@@ -6690,6 +7248,18 @@ def location(self) -> SourceLocation:
         """
         return mapping.from_impl(self._impl_obj.location)
 
+    @property
+    def timestamp(self) -> float:
+        """ConsoleMessage.timestamp
+
+        The timestamp of the console message in milliseconds since the Unix epoch.
+
+        Returns
+        -------
+        float
+        """
+        return mapping.from_maybe_impl(self._impl_obj.timestamp)
+
     @property
     def page(self) -> typing.Optional["Page"]:
         """ConsoleMessage.page
@@ -6702,11 +7272,134 @@ 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 Debugger(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["pausedstatechanged"],
+        f: typing.Callable[["None"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    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["pausedstatechanged"],
+        f: typing.Callable[["None"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def paused_details(self) -> typing.Optional[DebuggerPausedDetails]:
+        """Debugger.paused_details
+
+        Returns details about the currently paused call. Returns `null` if the debugger is not paused.
+
+        Returns
+        -------
+        Union[{location: {file: str, line: Union[int, None], column: Union[int, None]}, title: str}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.paused_details)
+
+    async def request_pause(self) -> None:
+        """Debugger.request_pause
+
+        Configures the debugger to pause before the next action is executed.
+
+        Throws if the debugger is already paused. Use `debugger.next()` or `debugger.run_to()` to step while
+        paused.
+
+        Note that `page.pause()` is equivalent to a \"debugger\" statement — it pauses execution at the call site
+        immediately. On the contrary, `debugger.request_pause()` is equivalent to \"pause on next statement\" — it
+        configures the debugger to pause before the next action is executed.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.request_pause())
+
+    async def resume(self) -> None:
+        """Debugger.resume
+
+        Resumes script execution. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.resume())
+
+    async def next(self) -> None:
+        """Debugger.next
+
+        Resumes script execution and pauses again before the next action. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.next())
+
+    async def run_to(self, location: DebuggerLocation) -> None:
+        """Debugger.run_to
+
+        Resumes script execution and pauses when an action originates from the given source location. Throws if the
+        debugger is not paused.
+
+        Parameters
+        ----------
+        location : {file: str, line: Union[int, None], column: Union[int, None]}
+            The source location to pause at.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.run_to(location=location))
+
+
+mapping.register(DebuggerImpl, Debugger)
+
+
 class Dialog(AsyncBase):
+
     @property
     def type(self) -> str:
         """Dialog.type
@@ -6783,6 +7476,7 @@ async def dismiss(self) -> None:
 
 
 class Download(AsyncBase):
+
     @property
     def page(self) -> "Page":
         """Download.page
@@ -6891,57 +7585,222 @@ async def cancel(self) -> None:
 mapping.register(DownloadImpl, Download)
 
 
-class Video(AsyncBase):
-    async def path(self) -> pathlib.Path:
-        """Video.path
+class Screencast(AsyncBase):
 
-        Returns the file system path this video will be recorded to. The video is guaranteed to be written to the
-        filesystem upon closing the browser context. This method throws when connected remotely.
+    async def start(
+        self,
+        *,
+        on_frame: typing.Optional[
+            typing.Callable[[ScreencastFrame], typing.Any]
+        ] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """Screencast.start
+
+        Starts the screencast. When `path` is provided, it saves video recording to the specified file. When `onFrame` is
+        provided, delivers JPEG-encoded frames to the callback. Both can be used together.
+
+        **Usage**
+
+        Parameters
+        ----------
+        on_frame : Union[Callable[[{data: bytes}], Any], None]
+            Callback that receives JPEG-encoded frame data.
+        path : Union[pathlib.Path, str, None]
+            Path where the video should be saved when the screencast is stopped. When provided, video recording is started.
+        quality : Union[int, None]
+            The quality of the image, between 0-100.
 
         Returns
         -------
-        pathlib.Path
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(await self._impl_obj.path())
+        return mapping.from_impl(
+            await self._impl_obj.start(
+                onFrame=self._wrap_handler(on_frame), path=path, quality=quality
+            )
+        )
 
-    async def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
-        """Video.save_as
+    async def stop(self) -> None:
+        """Screencast.stop
 
-        Saves the video to a user-specified path. It is safe to call this method while the video is still in progress, or
-        after the page has closed. This method waits until the page is closed and the video is fully saved.
+        Stops the screencast and video recording if active. If a video was being recorded, saves it to the path specified
+        in `screencast.start()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop())
+
+    async def show_actions(
+        self,
+        *,
+        duration: typing.Optional[float] = None,
+        position: typing.Optional[
+            Literal[
+                "bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right"
+            ]
+        ] = None,
+        font_size: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """Screencast.show_actions
+
+        Enables visual annotations on interacted elements. Returns a disposable that stops showing actions when disposed.
 
         Parameters
         ----------
-        path : Union[pathlib.Path, str]
-            Path where the video should be saved.
+        duration : Union[float, None]
+            How long each annotation is displayed in milliseconds. Defaults to `500`.
+        position : Union["bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right", None]
+            Position of the action title overlay. Defaults to `"top-right"`.
+        font_size : Union[int, None]
+            Font size of the action title in pixels. Defaults to `24`.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(await self._impl_obj.save_as(path=path))
+        return mapping.from_impl(
+            await self._impl_obj.show_actions(
+                duration=duration, position=position, fontSize=font_size
+            )
+        )
 
-    async def delete(self) -> None:
-        """Video.delete
+    async def hide_actions(self) -> None:
+        """Screencast.hide_actions
 
-        Deletes the video file. Will wait for the video to finish if necessary.
+        Removes action decorations.
         """
 
-        return mapping.from_maybe_impl(await self._impl_obj.delete())
+        return mapping.from_maybe_impl(await self._impl_obj.hide_actions())
 
+    async def show_overlay(
+        self, html: str, *, duration: typing.Optional[float] = None
+    ) -> "AsyncContextManager":
+        """Screencast.show_overlay
 
-mapping.register(VideoImpl, Video)
+        Adds an overlay with the given HTML content. The overlay is displayed on top of the page until removed. Returns a
+        disposable that removes the overlay when disposed.
 
+        Parameters
+        ----------
+        html : str
+            HTML content for the overlay.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Overlay stays until dismissed if not
+            provided.
 
-class Page(AsyncContextManager):
-    @typing.overload
-    def on(
-        self,
-        event: Literal["close"],
-        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
-    ) -> None:
+        Returns
+        -------
+        AsyncContextManager
         """
-        Emitted when the page closes."""
 
-    @typing.overload
+        return mapping.from_impl(
+            await self._impl_obj.show_overlay(html=html, duration=duration)
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        *,
+        description: typing.Optional[str] = None,
+        duration: typing.Optional[float] = None,
+    ) -> None:
+        """Screencast.show_chapter
+
+        Shows a chapter overlay with a title and optional description, centered on the page with a blurred backdrop. Useful
+        for narrating video recordings. The overlay is removed after the specified duration, or 2000ms.
+
+        Parameters
+        ----------
+        title : str
+            Title text displayed prominently in the overlay.
+        description : Union[str, None]
+            Optional description text displayed below the title.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Defaults to `2000`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.show_chapter(
+                title=title, description=description, duration=duration
+            )
+        )
+
+    async def show_overlays(self) -> None:
+        """Screencast.show_overlays
+
+        Shows overlays.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.show_overlays())
+
+    async def hide_overlays(self) -> None:
+        """Screencast.hide_overlays
+
+        Hides overlays without removing them.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.hide_overlays())
+
+
+mapping.register(ScreencastImpl, Screencast)
+
+
+class Video(AsyncBase):
+
+    async def path(self) -> pathlib.Path:
+        """Video.path
+
+        Returns the file system path this video will be recorded to. The video is guaranteed to be written to the
+        filesystem upon closing the browser context. This method throws when connected remotely.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.path())
+
+    async def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Video.save_as
+
+        Saves the video to a user-specified path. It is safe to call this method while the video is still in progress, or
+        after the page has closed. This method waits until the page is closed and the video is fully saved.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the video should be saved.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.save_as(path=path))
+
+    async def delete(self) -> None:
+        """Video.delete
+
+        Deletes the video file. Will wait for the video to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.delete())
+
+
+mapping.register(VideoImpl, Video)
+
+
+class Page(AsyncContextManager):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
     def on(
         self,
         event: Literal["console"],
@@ -7114,7 +7973,9 @@ def on(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         async with page.expect_event(\"popup\") as page_info:
@@ -7382,7 +8243,9 @@ def once(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         async with page.expect_event(\"popup\") as page_info:
@@ -7468,16 +8331,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
@@ -7520,6 +8373,18 @@ def context(self) -> "BrowserContext":
         """
         return mapping.from_impl(self._impl_obj.context)
 
+    @property
+    def clock(self) -> "Clock":
+        """Page.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
     @property
     def main_frame(self) -> "Frame":
         """Page.main_frame
@@ -7597,7 +8462,8 @@ def request(self) -> "APIRequestContext":
     def video(self) -> typing.Optional["Video"]:
         """Page.video
 
-        Video object associated with this page.
+        Video object associated with this page. Can be used to access the video file when using the `recordVideo` context
+        option.
 
         Returns
         -------
@@ -7605,6 +8471,20 @@ def video(self) -> typing.Optional["Video"]:
         """
         return mapping.from_impl_nullable(self._impl_obj.video)
 
+    @property
+    def screencast(self) -> "Screencast":
+        """Page.screencast
+
+        `Screencast` object associated with this page.
+
+        **Usage**
+
+        Returns
+        -------
+        Screencast
+        """
+        return mapping.from_impl(self._impl_obj.screencast)
+
     async def opener(self) -> typing.Optional["Page"]:
         """Page.opener
 
@@ -7623,7 +8503,7 @@ def frame(
         *,
         url: typing.Optional[
             typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Frame"]:
         """Page.frame
 
@@ -7686,7 +8566,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(
@@ -7746,7 +8626,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
 
@@ -7819,7 +8699,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
 
@@ -7853,7 +8733,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
 
@@ -7887,7 +8767,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
 
@@ -7921,7 +8801,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
 
@@ -7955,7 +8835,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
 
@@ -7989,7 +8869,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
 
@@ -8025,7 +8905,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
 
@@ -8207,7 +9087,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
 
@@ -8294,9 +9174,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
 
@@ -8313,7 +9193,7 @@ async def add_script_tag(
         content : Union[str, None]
             Raw JavaScript content to be injected into frame.
         type : Union[str, None]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See
+            Script type. Use 'module' in order to load a JavaScript ES6 module. See
             [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.
 
         Returns
@@ -8331,8 +9211,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
 
@@ -8358,7 +9238,9 @@ async def add_style_tag(
             await self._impl_obj.add_style_tag(url=url, path=path, content=content)
         )
 
-    async def expose_function(self, name: str, callback: typing.Callable) -> None:
+    async def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
         """Page.expose_function
 
         The method adds a function called `name` on the `window` object of every frame in the page. When called, the
@@ -8412,9 +9294,13 @@ async def main():
             Name of the function on the window object
         callback : Callable
             Callback function which will be called in Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.expose_function(
                 name=name, callback=self._wrap_handler(callback)
             )
@@ -8425,8 +9311,8 @@ async def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
-    ) -> None:
+        handle: typing.Optional[bool] = None,
+    ) -> "AsyncContextManager":
         """Page.expose_binding
 
         The method adds a function called `name` on the `window` object of every frame in this page. When called, the
@@ -8471,22 +9357,6 @@ async def main():
         asyncio.run(main())
         ```
 
-        An example of passing an element handle:
-
-        ```py
-        async def print(source, element):
-            print(await element.text_content())
-
-        await page.expose_binding(\"clicked\", print, handle=true)
-        await page.set_content(\"\"\"
-          <script>
-            document.addEventListener('click', event => window.clicked(event.target));
-          </script>
-          <div>Click me</div>
-          <div>Or click me</div>
-        \"\"\")
-        ```
-
         Parameters
         ----------
         name : str
@@ -8496,9 +9366,14 @@ async def print(source, element):
         handle : Union[bool, None]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is
             supported. When passing by value, multiple arguments are supported.
+            Deprecated: This option will be removed in the future.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.expose_binding(
                 name=name, callback=self._wrap_handler(callback), handle=handle
             )
@@ -8542,7 +9417,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
 
@@ -8582,7 +9457,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
 
@@ -8646,7 +9521,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
 
@@ -8685,7 +9560,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
 
@@ -8695,6 +9570,9 @@ async def wait_for_load_state(
         committed when this method is called. If current document has already reached the required state, resolves
         immediately.
 
+        **NOTE** Most of the time, this method is not needed because Playwright
+        [auto-waits before every action](https://playwright.dev/python/docs/actionability).
+
         **Usage**
 
         ```py
@@ -8738,7 +9616,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
 
@@ -8754,7 +9632,7 @@ async def wait_for_url(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -8778,96 +9656,276 @@ async def wait_for_url(
             )
         )
 
+    @typing.overload
     async def wait_for_event(
         self,
-        event: str,
-        predicate: typing.Optional[typing.Callable] = None,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
-    ) -> typing.Any:
-        """Page.wait_for_event
-
-        **NOTE** In most cases, you should use `page.expect_event()`.
-
-        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
-        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
-        `event` is fired.
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
 
-        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()`.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
 
-        Returns
-        -------
-        Any
-        """
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
 
-        return mapping.from_maybe_impl(
-            await self._impl_obj.wait_for_event(
-                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
-            )
-        )
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
 
-    async def go_back(
+    @typing.overload
+    async def wait_for_event(
         self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
         timeout: typing.Optional[float] = None,
-        wait_until: typing.Optional[
-            Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
-    ) -> typing.Optional["Response"]:
-        """Page.go_back
+    ) -> "Page": ...
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
-        the last redirect. If can not go back, returns `null`.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
 
-        Navigate to the previous page in history.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "FileChooser": ...
 
-        Parameters
-        ----------
-        timeout : Union[float, None]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_navigation_timeout()`,
-            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
-            `page.set_default_timeout()` methods.
-        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
-            When to consider operation succeeded, defaults to `load`. Events can be either:
-            - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.
-            - `'load'` - consider operation to be finished when the `load` event is fired.
-            - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for
-              at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.
-            - `'commit'` - consider operation to be finished when network response is received and the document started
-              loading.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-        Returns
-        -------
-        Union[Response, None]
-        """
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-        return mapping.from_impl_nullable(
-            await self._impl_obj.go_back(timeout=timeout, waitUntil=wait_until)
-        )
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-    async def go_forward(
+    @typing.overload
+    async def wait_for_event(
         self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
         timeout: typing.Optional[float] = None,
-        wait_until: typing.Optional[
-            Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
-    ) -> typing.Optional["Response"]:
-        """Page.go_forward
+    ) -> "Page": ...
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
-        the last redirect. If can not go forward, returns `null`.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Error": ...
 
-        Navigate to the next page in history.
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any:
+        """Page.wait_for_event
+
+        **NOTE** In most cases, you should use `page.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
+        `event` is fired.
+
+        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
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_event(
+                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+            )
+        )
+
+    async def go_back(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_back
+
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect. If cannot go back, returns `null`.
+
+        Navigate to the previous page in history.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            When to consider operation succeeded, defaults to `load`. Events can be either:
+            - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.
+            - `'load'` - consider operation to be finished when the `load` event is fired.
+            - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for
+              at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.
+            - `'commit'` - consider operation to be finished when network response is received and the document started
+              loading.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.go_back(timeout=timeout, waitUntil=wait_until)
+        )
+
+    async def go_forward(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_forward
+
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect. If cannot go forward, returns `null`.
+
+        Navigate to the next page in history.
 
         Parameters
         ----------
@@ -8894,6 +9952,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,
         *,
@@ -8904,7 +9984,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
 
@@ -8938,8 +10019,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
@@ -8948,12 +10027,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(
@@ -8962,6 +10043,7 @@ async def emulate_media(
                 colorScheme=color_scheme,
                 reducedMotion=reduced_motion,
                 forcedColors=forced_colors,
+                contrast=contrast,
             )
         )
 
@@ -9005,8 +10087,8 @@ async def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
-    ) -> None:
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "AsyncContextManager":
         """Page.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -9036,9 +10118,13 @@ async def add_init_script(
         path : Union[pathlib.Path, str, None]
             Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
             directory. Optional.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.add_init_script(script=script, path=path)
         )
 
@@ -9050,8 +10136,8 @@ async def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
-    ) -> None:
+        times: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
         """Page.route
 
         Routing provides the capability to modify network requests that are made by a page.
@@ -9063,7 +10149,10 @@ 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.
 
         **Usage**
 
@@ -9097,6 +10186,8 @@ async def handle_route(route: Route):
         await page.route(\"/api/**\", handle_route)
         ```
 
+        If a request matches multiple registered routes, the most recently registered route takes precedence.
+
         Page routes take precedence over browser context routes (set up with `browser_context.route()`) when request
         matches both handlers.
 
@@ -9107,16 +10198,20 @@ 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.
         times : Union[int, None]
             How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.route(
                 url=self._wrap_handler(url),
                 handler=self._wrap_handler(handler),
@@ -9142,7 +10237,7 @@ async def unroute(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing.
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while routing.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
             Optional handler function to route the request.
         """
@@ -9153,10 +10248,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
 
@@ -9165,7 +10303,7 @@ async def unroute_all(
         Parameters
         ----------
         behavior : Union["default", "ignoreErrors", "wait", None]
-            Specifies wether to wait for already running handlers and what to do if they throw errors:
+            Specifies whether to wait for already running handlers and what to do if they throw errors:
             - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may
               result in unhandled error
             - `'wait'` - wait for current handler calls (if any) to finish
@@ -9181,11 +10319,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
 
@@ -9194,7 +10332,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
         ----------
@@ -9217,7 +10355,8 @@ async def route_from_har(
             separate files or entries in the ZIP archive. If `embed` is specified, content is stored inline the HAR file.
         update_mode : Union["full", "minimal", None]
             When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,
-            cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.
+            cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to
+            `minimal`.
         """
 
         return mapping.from_maybe_impl(
@@ -9236,7 +10375,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,
@@ -9246,7 +10385,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
 
@@ -9291,7 +10430,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`.
@@ -9335,11 +10476,42 @@ async def title(self) -> str:
 
         return mapping.from_maybe_impl(await self._impl_obj.title())
 
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+    ) -> str:
+        """Page.aria_snapshot
+
+        Captures the aria snapshot of the page. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots).
+
+        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.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption: including element references like `[ref=e2]`
+            and snapshots of `<iframe>`s. Defaults to `"default"`.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(timeout=timeout, depth=depth, mode=mode)
+        )
+
     async def close(
         self,
         *,
         run_before_unload: typing.Optional[bool] = None,
-        reason: typing.Optional[str] = None
+        reason: typing.Optional[str] = None,
     ) -> None:
         """Page.close
 
@@ -9381,7 +10553,7 @@ async def click(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -9391,7 +10563,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
 
@@ -9411,9 +10583,10 @@ async def click(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9432,9 +10605,12 @@ async def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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.
@@ -9461,7 +10637,7 @@ async def dblclick(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -9470,7 +10646,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
 
@@ -9480,8 +10656,6 @@ async def dblclick(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -9493,9 +10667,10 @@ async def dblclick(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9509,15 +10684,16 @@ async def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -9540,14 +10716,14 @@ async def tap(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -9557,7 +10733,6 @@ async def tap(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -9569,9 +10744,10 @@ async def tap(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9581,15 +10757,16 @@ async def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -9613,7 +10790,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
 
@@ -9639,9 +10816,8 @@ async def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -9664,10 +10840,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
 
@@ -9723,7 +10899,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
 
@@ -9760,7 +10936,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
 
@@ -9801,7 +10977,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
 
@@ -9930,10 +11106,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
 
@@ -9954,7 +11130,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -9987,6 +11163,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`.
 
@@ -10053,7 +11230,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         await page.get_by_test_id(\"directions\").click()
@@ -10080,7 +11257,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
 
@@ -10144,7 +11321,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
 
@@ -10212,7 +11389,7 @@ async def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.focus
 
@@ -10243,7 +11420,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
 
@@ -10277,7 +11454,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
 
@@ -10311,7 +11488,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
 
@@ -10346,7 +11523,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
 
@@ -10382,14 +11559,14 @@ async def hover(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -10399,7 +11576,6 @@ async def hover(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -10409,9 +11585,10 @@ async def hover(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -10419,9 +11596,8 @@ async def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -10429,7 +11605,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(
@@ -10456,7 +11634,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
 
@@ -10493,9 +11672,8 @@ async def drag_and_drop(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10505,6 +11683,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(
@@ -10518,6 +11699,7 @@ async def drag_and_drop(
                 timeout=timeout,
                 strict=strict,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -10534,7 +11716,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
 
@@ -10580,9 +11762,8 @@ async def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -10613,7 +11794,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
 
@@ -10659,12 +11840,13 @@ 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
 
         Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then
-        they are resolved relative to the current working directory. For empty array, clears the selected files.
+        they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs
+        with a `[webkitdirectory]` attribute, only a single directory path is supported.
 
         This method expects `selector` to point to an
         [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside
@@ -10684,9 +11866,8 @@ async def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -10707,7 +11888,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
 
@@ -10731,9 +11912,8 @@ async def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10758,7 +11938,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
 
@@ -10773,7 +11953,8 @@ async def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -10813,6 +11994,7 @@ async def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         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.
@@ -10838,7 +12020,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
 
@@ -10850,7 +12032,6 @@ async def check(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -10870,9 +12051,8 @@ async def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10902,7 +12082,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
 
@@ -10914,7 +12094,6 @@ async def uncheck(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -10934,9 +12113,8 @@ async def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10988,7 +12166,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
 
@@ -11056,14 +12234,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())
@@ -11083,16 +12260,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()`:
 
@@ -11204,12 +12379,192 @@ async def pdf(
             )
         )
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["FileChooser"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Error"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
     def expect_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager:
         """Page.expect_event
 
@@ -11249,7 +12604,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
 
@@ -11280,7 +12635,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
 
@@ -11311,7 +12666,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
 
@@ -11347,7 +12702,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
 
@@ -11374,7 +12729,7 @@ def expect_navigation(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str, None]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -11406,7 +12761,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
 
@@ -11436,10 +12791,12 @@ def expect_popup(
     def expect_request(
         self,
         url_or_predicate: typing.Union[
-            str, typing.Pattern[str], typing.Callable[["Request"], bool]
+            str,
+            typing.Pattern[str],
+            typing.Callable[["Request"], typing.Union[bool, typing.Awaitable[bool]]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Request"]:
         """Page.expect_request
 
@@ -11461,7 +12818,7 @@ def expect_request(
 
         Parameters
         ----------
-        url_or_predicate : Union[Callable[[Request], bool], Pattern[str], str]
+        url_or_predicate : Union[Callable[[Request], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
             Request URL string, regex or predicate receiving `Request` object. When a `baseURL` via the context options was
             provided and the passed URL is a path, it gets merged via the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
@@ -11484,7 +12841,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
 
@@ -11514,10 +12871,12 @@ def expect_request_finished(
     def expect_response(
         self,
         url_or_predicate: typing.Union[
-            str, typing.Pattern[str], typing.Callable[["Response"], bool]
+            str,
+            typing.Pattern[str],
+            typing.Callable[["Response"], typing.Union[bool, typing.Awaitable[bool]]],
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> AsyncEventContextManager["Response"]:
         """Page.expect_response
 
@@ -11533,7 +12892,7 @@ def expect_response(
         return response.ok
 
         # or with a lambda
-        async with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200) as response_info:
+        async with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200 and response.request.method == \"get\") as response_info:
             await page.get_by_text(\"trigger response\").click()
         response = await response_info.value
         return response.ok
@@ -11541,7 +12900,7 @@ def expect_response(
 
         Parameters
         ----------
-        url_or_predicate : Union[Callable[[Response], bool], Pattern[str], str]
+        url_or_predicate : Union[Callable[[Response], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
             Request URL string, regex or predicate receiving `Response` object. When a `baseURL` via the context options was
             provided and the passed URL is a path, it gets merged via the
             [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
@@ -11564,7 +12923,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
 
@@ -11595,7 +12954,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
 
@@ -11632,7 +12991,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
 
@@ -11644,7 +13003,6 @@ async def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -11666,9 +13024,8 @@ async def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -11691,12 +13048,17 @@ async def set_checked(
         )
 
     async def add_locator_handler(
-        self, locator: "Locator", handler: typing.Callable
+        self,
+        locator: "Locator",
+        handler: typing.Union[
+            typing.Callable[["Locator"], typing.Any], typing.Callable[[], typing.Any]
+        ],
+        *,
+        no_wait_after: typing.Optional[bool] = None,
+        times: typing.Optional[int] = None,
     ) -> None:
         """Page.add_locator_handler
 
-        **NOTE** This method is experimental and its behavior may change in the upcoming releases.
-
         When testing a web page, sometimes unexpected overlays like a \"Sign up\" dialog appear and block actions you want to
         automate, e.g. clicking a button. These overlays don't always show up in the same way or at the same time, making
         them tricky to handle in automated tests.
@@ -11712,6 +13074,8 @@ async def add_locator_handler(
           is visible, Playwright calls the handler first, and then proceeds with the action/assertion. Note that the
           handler is only called when you perform an action/assertion - if the overlay becomes visible but you don't
           perform any actions, the handler will not be triggered.
+        - After executing the handler, Playwright will ensure that overlay that triggered the handler is not visible
+          anymore. You can opt-out of this behavior with `noWaitAfter`.
         - The execution time of the handler counts towards the timeout of the action/assertion that executed the handler.
           If your handler takes too long, it might cause timeouts.
         - You can register multiple handlers. However, only a single handler will be running at a time. Make sure the
@@ -11719,13 +13083,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**
 
@@ -11756,107 +13123,243 @@ def handler():
         ```
 
         An example with a custom callback on every actionability check. It uses a `<body>` locator that is always visible,
-        so the handler is called before every actionability check:
+        so the handler is called before every actionability check. It is important to specify `noWaitAfter`, because the
+        handler does not hide the `<body>` element.
 
         ```py
         # Setup the handler.
         def handler():
           page.evaluate(\"window.removeObstructionsForTestIfNeeded()\")
-        page.add_locator_handler(page.locator(\"body\"), handler)
+        page.add_locator_handler(page.locator(\"body\"), handler, no_wait_after=True)
 
         # Write the test as usual.
         page.goto(\"https://example.com\")
         page.get_by_role(\"button\", name=\"Start here\").click()
         ```
 
+        Handler takes the original locator as an argument. You can also automatically remove the handler after a number of
+        invocations by setting `times`:
+
+        ```py
+        def handler(locator):
+          locator.click()
+        page.add_locator_handler(page.get_by_label(\"Close\"), handler, times=1)
+        ```
+
         Parameters
         ----------
         locator : Locator
             Locator that triggers the handler.
-        handler : Callable
+        handler : Union[Callable[[Locator], Any], Callable[[], Any]]
             Function that should be run once `locator` appears. This function should get rid of the element that blocks actions
             like click.
+        no_wait_after : Union[bool, None]
+            By default, after calling the handler Playwright will wait until the overlay becomes hidden, and only then
+            Playwright will continue with the action/assertion that triggered the handler. This option allows to opt-out of
+            this behavior, so that overlay can stay visible after the handler has run.
+        times : Union[int, None]
+            Specifies the maximum number of times this handler should be called. Unlimited by default.
         """
 
         return mapping.from_maybe_impl(
             await self._impl_obj.add_locator_handler(
-                locator=locator._impl_obj, handler=self._wrap_handler(handler)
+                locator=locator._impl_obj,
+                handler=self._wrap_handler(handler),
+                noWaitAfter=no_wait_after,
+                times=times,
             )
         )
 
+    async def remove_locator_handler(self, locator: "Locator") -> None:
+        """Page.remove_locator_handler
 
-mapping.register(PageImpl, Page)
+        Removes all locator handlers added by `page.add_locator_handler()` for a specific locator.
+
+        Parameters
+        ----------
+        locator : Locator
+            Locator passed to `page.add_locator_handler()`.
+        """
 
+        return mapping.from_maybe_impl(
+            await self._impl_obj.remove_locator_handler(locator=locator._impl_obj)
+        )
 
-class WebError(AsyncBase):
-    @property
-    def page(self) -> typing.Optional["Page"]:
-        """WebError.page
+    async def requests(self) -> typing.List["Request"]:
+        """Page.requests
 
-        The page that produced this unhandled exception, if any.
+        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
         -------
-        Union[Page, None]
+        List[Request]
         """
-        return mapping.from_impl_nullable(self._impl_obj.page)
 
-    @property
-    def error(self) -> "Error":
-        """WebError.error
+        return mapping.from_impl_list(await self._impl_obj.requests())
 
-        Unhandled error that was thrown.
+    async def console_messages(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which messages are returned:
 
         Returns
         -------
-        Error
+        List[ConsoleMessage]
         """
-        return mapping.from_impl(self._impl_obj.error)
 
+        return mapping.from_impl_list(
+            await self._impl_obj.console_messages(filter=filter)
+        )
 
-mapping.register(WebErrorImpl, WebError)
+    async def page_errors(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> 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.
 
-class BrowserContext(AsyncContextManager):
-    @typing.overload
-    def on(
-        self,
-        event: Literal["backgroundpage"],
-        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
-    ) -> None:
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
+        Returns
+        -------
+        List[Error]
         """
-        **NOTE** Only works with Chromium browser's persistent context.
 
-        Emitted when new background page is created in the context.
+        return mapping.from_impl_list(await self._impl_obj.page_errors(filter=filter))
 
-        ```py
-        background_page = await context.wait_for_event(\"backgroundpage\")
-        ```"""
+    async def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
 
-    @typing.overload
-    def on(
-        self,
-        event: Literal["close"],
-        f: typing.Callable[
-            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
-        ],
-    ) -> None:
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
         """
-        Emitted when Browser context gets closed. This might happen because of one of the following:
-        - Browser context is closed.
-        - Browser application is closed or crashed.
-        - The `browser.close()` method was called."""
 
-    @typing.overload
-    def on(
-        self,
-        event: Literal["console"],
-        f: typing.Callable[
-            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
-        ],
-    ) -> None:
-        """
-        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
+        return mapping.from_maybe_impl(await self._impl_obj.clear_console_messages())
+
+    async def clear_page_errors(self) -> None:
+        """Page.clear_page_errors
+
+        Clears all stored page errors from this page. Subsequent calls to `page.page_errors()` will only return
+        errors thrown after the clear.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.clear_page_errors())
+
+    async def pick_locator(self) -> "Locator":
+        """Page.pick_locator
+
+        Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+        Once the user clicks an element, the mode is deactivated and the `Locator` for the picked element is returned.
+
+        **Usage**
+
+        ```py
+        locator = await page.pick_locator()
+        print(locator)
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(await self._impl_obj.pick_locator())
+
+    async def cancel_pick_locator(self) -> None:
+        """Page.cancel_pick_locator
+
+        Cancels an ongoing `page.pick_locator()` call by deactivating pick locator mode. If no pick locator mode is
+        active, this method is a no-op.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.cancel_pick_locator())
+
+
+mapping.register(PageImpl, Page)
+
+
+class WebError(AsyncBase):
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """WebError.page
+
+        The page that produced this unhandled exception, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def error(self) -> "Error":
+        """WebError.error
+
+        Unhandled error that was thrown.
+
+        Returns
+        -------
+        Error
+        """
+        return mapping.from_impl(self._impl_obj.error)
+
+
+mapping.register(WebErrorImpl, WebError)
+
+
+class BrowserContext(AsyncContextManager):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["backgroundpage"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when Browser context gets closed. This might happen because of one of the following:
+        - Browser context is closed.
+        - Browser application is closed or crashed.
+        - The `browser.close()` method was called."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
 
         The arguments passed into `console.log` and the page are available on the `ConsoleMessage` event handler argument.
 
@@ -11907,7 +13410,9 @@ def on(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         async with context.expect_page() as page_info:
@@ -12003,13 +13508,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(
@@ -12085,7 +13584,9 @@ def once(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         async with context.expect_page() as page_info:
@@ -12190,7 +13691,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
         -------
@@ -12202,9 +13704,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
         -------
@@ -12236,6 +13736,18 @@ def tracing(self) -> "Tracing":
         """
         return mapping.from_impl(self._impl_obj.tracing)
 
+    @property
+    def debugger(self) -> "Debugger":
+        """BrowserContext.debugger
+
+        Debugger allows to pause and resume the execution.
+
+        Returns
+        -------
+        Debugger
+        """
+        return mapping.from_impl(self._impl_obj.debugger)
+
     @property
     def request(self) -> "APIRequestContext":
         """BrowserContext.request
@@ -12248,6 +13760,18 @@ def request(self) -> "APIRequestContext":
         """
         return mapping.from_impl(self._impl_obj.request)
 
+    @property
+    def clock(self) -> "Clock":
+        """BrowserContext.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
     def set_default_navigation_timeout(self, timeout: float) -> None:
         """BrowserContext.set_default_navigation_timeout
 
@@ -12284,7 +13808,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(
@@ -12318,7 +13842,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(
@@ -12339,10 +13863,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]}]
-            Adds cookies to the browser context.
-
-            For the cookie to apply to all subdomains as well, prefix domain with a dot, like this: ".example.com".
+        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(
@@ -12352,9 +13873,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
 
@@ -12395,22 +13916,30 @@ 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:
-            - `'geolocation'`
-            - `'midi'`
-            - `'midi-sysex'` (system-exclusive midi)
-            - `'notifications'`
-            - `'camera'`
-            - `'microphone'`
-            - `'background-sync'`
-            - `'ambient-light-sensor'`
+            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'`
-            - `'gyroscope'`
-            - `'magnetometer'`
-            - `'accessibility-events'`
+            - `'ambient-light-sensor'`
+            - `'background-sync'`
+            - `'camera'`
             - `'clipboard-read'`
             - `'clipboard-write'`
+            - `'geolocation'`
+            - `'gyroscope'`
+            - `'local-fonts'`
+            - `'local-network-access'`
+            - `'magnetometer'`
+            - `'microphone'`
+            - `'midi-sysex'` (system-exclusive midi)
+            - `'midi'`
+            - `'notifications'`
             - `'payment-handler'`
+            - `'storage-access'`
+            - `'screen-wake-lock'`
         origin : Union[str, None]
             The [origin] to grant permissions to, e.g. "https://example.com".
         """
@@ -12502,8 +14031,8 @@ async def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
-    ) -> None:
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "AsyncContextManager":
         """BrowserContext.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -12533,9 +14062,13 @@ async def add_init_script(
         path : Union[pathlib.Path, str, None]
             Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
             directory. Optional.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.add_init_script(script=script, path=path)
         )
 
@@ -12544,8 +14077,8 @@ async def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
-    ) -> None:
+        handle: typing.Optional[bool] = None,
+    ) -> "AsyncContextManager":
         """BrowserContext.expose_binding
 
         The method adds a function called `name` on the `window` object of every frame in every page in the context. When
@@ -12588,22 +14121,6 @@ async def main():
         asyncio.run(main())
         ```
 
-        An example of passing an element handle:
-
-        ```py
-        async def print(source, element):
-            print(await element.text_content())
-
-        await context.expose_binding(\"clicked\", print, handle=true)
-        await page.set_content(\"\"\"
-          <script>
-            document.addEventListener('click', event => window.clicked(event.target));
-          </script>
-          <div>Click me</div>
-          <div>Or click me</div>
-        \"\"\")
-        ```
-
         Parameters
         ----------
         name : str
@@ -12613,15 +14130,22 @@ async def print(source, element):
         handle : Union[bool, None]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is
             supported. When passing by value, multiple arguments are supported.
+            Deprecated: This option will be removed in the future.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.expose_binding(
                 name=name, callback=self._wrap_handler(callback), handle=handle
             )
         )
 
-    async def expose_function(self, name: str, callback: typing.Callable) -> None:
+    async def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
         """BrowserContext.expose_function
 
         The method adds a function called `name` on the `window` object of every frame in every page in the context. When
@@ -12674,9 +14198,13 @@ async def main():
             Name of the function on the window object.
         callback : Callable
             Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.expose_function(
                 name=name, callback=self._wrap_handler(callback)
             )
@@ -12690,8 +14218,8 @@ async def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
-    ) -> None:
+        times: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
         """BrowserContext.route
 
         Routing provides the capability to modify network requests that are made by any page in the browser context. Once
@@ -12699,7 +14227,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**
 
@@ -12746,16 +14274,20 @@ 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.
         times : Union[int, None]
             How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        AsyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.route(
                 url=self._wrap_handler(url),
                 handler=self._wrap_handler(handler),
@@ -12781,7 +14313,7 @@ async def unroute(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] used to register a routing with
+            A glob pattern, regex pattern, or predicate receiving [URL] used to register a routing with
             `browser_context.route()`.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
             Optional handler function used to register a routing with `browser_context.route()`.
@@ -12793,10 +14325,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
 
@@ -12805,7 +14382,7 @@ async def unroute_all(
         Parameters
         ----------
         behavior : Union["default", "ignoreErrors", "wait", None]
-            Specifies wether to wait for already running handlers and what to do if they throw errors:
+            Specifies whether to wait for already running handlers and what to do if they throw errors:
             - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may
               result in unhandled error
             - `'wait'` - wait for current handler calls (if any) to finish
@@ -12821,11 +14398,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
 
@@ -12834,7 +14411,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
         ----------
@@ -12872,53 +14449,173 @@ async def route_from_har(
             )
         )
 
+    @typing.overload
     def expect_event(
         self,
-        event: str,
-        predicate: typing.Optional[typing.Callable] = None,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
-    ) -> AsyncEventContextManager:
-        """BrowserContext.expect_event
-
-        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 context closes before the event is fired. Returns the event data value.
-
-        **Usage**
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
 
-        ```py
-        async with context.expect_event(\"page\") as event_info:
-            await page.get_by_role(\"button\").click()
-        page = await event_info.value
-        ```
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["BrowserContext"]: ...
 
-        Parameters
-        ----------
-        event : str
-            Event name, same one would pass into `browserContext.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()`.
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
 
-        Returns
-        -------
-        EventContextManager
-        """
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Dialog"]: ...
 
-        return AsyncEventContextManager(
-            self._impl_obj.expect_event(
-                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
-            ).future
-        )
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
 
-    async def close(self, *, reason: typing.Optional[str] = None) -> None:
-        """BrowserContext.close
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebError"]: ...
 
-        Closes the browser context. All the pages that belong to the browser context will be closed.
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
 
-        **NOTE** The default browser context cannot be closed.
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager:
+        """BrowserContext.expect_event
+
+        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 context closes before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        async with context.expect_event(\"page\") as event_info:
+            await page.get_by_role(\"button\").click()
+        page = await event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one would pass into `browserContext.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
+        )
+
+    def is_closed(self) -> bool:
+        """BrowserContext.is_closed
+
+        Indicates that the browser context is in the process of closing or has already been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    async def close(self, *, reason: typing.Optional[str] = None) -> None:
+        """BrowserContext.close
+
+        Closes the browser context. All the pages that belong to the browser context will be closed.
+
+        **NOTE** The default browser context cannot be closed.
 
         Parameters
         ----------
@@ -12929,31 +14626,176 @@ 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 set_storage_state(
+        self, storage_state: typing.Union[StorageState, str, pathlib.Path]
+    ) -> None:
+        """BrowserContext.set_storage_state
+
+        Clears the existing cookies, local storage and IndexedDB entries for all origins and sets the new storage state.
+
+        **Usage**
+
+        ```py
+        # Load storage state from a file and apply it to the context.
+        await context.set_storage_state(\"state.json\")
+        ```
+
+        Parameters
+        ----------
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_storage_state(storageState=storage_state)
+        )
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "BrowserContext": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebError": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
 
     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
 
@@ -12988,7 +14830,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
 
@@ -13020,7 +14862,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
 
@@ -13074,6 +14916,59 @@ async def new_cdp_session(
 
 
 class CDPSession(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["CDPSession"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    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"],
+        f: typing.Callable[
+            ["CDPSession"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
     async def send(
         self, method: str, params: typing.Optional[typing.Dict] = None
     ) -> typing.Dict:
@@ -13109,6 +15004,8 @@ async def detach(self) -> None:
 
 
 class Browser(AsyncContextManager):
+
+    @typing.overload
     def on(
         self,
         event: Literal["disconnected"],
@@ -13119,18 +15016,45 @@ def on(
         following:
         - Browser application is closed or crashed.
         - The `browser.close()` method was called."""
-        return super().on(event=event, f=f)
 
-    def once(
+    @typing.overload
+    def on(
         self,
-        event: Literal["disconnected"],
-        f: typing.Callable[["Browser"], "typing.Union[typing.Awaitable[None], None]"],
-    ) -> None:
-        """
-        Emitted when Browser gets disconnected from the browser application. This might happen because of one of the
-        following:
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    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["disconnected"],
+        f: typing.Callable[["Browser"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when Browser gets disconnected from the browser application. This might happen because of one of the
+        following:
         - Browser application is closed or crashed.
         - The `browser.close()` method was called."""
+
+    @typing.overload
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
         return super().once(event=event, f=f)
 
     @property
@@ -13143,9 +15067,9 @@ def contexts(self) -> typing.List["BrowserContext"]:
 
         ```py
         browser = await pw.webkit.launch()
-        print(len(browser.contexts())) # prints `0`
+        print(len(browser.contexts)) # prints `0`
         context = await browser.new_context()
-        print(len(browser.contexts())) # prints `1`
+        print(len(browser.contexts)) # prints `1`
         ```
 
         Returns
@@ -13217,12 +15141,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]
@@ -13231,10 +15156,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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """Browser.new_context
 
@@ -13296,7 +15222,7 @@ async def new_context(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -13310,9 +15236,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
@@ -13321,14 +15247,14 @@ 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]
             Network proxy settings to use with this context. Defaults to none.
-
-            **NOTE** For Chromium on Windows the browser needs to be launched with the global proxy for this option to work. If
-            all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({
-            proxy: { server: 'http://per-context' } })`.
         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()`
@@ -13375,6 +15301,23 @@ async def new_context(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -13403,6 +15346,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,
@@ -13417,6 +15361,7 @@ async def new_context(
                 recordHarUrlFilter=record_har_url_filter,
                 recordHarMode=record_har_mode,
                 recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
             )
         )
 
@@ -13444,15 +15389,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]
@@ -13461,10 +15407,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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "Page":
         """Browser.new_page
 
@@ -13510,7 +15457,7 @@ async def new_page(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -13524,13 +15471,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
@@ -13539,10 +15490,6 @@ async def new_page(
             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]
             Network proxy settings to use with this context. Defaults to none.
-
-            **NOTE** For Chromium on Windows the browser needs to be launched with the global proxy for this option to work. If
-            all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({
-            proxy: { server: 'http://per-context' } })`.
         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()`
@@ -13589,6 +15536,23 @@ async def new_page(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -13616,6 +15580,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,
@@ -13631,6 +15596,7 @@ async def new_page(
                 recordHarUrlFilter=record_har_url_filter,
                 recordHarMode=record_har_mode,
                 recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
             )
         )
 
@@ -13643,9 +15609,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.
 
@@ -13671,13 +15637,56 @@ async def new_browser_cdp_session(self) -> "CDPSession":
 
         return mapping.from_impl(await self._impl_obj.new_browser_cdp_session())
 
+    async def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BrowserBindResult:
+        """Browser.bind
+
+        Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
+
+        Parameters
+        ----------
+        title : str
+            Title of the browser server, used for identification.
+        workspace_dir : Union[str, None]
+            Working directory associated with this browser server.
+        host : Union[str, None]
+            Host to bind the web socket server to. When specified, a web socket server is created instead of a named pipe.
+        port : Union[int, None]
+            Port to bind the web socket server to. When specified, a web socket server is created instead of a named pipe. Use
+            `0` to let the OS pick an available port.
+
+        Returns
+        -------
+        {endpoint: str}
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.bind(
+                title=title, workspaceDir=workspace_dir, host=host, port=port
+            )
+        )
+
+    async def unbind(self) -> None:
+        """Browser.unbind
+
+        Unbinds the browser server previously bound with `browser.bind()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.unbind())
+
     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
 
@@ -13740,6 +15749,7 @@ async def stop_tracing(self) -> bytes:
 
 
 class BrowserType(AsyncBase):
+
     @property
     def name(self) -> str:
         """BrowserType.name
@@ -13767,7 +15777,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[
@@ -13779,15 +15789,15 @@ 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,
+        artifacts_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
 
@@ -13825,9 +15835,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.
 
@@ -13850,12 +15863,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]
@@ -13867,12 +15875,19 @@ async def launch(
             on.
         traces_dir : Union[pathlib.Path, str, None]
             If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
         chromium_sandbox : Union[bool, None]
             Enable Chromium sandboxing. Defaults to `false`.
         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.
+
         Returns
         -------
         Browser
@@ -13890,11 +15905,11 @@ async def launch(
                 timeout=timeout,
                 env=mapping.to_impl(env),
                 headless=headless,
-                devtools=devtools,
                 proxy=proxy,
                 downloadsPath=downloads_path,
                 slowMo=slow_mo,
                 tracesDir=traces_dir,
+                artifactsDir=artifacts_dir,
                 chromiumSandbox=chromium_sandbox,
                 firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
             )
@@ -13905,7 +15920,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]]
@@ -13916,9 +15931,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,
@@ -13944,24 +15958,27 @@ 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,
+        artifacts_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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -13973,15 +15990,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,
@@ -14008,12 +16039,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]
@@ -14057,7 +16083,7 @@ async def launch_persistent_context(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -14071,9 +16097,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
@@ -14082,15 +16108,26 @@ 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]
             If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
         chromium_sandbox : Union[bool, None]
             Enable Chromium sandboxing. Defaults to `false`.
         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()`
@@ -14132,6 +16169,23 @@ async def launch_persistent_context(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -14151,7 +16205,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,
@@ -14175,8 +16228,10 @@ async def launch_persistent_context(
                 colorScheme=color_scheme,
                 reducedMotion=reduced_motion,
                 forcedColors=forced_colors,
+                contrast=contrast,
                 acceptDownloads=accept_downloads,
                 tracesDir=traces_dir,
+                artifactsDir=artifacts_dir,
                 chromiumSandbox=chromium_sandbox,
                 firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
                 recordHarPath=record_har_path,
@@ -14189,6 +16244,7 @@ async def launch_persistent_context(
                 recordHarUrlFilter=record_har_url_filter,
                 recordHarMode=record_har_mode,
                 recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
             )
         )
 
@@ -14198,7 +16254,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
 
@@ -14208,6 +16265,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
@@ -14229,6 +16290,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
         -------
@@ -14241,28 +16305,30 @@ async def connect_over_cdp(
                 timeout=timeout,
                 slowMo=slow_mo,
                 headers=mapping.to_impl(headers),
+                isLocal=is_local,
             )
         )
 
     async def connect(
         self,
-        ws_endpoint: str,
+        endpoint: str,
         *,
         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.
+        endpoint : str
+            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]
@@ -14292,7 +16358,7 @@ async def connect(
 
         return mapping.from_impl(
             await self._impl_obj.connect(
-                wsEndpoint=ws_endpoint,
+                endpoint=endpoint,
                 timeout=timeout,
                 slowMo=slow_mo,
                 headers=mapping.to_impl(headers),
@@ -14305,6 +16371,7 @@ async def connect(
 
 
 class Playwright(AsyncBase):
+
     @property
     def devices(self) -> typing.Dict:
         """Playwright.devices
@@ -14399,6 +16466,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:
@@ -14429,6 +16497,7 @@ async def stop(self) -> None:
 
 
 class Tracing(AsyncBase):
+
     async def start(
         self,
         *,
@@ -14436,12 +16505,22 @@ 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,
+        live: 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
@@ -14455,8 +16534,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]
@@ -14467,6 +16546,10 @@ async def start(
             Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
         sources : Union[bool, None]
             Whether to include source files for trace actions.
+        live : Union[bool, None]
+            When enabled, the trace is written to an unarchived file that is updated in real time as actions occur, instead of
+            caching changes and archiving them into a zip file at the end. This is useful for live trace viewing during test
+            execution.
         """
 
         return mapping.from_maybe_impl(
@@ -14476,6 +16559,7 @@ async def start(
                 snapshots=snapshots,
                 screenshots=screenshots,
                 sources=sources,
+                live=live,
             )
         )
 
@@ -14512,8 +16596,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(
@@ -14521,7 +16605,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
 
@@ -14536,7 +16620,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
 
@@ -14550,11 +16634,58 @@ 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
+    ) -> "AsyncContextManager":
+        """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.
+        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.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_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
@@ -14623,6 +16754,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]:
@@ -14673,7 +16827,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
 
@@ -14687,7 +16841,6 @@ async def check(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -14712,9 +16865,8 @@ async def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -14734,7 +16886,7 @@ async def click(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -14743,7 +16895,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
 
@@ -14780,9 +16933,10 @@ async def click(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -14801,9 +16955,15 @@ async def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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(
@@ -14817,6 +16977,7 @@ async def click(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -14824,7 +16985,7 @@ async def dblclick(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -14832,7 +16993,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
 
@@ -14844,8 +17006,6 @@ async def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -14856,9 +17016,10 @@ async def dblclick(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -14872,12 +17033,16 @@ async def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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(
@@ -14890,6 +17055,7 @@ async def dblclick(
                 force=force,
                 noWaitAfter=no_wait_after,
                 trial=trial,
+                steps=steps,
             )
         )
 
@@ -14898,7 +17064,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
 
@@ -14934,7 +17100,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})
         ```
@@ -14961,7 +17126,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
 
@@ -14978,9 +17143,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
@@ -14991,8 +17158,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
         -------
@@ -15052,7 +17219,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
 
@@ -15081,8 +17248,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
         -------
@@ -15101,7 +17268,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
 
@@ -15133,9 +17300,8 @@ async def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -15151,7 +17317,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
 
@@ -15179,9 +17345,8 @@ async def clear(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -15196,10 +17361,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
 
@@ -15254,7 +17419,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
 
@@ -15291,7 +17456,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
 
@@ -15332,7 +17497,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
 
@@ -15461,10 +17626,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
 
@@ -15485,7 +17650,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -15518,6 +17683,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`.
 
@@ -15584,7 +17750,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         await page.get_by_test_id(\"directions\").click()
@@ -15611,7 +17777,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
 
@@ -15675,7 +17841,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
 
@@ -15790,13 +17956,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
 
@@ -15838,6 +18030,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
         -------
@@ -15850,23 +18044,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()
@@ -15894,7 +18096,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
@@ -15944,9 +18146,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**
 
@@ -15992,7 +18198,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
 
@@ -16025,9 +18232,8 @@ async def drag_to(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -16040,6 +18246,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(
@@ -16051,6 +18260,7 @@ async def drag_to(
                 trial=trial,
                 sourcePosition=source_position,
                 targetPosition=target_position,
+                steps=steps,
             )
         )
 
@@ -16085,13 +18295,13 @@ async def hover(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -16109,7 +18319,6 @@ async def hover(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -16118,9 +18327,10 @@ async def hover(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -16128,14 +18338,15 @@ async def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             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(
@@ -16283,7 +18494,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.
@@ -16394,7 +18607,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
 
@@ -16419,7 +18632,8 @@ async def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -16442,6 +18656,7 @@ async def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -16455,7 +18670,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,
@@ -16463,7 +18678,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
 
@@ -16526,7 +18741,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`.
@@ -16556,6 +18773,90 @@ async def screenshot(
             )
         )
 
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = 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\"
+        ```
+
+        An AI-optimized snapshot, controlled by `mode`, is different from a default snapshot:
+        1. Includes element references `[ref=e2]`. 2. Does not wait for an element matching the locator, and throws when
+           no elements match. 3. Includes snapshots of `<iframe>`s inside the target.
+
+        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.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(timeout=timeout, depth=depth, mode=mode)
+        )
+
+    async def normalize(self) -> "Locator":
+        """Locator.normalize
+
+        Returns a new locator that uses best practices for referencing the matched element, prioritizing test ids, aria
+        roles, and other user-facing attributes over CSS selectors. This is useful for converting implementation-detail
+        selectors into more resilient, human-readable locators.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(await self._impl_obj.normalize())
+
     async def scroll_into_view_if_needed(
         self, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -16565,6 +18866,8 @@ async def scroll_into_view_if_needed(
         it is completely visible as defined by
         [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
 
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
+
         Parameters
         ----------
         timeout : Union[float, None]
@@ -16587,7 +18890,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
 
@@ -16611,9 +18914,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>
         ```
 
@@ -16642,9 +18945,8 @@ async def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
 
@@ -16669,7 +18971,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
 
@@ -16704,11 +19006,12 @@ 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
 
-        Upload file or multiple files into `<input type=file>`.
+        Upload file or multiple files into `<input type=file>`. For inputs with a `[webkitdirectory]` attribute, only a
+        single directory path is supported.
 
         **Usage**
 
@@ -16719,6 +19022,9 @@ async def set_input_files(
         # Select multiple files
         await page.get_by_label(\"Upload files\").set_input_files(['file1.txt', 'file2.txt'])
 
+        # Select a directory
+        await page.get_by_label(\"Upload directory\").set_input_files('mydir')
+
         # Remove all the selected files
         await page.get_by_label(\"Upload file\").set_input_files([])
 
@@ -16747,9 +19053,8 @@ async def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -16762,17 +19067,18 @@ async def tap(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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**
 
@@ -16780,7 +19086,6 @@ async def tap(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -16791,9 +19096,10 @@ async def tap(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -16803,12 +19109,13 @@ async def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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(
@@ -16853,7 +19160,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
 
@@ -16874,9 +19181,8 @@ async def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -16891,7 +19197,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
 
@@ -16928,9 +19234,8 @@ async def press_sequentially(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -16946,7 +19251,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
 
@@ -16966,7 +19271,6 @@ async def uncheck(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -16985,9 +19289,8 @@ async def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -17051,7 +19354,7 @@ async def wait_for(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> None:
         """Locator.wait_for
 
@@ -17094,7 +19397,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
 
@@ -17115,7 +19418,6 @@ async def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -17134,9 +19436,8 @@ async def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -17167,6 +19468,7 @@ async def highlight(self) -> None:
 
 
 class APIResponse(AsyncBase):
+
     @property
     def ok(self) -> bool:
         """APIResponse.ok
@@ -17231,8 +19533,8 @@ def headers(self) -> typing.Dict[str, str]:
     def headers_array(self) -> typing.List[NameValue]:
         """APIResponse.headers_array
 
-        An array with all the request HTTP headers associated with this response. Header names are not lower-cased. Headers
-        with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+        An array with all the response HTTP headers associated with this response. Header names are not lower-cased.
+        Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
 
         Returns
         -------
@@ -17291,25 +19593,31 @@ async def dispose(self) -> None:
 
 
 class APIRequestContext(AsyncBase):
-    async def dispose(self) -> None:
+
+    async def dispose(self, *, reason: typing.Optional[str] = None) -> None:
         """APIRequestContext.dispose
 
         All responses returned by `a_pi_request_context.get()` and similar methods are stored in the memory, so that
         you can later call `a_pi_response.body()`.This method discards all its resources, calling any method on
         disposed `APIRequestContext` will throw an exception.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context disposal.
         """
 
-        return mapping.from_maybe_impl(await self._impl_obj.dispose())
+        return mapping.from_maybe_impl(await self._impl_obj.dispose(reason=reason))
 
     async def delete(
         self,
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17317,7 +19625,8 @@ async def delete(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.delete
 
@@ -17329,7 +19638,7 @@ async def delete(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17345,9 +19654,7 @@ async def delete(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17358,6 +19665,9 @@ async def delete(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17376,6 +19686,7 @@ async def delete(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17384,10 +19695,10 @@ async def head(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17395,7 +19706,8 @@ async def head(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.head
 
@@ -17407,7 +19719,7 @@ async def head(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17423,9 +19735,7 @@ async def head(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17436,6 +19746,9 @@ async def head(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17454,6 +19767,7 @@ async def head(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17462,10 +19776,10 @@ async def get(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17473,7 +19787,8 @@ async def get(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.get
 
@@ -17497,7 +19812,7 @@ async def get(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17513,9 +19828,7 @@ async def get(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17526,6 +19839,9 @@ async def get(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17544,6 +19860,7 @@ async def get(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17552,10 +19869,10 @@ async def patch(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17563,7 +19880,8 @@ async def patch(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.patch
 
@@ -17575,7 +19893,7 @@ async def patch(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17591,9 +19909,7 @@ async def patch(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17604,6 +19920,9 @@ async def patch(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17622,6 +19941,7 @@ async def patch(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17630,10 +19950,10 @@ async def put(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17641,7 +19961,8 @@ async def put(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.put
 
@@ -17653,7 +19974,7 @@ async def put(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17669,9 +19990,7 @@ async def put(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17682,6 +20001,9 @@ async def put(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17700,6 +20022,7 @@ async def put(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17708,10 +20031,10 @@ async def post(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17719,7 +20042,8 @@ async def post(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.post
 
@@ -17744,11 +20068,11 @@ async def post(
         files):
 
         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. You can achieve that with Playwright API like this:
+        encoding. Use `FormData` to construct request body and pass it to the request as `multipart` parameter:
 
         ```python
         api_request_context.post(
-          \"https://example.com/api/uploadScrip'\",
+          \"https://example.com/api/uploadScript'\",
           multipart={
             \"fileField\": {
               \"name\": \"f.js\",
@@ -17762,7 +20086,7 @@ async def post(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17778,9 +20102,7 @@ async def post(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17791,6 +20113,9 @@ async def post(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17809,6 +20134,7 @@ async def post(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
@@ -17817,11 +20143,11 @@ async def fetch(
         url_or_request: typing.Union[str, "Request"],
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17829,16 +20155,18 @@ async def fetch(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.fetch
 
         Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and
-        update context cookies from the response. The method will automatically follow redirects. JSON objects can be
-        passed directly to the request.
+        update context cookies from the response. The method will automatically follow redirects.
 
         **Usage**
 
+        JSON objects can be passed directly to the request:
+
         ```python
         data = {
             \"title\": \"Book Title\",
@@ -17847,14 +20175,14 @@ async def fetch(
         api_request_context.fetch(\"https://example.com/api/createBook\", method=\"post\", data=data)
         ```
 
-        The common way to send file(s) in the body of a request is to encode it as form fields with `multipart/form-data`
-        encoding. You can achieve that with Playwright API like this:
+        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, by specifiying the `multipart` parameter:
 
         Parameters
         ----------
         url_or_request : Union[Request, str]
             Target URL or Request to get all parameters from.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         method : Union[str, None]
             If set changes the fetch method (e.g. [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) or
@@ -17873,9 +20201,7 @@ async def fetch(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17886,6 +20212,9 @@ async def fetch(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17905,11 +20234,15 @@ async def fetch(
                 failOnStatusCode=fail_on_status_code,
                 ignoreHTTPSErrors=ignore_https_errors,
                 maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
         )
 
     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
 
@@ -17921,19 +20254,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,
         *,
@@ -17946,7 +20284,10 @@ async def new_context(
         timeout: typing.Optional[float] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
-        ] = None
+        ] = 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
 
@@ -17965,7 +20306,7 @@ async def new_context(
               `http://localhost:3000/bar.html`
         extra_http_headers : Union[Dict[str, str], None]
             An object containing additional HTTP headers to be sent with every request. Defaults to none.
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         ignore_https_errors : Union[bool, None]
@@ -17982,6 +20323,30 @@ async def new_context(
             information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
             Either a path to the file with saved storage, or the value returned by one of
             `browser_context.storage_state()` or `a_pi_request_context.storage_state()` methods.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -17998,6 +20363,9 @@ async def new_context(
                 userAgent=user_agent,
                 timeout=timeout,
                 storageState=storage_state,
+                clientCertificates=client_certificates,
+                failOnStatusCode=fail_on_status_code,
+                maxRedirects=max_redirects,
             )
         )
 
@@ -18006,11 +20374,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
 
@@ -18045,7 +20414,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
 
@@ -18070,7 +20439,8 @@ async def to_have_url(
         self,
         url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.to_have_url
 
@@ -18092,12 +20462,15 @@ async def to_have_url(
             Expected URL string or RegExp.
         timeout : Union[float, None]
             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 parameter if specified. A provided predicate ignores this flag.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
             await self._impl_obj.to_have_url(
-                urlOrRegExp=url_or_reg_exp, timeout=timeout
+                urlOrRegExp=url_or_reg_exp, timeout=timeout, ignoreCase=ignore_case
             )
         )
 
@@ -18105,7 +20478,8 @@ async def not_to_have_url(
         self,
         url_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.not_to_have_url
 
@@ -18117,12 +20491,15 @@ async def not_to_have_url(
             Expected URL string or RegExp.
         timeout : Union[float, None]
             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.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
             await self._impl_obj.not_to_have_url(
-                urlOrRegExp=url_or_reg_exp, timeout=timeout
+                urlOrRegExp=url_or_reg_exp, timeout=timeout, ignoreCase=ignore_case
             )
         )
 
@@ -18131,6 +20508,7 @@ async def not_to_have_url(
 
 
 class LocatorAssertions(AsyncBase):
+
     async def to_contain_text(
         self,
         expected: typing.Union[
@@ -18143,7 +20521,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
 
@@ -18188,7 +20566,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\"])
@@ -18235,7 +20613,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
 
@@ -18270,7 +20648,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
 
@@ -18311,7 +20689,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
 
@@ -18347,33 +20725,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\"])
         ```
 
@@ -18402,7 +20782,7 @@ async def not_to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_class
 
@@ -18423,6 +20803,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:
@@ -18477,7 +20943,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
 
@@ -18512,7 +20978,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
 
@@ -18539,7 +21005,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
 
@@ -18571,7 +21037,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
 
@@ -18652,7 +21118,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
 
@@ -18686,7 +21152,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
 
@@ -18713,7 +21179,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
 
@@ -18764,7 +21230,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
 
@@ -18797,7 +21263,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
 
@@ -18888,7 +21354,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
 
@@ -18921,7 +21387,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
 
@@ -18950,7 +21416,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
 
@@ -18970,18 +21437,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
 
@@ -19068,7 +21542,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
 
@@ -19099,7 +21573,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
 
@@ -19162,7 +21636,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
 
@@ -19193,7 +21667,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
 
@@ -19257,7 +21731,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
 
@@ -19298,7 +21772,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
 
@@ -19363,7 +21837,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
 
@@ -19402,7 +21876,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
 
@@ -19420,37 +21894,529 @@ async def not_to_be_in_viewport(
             await self._impl_obj.not_to_be_in_viewport(ratio=ratio, timeout=timeout)
         )
 
+    async def to_have_accessible_description(
+        self,
+        description: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_description
 
-mapping.register(LocatorAssertionsImpl, LocatorAssertions)
+        Ensures the `Locator` points to an element with a given
+        [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
 
+        **Usage**
 
-class APIResponseAssertions(AsyncBase):
-    async def to_be_ok(self) -> None:
-        """APIResponseAssertions.to_be_ok
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_accessible_description(\"Save results to disk\")
+        ```
 
-        Ensures the response status code is within `200..299` range.
+        Parameters
+        ----------
+        description : Union[Pattern[str], str]
+            Expected accessible description.
+        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
 
-        **Usage**
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_description(
+                description=description, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
 
-        ```py
-        from playwright.async_api import expect
+    async def not_to_have_accessible_description(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_description
 
-        # ...
-        await expect(response).to_be_ok()
-        ```
+        The opposite of `locator_assertions.to_have_accessible_description()`.
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible description.
+        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_be_ok())
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_description(
+                name=name, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
 
-    async def not_to_be_ok(self) -> None:
-        """APIResponseAssertions.not_to_be_ok
+    async def to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_name
 
-        The opposite of `a_pi_response_assertions.to_be_ok()`.
+        Ensures the `Locator` points to an element with a given
+        [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_accessible_name(\"Save to disk\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        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_be_ok())
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_name(
+                name=name, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
 
+    async def not_to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_name
 
-mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
+        The opposite of `locator_assertions.to_have_accessible_name()`.
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        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_name(
+                name=name, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
+
+    async def to_have_role(
+        self,
+        role: Literal[
+            "alert",
+            "alertdialog",
+            "application",
+            "article",
+            "banner",
+            "blockquote",
+            "button",
+            "caption",
+            "cell",
+            "checkbox",
+            "code",
+            "columnheader",
+            "combobox",
+            "complementary",
+            "contentinfo",
+            "definition",
+            "deletion",
+            "dialog",
+            "directory",
+            "document",
+            "emphasis",
+            "feed",
+            "figure",
+            "form",
+            "generic",
+            "grid",
+            "gridcell",
+            "group",
+            "heading",
+            "img",
+            "insertion",
+            "link",
+            "list",
+            "listbox",
+            "listitem",
+            "log",
+            "main",
+            "marquee",
+            "math",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "navigation",
+            "none",
+            "note",
+            "option",
+            "paragraph",
+            "presentation",
+            "progressbar",
+            "radio",
+            "radiogroup",
+            "region",
+            "row",
+            "rowgroup",
+            "rowheader",
+            "scrollbar",
+            "search",
+            "searchbox",
+            "separator",
+            "slider",
+            "spinbutton",
+            "status",
+            "strong",
+            "subscript",
+            "superscript",
+            "switch",
+            "tab",
+            "table",
+            "tablist",
+            "tabpanel",
+            "term",
+            "textbox",
+            "time",
+            "timer",
+            "toolbar",
+            "tooltip",
+            "tree",
+            "treegrid",
+            "treeitem",
+        ],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_role
+
+        Ensures the `Locator` points to an element with a given [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles).
+
+        Note that role is matched as a string, disregarding the ARIA role hierarchy. For example, asserting  a superclass
+        role `\"checkbox\"` on an element with a subclass role `\"switch\"` will fail.
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_role(\"button\")
+        ```
+
+        Parameters
+        ----------
+        role : Union["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"]
+            Required aria role.
+        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_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[
+            "alert",
+            "alertdialog",
+            "application",
+            "article",
+            "banner",
+            "blockquote",
+            "button",
+            "caption",
+            "cell",
+            "checkbox",
+            "code",
+            "columnheader",
+            "combobox",
+            "complementary",
+            "contentinfo",
+            "definition",
+            "deletion",
+            "dialog",
+            "directory",
+            "document",
+            "emphasis",
+            "feed",
+            "figure",
+            "form",
+            "generic",
+            "grid",
+            "gridcell",
+            "group",
+            "heading",
+            "img",
+            "insertion",
+            "link",
+            "list",
+            "listbox",
+            "listitem",
+            "log",
+            "main",
+            "marquee",
+            "math",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "navigation",
+            "none",
+            "note",
+            "option",
+            "paragraph",
+            "presentation",
+            "progressbar",
+            "radio",
+            "radiogroup",
+            "region",
+            "row",
+            "rowgroup",
+            "rowheader",
+            "scrollbar",
+            "search",
+            "searchbox",
+            "separator",
+            "slider",
+            "spinbutton",
+            "status",
+            "strong",
+            "subscript",
+            "superscript",
+            "switch",
+            "tab",
+            "table",
+            "tablist",
+            "tabpanel",
+            "term",
+            "textbox",
+            "time",
+            "timer",
+            "toolbar",
+            "tooltip",
+            "tree",
+            "treegrid",
+            "treeitem",
+        ],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_role
+
+        The opposite of `locator_assertions.to_have_role()`.
+
+        Parameters
+        ----------
+        role : Union["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"]
+            Required aria role.
+        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_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
+
+        Ensures the response status code is within `200..299` range.
+
+        **Usage**
+
+        ```py
+        from playwright.async_api import expect
+
+        # ...
+        await expect(response).to_be_ok()
+        ```
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(await self._impl_obj.to_be_ok())
+
+    async def not_to_be_ok(self) -> None:
+        """APIResponseAssertions.not_to_be_ok
+
+        The opposite of `a_pi_response_assertions.to_be_ok()`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(await self._impl_obj.not_to_be_ok())
+
+
+mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
+
+
+class Disposable(AsyncContextManager):
+
+    async def dispose(self) -> None:
+        """Disposable.dispose
+
+        Removes the associated resource. For example, removes the init script installed via `page.add_init_script()`
+        or `browser_context.add_init_script()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.dispose())
+
+    async def close(self) -> None:
+
+        return mapping.from_maybe_impl(await self._impl_obj.close())
+
+
+mapping.register(DisposableImpl, Disposable)
diff --git a/playwright/sync_api/__init__.py b/playwright/sync_api/__init__.py
index e17c0e305..6015bc1be 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,
 )
 
@@ -71,12 +72,17 @@
 FloatRect = playwright._impl._api_structures.FloatRect
 Geolocation = playwright._impl._api_structures.Geolocation
 HttpCredentials = playwright._impl._api_structures.HttpCredentials
+BrowserBindResult = playwright._impl._api_structures.BrowserBindResult
+DebuggerLocation = playwright._impl._api_structures.DebuggerLocation
+DebuggerPausedDetails = playwright._impl._api_structures.DebuggerPausedDetails
 PdfMargins = playwright._impl._api_structures.PdfMargins
 Position = playwright._impl._api_structures.Position
 ProxySettings = playwright._impl._api_structures.ProxySettings
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
+ScreencastFrame = playwright._impl._api_structures.ScreencastFrame
 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 +113,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,11 +152,11 @@ def __call__(
 
 __all__ = [
     "expect",
-    "Accessibility",
     "APIRequest",
     "APIRequestContext",
     "APIResponse",
     "Browser",
+    "BrowserBindResult",
     "BrowserContext",
     "BrowserType",
     "CDPSession",
@@ -173,6 +178,8 @@ def __call__(
     "Keyboard",
     "Locator",
     "Mouse",
+    "DebuggerLocation",
+    "DebuggerPausedDetails",
     "Page",
     "PdfMargins",
     "Position",
@@ -182,14 +189,18 @@ def __call__(
     "ResourceTiming",
     "Response",
     "Route",
+    "ScreencastFrame",
     "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 6c1fe5fbb..13139abec 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -13,13 +13,17 @@
 # limitations under the License.
 
 
+import datetime
 import pathlib
 import typing
 from typing import Literal
 
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
 from playwright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
     Cookie,
+    DebuggerLocation,
+    DebuggerPausedDetails,
     FilePayload,
     FloatRect,
     Geolocation,
@@ -31,10 +35,12 @@
     RemoteAddr,
     RequestSizes,
     ResourceTiming,
+    ScreencastFrame,
     SecurityDetails,
     SetCookieParam,
     SourceLocation,
     StorageState,
+    TracingGroupLocation,
     ViewportSize,
 )
 from playwright._impl._assertions import (
@@ -46,8 +52,11 @@
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
 from playwright._impl._errors import Error
@@ -66,9 +75,11 @@
 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
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
 from playwright._impl._sync_base import (
     EventContextManager,
@@ -82,6 +93,7 @@
 
 
 class Request(SyncBase):
+
     @property
     def url(self) -> str:
         """Request.url
@@ -108,6 +120,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
@@ -159,6 +189,21 @@ def post_data_buffer(self) -> typing.Optional[bytes]:
         """
         return mapping.from_maybe_impl(self._impl_obj.post_data_buffer)
 
+    @property
+    def existing_response(self) -> typing.Optional["Response"]:
+        """Request.existing_response
+
+        Returns the `Response` object if the response has already been received, `null` otherwise.
+
+        Unlike `request.response()`, this method does not wait for the response to arrive. It returns immediately
+        with the response object if the response has been received, or `null` if the response has not been received yet.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.existing_response)
+
     @property
     def frame(self) -> "Frame":
         """Request.frame
@@ -363,7 +408,7 @@ def headers_array(self) -> typing.List[NameValue]:
     def header_value(self, name: str) -> typing.Optional[str]:
         """Request.header_value
 
-        Returns the value of the header matching the name. The name is case insensitive.
+        Returns the value of the header matching the name. The name is case-insensitive.
 
         Parameters
         ----------
@@ -384,6 +429,7 @@ def header_value(self, name: str) -> typing.Optional[str]:
 
 
 class Response(SyncBase):
+
     @property
     def url(self) -> str:
         """Response.url
@@ -512,7 +558,7 @@ def headers_array(self) -> typing.List[NameValue]:
     def header_value(self, name: str) -> typing.Optional[str]:
         """Response.header_value
 
-        Returns the value of the header matching the name. The name is case insensitive. If multiple headers have the same
+        Returns the value of the header matching the name. The name is case-insensitive. If multiple headers have the same
         name (except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\\n` separator is
         used. If no headers are found, `null` is returned.
 
@@ -533,7 +579,7 @@ def header_value(self, name: str) -> typing.Optional[str]:
     def header_values(self, name: str) -> typing.List[str]:
         """Response.header_values
 
-        Returns all values of the headers matching the name, for example `set-cookie`. The name is case insensitive.
+        Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.
 
         Parameters
         ----------
@@ -573,6 +619,18 @@ def security_details(self) -> typing.Optional[SecurityDetails]:
 
         return mapping.from_impl_nullable(self._sync(self._impl_obj.security_details()))
 
+    def http_version(self) -> str:
+        """Response.http_version
+
+        Returns the http version used by the response.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.http_version()))
+
     def finished(self) -> None:
         """Response.finished
 
@@ -624,6 +682,7 @@ def json(self) -> typing.Any:
 
 
 class Route(SyncBase):
+
     @property
     def request(self) -> "Request":
         """Route.request
@@ -674,9 +733,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
 
@@ -741,7 +800,8 @@ def fetch(
         headers: typing.Optional[typing.Dict[str, str]] = None,
         post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
         max_redirects: typing.Optional[int] = None,
-        timeout: typing.Optional[float] = None
+        max_retries: typing.Optional[int] = None,
+        timeout: typing.Optional[float] = None,
     ) -> "APIResponse":
         """Route.fetch
 
@@ -781,6 +841,9 @@ def handle(route):
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
@@ -797,6 +860,7 @@ def handle(route):
                     headers=mapping.to_impl(headers),
                     postData=mapping.to_impl(post_data),
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                     timeout=timeout,
                 )
             )
@@ -808,17 +872,20 @@ 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
 
+        Continues route's request with optional overrides. The method is similar to `route.continue_()` with the
+        difference that other matching handlers will be invoked before sending the request.
+
+        **Usage**
+
         When several routes match the given pattern, they run in the order opposite to their registration. That way the
         last registered route can always override all the previous ones. In the example below, request will be handled by
         the bottom-most handler first, then it'll fall back to the previous one and in the end will be aborted by the first
         registered route.
 
-        **Usage**
-
         ```py
         page.route(\"**/*\", lambda route: route.abort())  # Runs last.
         page.route(\"**/*\", lambda route: route.fallback())  # Runs second.
@@ -865,6 +932,9 @@ def handle(route, request):
         page.route(\"**/*\", handle)
         ```
 
+        Use `route.continue_()` to immediately send the request to the network, other matching handlers won't be
+        invoked in that case.
+
         Parameters
         ----------
         url : Union[str, None]
@@ -895,11 +965,11 @@ 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_
 
-        Continues route's request with optional overrides.
+        Sends route's request to the network with optional overrides.
 
         **Usage**
 
@@ -918,9 +988,18 @@ 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
         ----------
@@ -950,6 +1029,7 @@ def handle(route, request):
 
 
 class WebSocket(SyncBase):
+
     @typing.overload
     def on(
         self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]
@@ -1032,12 +1112,61 @@ def url(self) -> str:
         """
         return mapping.from_maybe_impl(self._impl_obj.url)
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["str"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
     def expect_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """WebSocket.expect_event
 
@@ -1065,12 +1194,61 @@ def expect_event(
             ).future,
         )
 
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "str": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
     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:
         """WebSocket.wait_for_event
 
@@ -1121,7 +1299,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
 
@@ -1136,7 +1442,8 @@ def down(self, key: str) -> None:
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -1244,7 +1551,8 @@ def press(self, key: str, *, delay: typing.Optional[float] = None) -> None:
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -1287,6 +1595,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
 
@@ -1295,9 +1604,12 @@ def move(self, x: float, y: float, *, steps: typing.Optional[int] = None) -> Non
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         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(
@@ -1308,7 +1620,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
 
@@ -1330,7 +1642,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
 
@@ -1355,7 +1667,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
 
@@ -1364,7 +1676,9 @@ def click(
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
         button : Union["left", "middle", "right", None]
@@ -1387,7 +1701,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
 
@@ -1397,7 +1711,9 @@ def dblclick(
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
         button : Union["left", "middle", "right", None]
@@ -1411,7 +1727,8 @@ def dblclick(
     def wheel(self, delta_x: float, delta_y: float) -> None:
         """Mouse.wheel
 
-        Dispatches a `wheel` event.
+        Dispatches a `wheel` event. This method is usually used to manually scroll the page. See
+        [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
 
         **NOTE** Wheel events may cause scrolling if they are not handled, and this method does not wait for the scrolling
         to finish before returning.
@@ -1433,6 +1750,7 @@ def wheel(self, delta_x: float, delta_y: float) -> None:
 
 
 class Touchscreen(SyncBase):
+
     def tap(self, x: float, y: float) -> None:
         """Touchscreen.tap
 
@@ -1443,7 +1761,9 @@ def tap(self, x: float, y: float) -> None:
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         """
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.tap(x=x, y=y)))
@@ -1453,6 +1773,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:
@@ -1610,6 +1931,7 @@ def json_value(self) -> typing.Any:
 
 
 class ElementHandle(JSHandle):
+
     def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
@@ -1839,6 +2161,8 @@ def scroll_into_view_if_needed(
         Throws when `elementHandle` does not point to an element
         [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
 
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
+
         Parameters
         ----------
         timeout : Union[float, None]
@@ -1854,13 +2178,13 @@ def hover(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -1868,7 +2192,6 @@ def hover(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -1877,9 +2200,10 @@ def hover(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -1887,9 +2211,8 @@ def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         trial : Union[bool, None]
@@ -1914,7 +2237,7 @@ def click(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -1923,7 +2246,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
 
@@ -1940,9 +2264,10 @@ def click(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -1961,9 +2286,13 @@ def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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.
+        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(
@@ -1978,6 +2307,7 @@ def click(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -1986,7 +2316,7 @@ def dblclick(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -1994,7 +2324,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
 
@@ -2002,8 +2333,6 @@ def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -2014,9 +2343,10 @@ def dblclick(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -2030,12 +2360,14 @@ def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
+        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(
@@ -2049,6 +2381,7 @@ def dblclick(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -2064,7 +2397,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
 
@@ -2109,9 +2442,8 @@ def select_option(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
 
         Returns
         -------
@@ -2136,13 +2468,13 @@ def tap(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -2150,7 +2482,6 @@ def tap(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -2161,9 +2492,10 @@ def tap(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -2173,9 +2505,8 @@ def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2200,7 +2531,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
 
@@ -2222,9 +2553,8 @@ def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -2241,7 +2571,7 @@ def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """ElementHandle.select_text
 
@@ -2300,12 +2630,13 @@ 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
 
         Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then
-        they are resolved relative to the current working directory. For empty array, clears the selected files.
+        they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs
+        with a `[webkitdirectory]` attribute, only a single directory path is supported.
 
         This method expects `ElementHandle` to point to an
         [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside
@@ -2319,9 +2650,8 @@ def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -2348,7 +2678,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
 
@@ -2369,9 +2699,8 @@ def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -2388,7 +2717,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
 
@@ -2403,7 +2732,8 @@ def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -2426,6 +2756,7 @@ def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -2444,7 +2775,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
 
@@ -2455,7 +2786,6 @@ def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -2474,9 +2804,8 @@ def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2502,7 +2831,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
 
@@ -2512,7 +2841,6 @@ def check(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -2531,9 +2859,8 @@ def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2558,7 +2885,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
 
@@ -2568,7 +2895,6 @@ def uncheck(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -2587,9 +2913,8 @@ def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -2642,7 +2967,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,
@@ -2650,7 +2975,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
 
@@ -2697,7 +3022,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`.
@@ -2869,7 +3196,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
 
@@ -2911,7 +3238,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
 
@@ -2970,79 +3297,13 @@ 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`.
+class FileChooser(SyncBase):
 
-        **Usage**
+    @property
+    def page(self) -> "Page":
+        """FileChooser.page
 
-        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
-
-        Returns page this file chooser belongs to.
+        Returns page this file chooser belongs to.
 
         Returns
         -------
@@ -3085,7 +3346,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
 
@@ -3099,9 +3360,8 @@ def set_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -3119,6 +3379,7 @@ def set_files(
 
 
 class Frame(SyncBase):
+
     @property
     def page(self) -> "Page":
         """Frame.page
@@ -3190,7 +3451,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
 
@@ -3257,7 +3518,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
 
@@ -3282,7 +3543,7 @@ def expect_navigation(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str, None]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -3317,7 +3578,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
 
@@ -3333,7 +3594,7 @@ def wait_for_url(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -3365,7 +3626,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
 
@@ -3375,6 +3636,9 @@ def wait_for_load_state(
         committed when this method is called. If current document has already reached the required state, resolves
         immediately.
 
+        **NOTE** Most of the time, this method is not needed because Playwright
+        [auto-waits before every action](https://playwright.dev/python/docs/actionability).
+
         **Usage**
 
         ```py
@@ -3600,7 +3864,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
 
@@ -3672,7 +3936,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
 
@@ -3708,7 +3972,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
 
@@ -3744,7 +4008,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
 
@@ -3780,7 +4044,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
 
@@ -3811,13 +4075,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
@@ -3831,8 +4089,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
         -------
@@ -3840,19 +4096,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
 
@@ -3867,8 +4115,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
         -------
@@ -3876,11 +4122,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(
@@ -3890,7 +4132,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
 
@@ -3962,7 +4204,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
 
@@ -4072,7 +4314,7 @@ def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Frame.set_content
 
@@ -4122,9 +4364,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
 
@@ -4142,7 +4384,7 @@ def add_script_tag(
         content : Union[str, None]
             Raw JavaScript content to be injected into frame.
         type : Union[str, None]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See
+            Script type. Use 'module' in order to load a JavaScript ES6 module. See
             [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.
 
         Returns
@@ -4162,8 +4404,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
 
@@ -4198,7 +4440,7 @@ def click(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -4208,7 +4450,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
 
@@ -4228,9 +4470,10 @@ def click(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4249,12 +4492,15 @@ def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         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.
         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(
@@ -4280,7 +4526,7 @@ def dblclick(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -4289,7 +4535,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
 
@@ -4298,8 +4544,7 @@ def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `force` option is set. If
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
-        1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
+        1. Use `page.mouse` to double click in the center of the element, or the specified `position`. if
            the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -4312,9 +4557,10 @@ def dblclick(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4328,15 +4574,16 @@ def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -4361,14 +4608,14 @@ def tap(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -4378,7 +4625,6 @@ def tap(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -4390,9 +4636,10 @@ def tap(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -4402,15 +4649,16 @@ def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -4436,7 +4684,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
 
@@ -4462,9 +4710,8 @@ def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -4489,10 +4736,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
 
@@ -4550,7 +4797,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
 
@@ -4587,7 +4834,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
 
@@ -4628,7 +4875,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
 
@@ -4757,10 +5004,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
 
@@ -4781,7 +5028,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -4814,6 +5061,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`.
 
@@ -4880,7 +5128,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         page.get_by_test_id(\"directions\").click()
@@ -4907,7 +5155,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
 
@@ -4971,7 +5219,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
 
@@ -5039,7 +5287,7 @@ def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Frame.focus
 
@@ -5070,7 +5318,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
 
@@ -5106,7 +5354,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
 
@@ -5142,7 +5390,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
 
@@ -5179,7 +5427,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
 
@@ -5217,14 +5465,14 @@ def hover(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -5234,7 +5482,6 @@ def hover(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -5244,9 +5491,10 @@ def hover(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -5254,9 +5502,8 @@ def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -5264,7 +5511,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(
@@ -5293,7 +5542,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
 
@@ -5314,9 +5564,8 @@ def drag_and_drop(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5326,6 +5575,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(
@@ -5340,6 +5592,7 @@ def drag_and_drop(
                     strict=strict,
                     timeout=timeout,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -5357,7 +5610,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
 
@@ -5402,9 +5655,8 @@ def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5437,7 +5689,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
 
@@ -5485,7 +5737,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
 
@@ -5510,9 +5762,8 @@ def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -5535,7 +5786,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
 
@@ -5562,9 +5813,8 @@ def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -5588,7 +5838,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
 
@@ -5601,7 +5851,8 @@ def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -5630,6 +5881,7 @@ def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -5654,7 +5906,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
 
@@ -5666,7 +5918,6 @@ def check(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5686,9 +5937,8 @@ def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5720,7 +5970,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
 
@@ -5732,7 +5982,6 @@ def uncheck(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5752,9 +6001,8 @@ def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5801,7 +6049,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
 
@@ -5887,7 +6135,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
 
@@ -5899,7 +6147,6 @@ def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -5921,9 +6168,8 @@ def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -5952,6 +6198,7 @@ def set_checked(
 
 
 class FrameLocator(SyncBase):
+
     @property
     def first(self) -> "FrameLocator":
         """FrameLocator.first
@@ -5990,7 +6237,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()
@@ -6006,10 +6253,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
 
@@ -6064,7 +6311,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
 
@@ -6101,7 +6348,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
 
@@ -6142,7 +6389,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
 
@@ -6271,10 +6518,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
 
@@ -6295,7 +6542,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -6328,6 +6575,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`.
 
@@ -6394,7 +6642,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         page.get_by_test_id(\"directions\").click()
@@ -6421,7 +6669,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
 
@@ -6485,7 +6733,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
 
@@ -6559,20 +6807,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
@@ -6652,18 +6923,87 @@ def evaluate_handle(
             )
         )
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager:
+        """Worker.expect_event
+
+        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**
+
+        ```py
+        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[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
 
@@ -6751,46 +7091,244 @@ def set_test_id_attribute(self, attribute_name: str) -> None:
 mapping.register(SelectorsImpl, Selectors)
 
 
-class ConsoleMessage(SyncBase):
-    @property
-    def type(self) -> str:
-        """ConsoleMessage.type
+class Clock(SyncBase):
+
+    def install(
+        self,
+        *,
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
+    ) -> None:
+        """Clock.install
 
-        One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-        `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`,
-        `'profileEnd'`, `'count'`, `'timeEnd'`.
+        Install fake implementations for the following time-related functions:
+        - `Date`
+        - `setTimeout`
+        - `clearTimeout`
+        - `setInterval`
+        - `clearInterval`
+        - `requestAnimationFrame`
+        - `cancelAnimationFrame`
+        - `requestIdleCallback`
+        - `cancelIdleCallback`
+        - `performance`
 
-        Returns
-        -------
-        str
+        Fake timers are used to manually control the flow of time in tests. They allow you to advance time, fire timers,
+        and control the behavior of time-dependent functions. See `clock.run_for()` and
+        `clock.fast_forward()` for more information.
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str, None]
+            Time to initialize with, current system time by default.
         """
-        return mapping.from_maybe_impl(self._impl_obj.type)
 
-    @property
-    def text(self) -> str:
-        """ConsoleMessage.text
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.install(time=time)))
 
-        The text of the console message.
+    def fast_forward(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.fast_forward
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.text)
+        Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user
+        closing the laptop lid for a while and reopening it later, after given time.
 
-    @property
-    def args(self) -> typing.List["JSHandle"]:
-        """ConsoleMessage.args
+        **Usage**
 
-        List of arguments passed to a `console` function call. See also `page.on('console')`.
+        ```py
+        page.clock.fast_forward(1000)
+        page.clock.fast_forward(\"30:00\")
+        ```
 
-        Returns
-        -------
-        List[JSHandle]
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are
+            "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.
         """
-        return mapping.from_impl_list(self._impl_obj.args)
 
-    @property
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.fast_forward(ticks=ticks))
+        )
+
+    def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.pause_at
+
+        Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers are fired
+        unless `clock.run_for()`, `clock.fast_forward()`, `clock.pause_at()` or
+        `clock.resume()` is called.
+
+        Only fires due timers at most once. This is equivalent to user closing the laptop lid for a while and reopening it
+        at the specified time and pausing.
+
+        **Usage**
+
+        ```py
+        page.clock.pause_at(datetime.datetime(2020, 2, 2))
+        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]
+            Time to pause at.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.pause_at(time=time)))
+
+    def resume(self) -> None:
+        """Clock.resume
+
+        Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.resume()))
+
+    def run_for(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.run_for
+
+        Advance the clock, firing all the time-related callbacks.
+
+        **Usage**
+
+        ```py
+        page.clock.run_for(1000);
+        page.clock.run_for(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            Time may be the number of milliseconds to advance the clock by or a human-readable string. Valid string formats are
+            "08" for eight seconds, "01:00" for one minute and "02:34:10" for two hours, 34 minutes and ten seconds.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.run_for(ticks=ticks)))
+
+    def set_fixed_time(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.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
+        page.clock.set_fixed_time(datetime.datetime.now())
+        page.clock.set_fixed_time(datetime.datetime(2020, 2, 2))
+        page.clock.set_fixed_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_fixed_time(time=time))
+        )
+
+    def set_system_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.set_system_time
+
+        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**
+
+        ```py
+        page.clock.set_system_time(datetime.datetime.now())
+        page.clock.set_system_time(datetime.datetime(2020, 2, 2))
+        page.clock.set_system_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_system_time(time=time))
+        )
+
+
+mapping.register(ClockImpl, Clock)
+
+
+class ConsoleMessage(SyncBase):
+
+    @property
+    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
+
+        Returns
+        -------
+        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)
+
+    @property
+    def text(self) -> str:
+        """ConsoleMessage.text
+
+        The text of the console message.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.text)
+
+    @property
+    def args(self) -> typing.List["JSHandle"]:
+        """ConsoleMessage.args
+
+        List of arguments passed to a `console` function call. See also `page.on('console')`.
+
+        Returns
+        -------
+        List[JSHandle]
+        """
+        return mapping.from_impl_list(self._impl_obj.args)
+
+    @property
     def location(self) -> SourceLocation:
         """ConsoleMessage.location
 
@@ -6800,6 +7338,18 @@ def location(self) -> SourceLocation:
         """
         return mapping.from_impl(self._impl_obj.location)
 
+    @property
+    def timestamp(self) -> float:
+        """ConsoleMessage.timestamp
+
+        The timestamp of the console message in milliseconds since the Unix epoch.
+
+        Returns
+        -------
+        float
+        """
+        return mapping.from_maybe_impl(self._impl_obj.timestamp)
+
     @property
     def page(self) -> typing.Optional["Page"]:
         """ConsoleMessage.page
@@ -6812,11 +7362,116 @@ 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 Debugger(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["pausedstatechanged"], f: typing.Callable[["None"], "None"]
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def on(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["pausedstatechanged"], f: typing.Callable[["None"], "None"]
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def once(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def paused_details(self) -> typing.Optional[DebuggerPausedDetails]:
+        """Debugger.paused_details
+
+        Returns details about the currently paused call. Returns `null` if the debugger is not paused.
+
+        Returns
+        -------
+        Union[{location: {file: str, line: Union[int, None], column: Union[int, None]}, title: str}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.paused_details)
+
+    def request_pause(self) -> None:
+        """Debugger.request_pause
+
+        Configures the debugger to pause before the next action is executed.
+
+        Throws if the debugger is already paused. Use `debugger.next()` or `debugger.run_to()` to step while
+        paused.
+
+        Note that `page.pause()` is equivalent to a \"debugger\" statement — it pauses execution at the call site
+        immediately. On the contrary, `debugger.request_pause()` is equivalent to \"pause on next statement\" — it
+        configures the debugger to pause before the next action is executed.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.request_pause()))
+
+    def resume(self) -> None:
+        """Debugger.resume
+
+        Resumes script execution. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.resume()))
+
+    def next(self) -> None:
+        """Debugger.next
+
+        Resumes script execution and pauses again before the next action. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.next()))
+
+    def run_to(self, location: DebuggerLocation) -> None:
+        """Debugger.run_to
+
+        Resumes script execution and pauses when an action originates from the given source location. Throws if the
+        debugger is not paused.
+
+        Parameters
+        ----------
+        location : {file: str, line: Union[int, None], column: Union[int, None]}
+            The source location to pause at.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.run_to(location=location))
+        )
+
+
+mapping.register(DebuggerImpl, Debugger)
+
+
 class Dialog(SyncBase):
+
     @property
     def type(self) -> str:
         """Dialog.type
@@ -6893,6 +7548,7 @@ def dismiss(self) -> None:
 
 
 class Download(SyncBase):
+
     @property
     def page(self) -> "Page":
         """Download.page
@@ -7001,62 +7657,233 @@ def cancel(self) -> None:
 mapping.register(DownloadImpl, Download)
 
 
-class Video(SyncBase):
-    def path(self) -> pathlib.Path:
-        """Video.path
+class Screencast(SyncBase):
 
-        Returns the file system path this video will be recorded to. The video is guaranteed to be written to the
-        filesystem upon closing the browser context. This method throws when connected remotely.
+    def start(
+        self,
+        *,
+        on_frame: typing.Optional[
+            typing.Callable[[ScreencastFrame], typing.Any]
+        ] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """Screencast.start
+
+        Starts the screencast. When `path` is provided, it saves video recording to the specified file. When `onFrame` is
+        provided, delivers JPEG-encoded frames to the callback. Both can be used together.
+
+        **Usage**
+
+        Parameters
+        ----------
+        on_frame : Union[Callable[[{data: bytes}], Any], None]
+            Callback that receives JPEG-encoded frame data.
+        path : Union[pathlib.Path, str, None]
+            Path where the video should be saved when the screencast is stopped. When provided, video recording is started.
+        quality : Union[int, None]
+            The quality of the image, between 0-100.
 
         Returns
         -------
-        pathlib.Path
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.start(
+                    onFrame=self._wrap_handler(on_frame), path=path, quality=quality
+                )
+            )
+        )
 
-    def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
-        """Video.save_as
+    def stop(self) -> None:
+        """Screencast.stop
 
-        Saves the video to a user-specified path. It is safe to call this method while the video is still in progress, or
-        after the page has closed. This method waits until the page is closed and the video is fully saved.
+        Stops the screencast and video recording if active. If a video was being recorded, saves it to the path specified
+        in `screencast.start()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop()))
+
+    def show_actions(
+        self,
+        *,
+        duration: typing.Optional[float] = None,
+        position: typing.Optional[
+            Literal[
+                "bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right"
+            ]
+        ] = None,
+        font_size: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """Screencast.show_actions
+
+        Enables visual annotations on interacted elements. Returns a disposable that stops showing actions when disposed.
 
         Parameters
         ----------
-        path : Union[pathlib.Path, str]
-            Path where the video should be saved.
+        duration : Union[float, None]
+            How long each annotation is displayed in milliseconds. Defaults to `500`.
+        position : Union["bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right", None]
+            Position of the action title overlay. Defaults to `"top-right"`.
+        font_size : Union[int, None]
+            Font size of the action title in pixels. Defaults to `24`.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.save_as(path=path)))
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.show_actions(
+                    duration=duration, position=position, fontSize=font_size
+                )
+            )
+        )
 
-    def delete(self) -> None:
-        """Video.delete
+    def hide_actions(self) -> None:
+        """Screencast.hide_actions
 
-        Deletes the video file. Will wait for the video to finish if necessary.
+        Removes action decorations.
         """
 
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_actions()))
 
+    def show_overlay(
+        self, html: str, *, duration: typing.Optional[float] = None
+    ) -> "SyncContextManager":
+        """Screencast.show_overlay
 
-mapping.register(VideoImpl, Video)
+        Adds an overlay with the given HTML content. The overlay is displayed on top of the page until removed. Returns a
+        disposable that removes the overlay when disposed.
 
+        Parameters
+        ----------
+        html : str
+            HTML content for the overlay.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Overlay stays until dismissed if not
+            provided.
 
-class Page(SyncContextManager):
-    @typing.overload
-    def on(self, event: Literal["close"], f: typing.Callable[["Page"], "None"]) -> None:
+        Returns
+        -------
+        SyncContextManager
         """
-        Emitted when the page closes."""
 
-    @typing.overload
-    def on(
-        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+        return mapping.from_impl(
+            self._sync(self._impl_obj.show_overlay(html=html, duration=duration))
+        )
+
+    def show_chapter(
+        self,
+        title: str,
+        *,
+        description: typing.Optional[str] = None,
+        duration: typing.Optional[float] = None,
     ) -> None:
-        """
-        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """Screencast.show_chapter
 
-        The arguments passed into `console.log` are available on the `ConsoleMessage` event handler argument.
+        Shows a chapter overlay with a title and optional description, centered on the page with a blurred backdrop. Useful
+        for narrating video recordings. The overlay is removed after the specified duration, or 2000ms.
 
-        **Usage**
+        Parameters
+        ----------
+        title : str
+            Title text displayed prominently in the overlay.
+        description : Union[str, None]
+            Optional description text displayed below the title.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Defaults to `2000`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.show_chapter(
+                    title=title, description=description, duration=duration
+                )
+            )
+        )
+
+    def show_overlays(self) -> None:
+        """Screencast.show_overlays
+
+        Shows overlays.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.show_overlays()))
+
+    def hide_overlays(self) -> None:
+        """Screencast.hide_overlays
+
+        Hides overlays without removing them.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_overlays()))
+
+
+mapping.register(ScreencastImpl, Screencast)
+
+
+class Video(SyncBase):
+
+    def path(self) -> pathlib.Path:
+        """Video.path
+
+        Returns the file system path this video will be recorded to. The video is guaranteed to be written to the
+        filesystem upon closing the browser context. This method throws when connected remotely.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+
+    def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Video.save_as
+
+        Saves the video to a user-specified path. It is safe to call this method while the video is still in progress, or
+        after the page has closed. This method waits until the page is closed and the video is fully saved.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the video should be saved.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.save_as(path=path)))
+
+    def delete(self) -> None:
+        """Video.delete
+
+        Deletes the video file. Will wait for the video to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+
+
+mapping.register(VideoImpl, Video)
+
+
+class Page(SyncContextManager):
+
+    @typing.overload
+    def on(self, event: Literal["close"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
+
+        The arguments passed into `console.log` are available on the `ConsoleMessage` event handler argument.
+
+        **Usage**
 
         ```py
         def print_args(msg):
@@ -7184,7 +8011,9 @@ def on(self, event: Literal["popup"], f: typing.Callable[["Page"], "None"]) -> N
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         with page.expect_event(\"popup\") as page_info:
@@ -7404,7 +8233,9 @@ def once(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         with page.expect_event(\"popup\") as page_info:
@@ -7474,16 +8305,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
@@ -7526,6 +8347,18 @@ def context(self) -> "BrowserContext":
         """
         return mapping.from_impl(self._impl_obj.context)
 
+    @property
+    def clock(self) -> "Clock":
+        """Page.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
     @property
     def main_frame(self) -> "Frame":
         """Page.main_frame
@@ -7603,7 +8436,8 @@ def request(self) -> "APIRequestContext":
     def video(self) -> typing.Optional["Video"]:
         """Page.video
 
-        Video object associated with this page.
+        Video object associated with this page. Can be used to access the video file when using the `recordVideo` context
+        option.
 
         Returns
         -------
@@ -7611,6 +8445,20 @@ def video(self) -> typing.Optional["Video"]:
         """
         return mapping.from_impl_nullable(self._impl_obj.video)
 
+    @property
+    def screencast(self) -> "Screencast":
+        """Page.screencast
+
+        `Screencast` object associated with this page.
+
+        **Usage**
+
+        Returns
+        -------
+        Screencast
+        """
+        return mapping.from_impl(self._impl_obj.screencast)
+
     def opener(self) -> typing.Optional["Page"]:
         """Page.opener
 
@@ -7629,7 +8477,7 @@ def frame(
         *,
         url: typing.Optional[
             typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Frame"]:
         """Page.frame
 
@@ -7692,7 +8540,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(
@@ -7752,7 +8600,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
 
@@ -7824,7 +8672,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
 
@@ -7860,7 +8708,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
 
@@ -7896,7 +8744,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
 
@@ -7932,7 +8780,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
 
@@ -7968,7 +8816,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
 
@@ -8004,7 +8852,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
 
@@ -8042,7 +8890,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
 
@@ -8228,7 +9076,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
 
@@ -8319,9 +9167,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
 
@@ -8338,7 +9186,7 @@ def add_script_tag(
         content : Union[str, None]
             Raw JavaScript content to be injected into frame.
         type : Union[str, None]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See
+            Script type. Use 'module' in order to load a JavaScript ES6 module. See
             [script](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script) for more details.
 
         Returns
@@ -8358,8 +9206,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
 
@@ -8387,7 +9235,9 @@ def add_style_tag(
             )
         )
 
-    def expose_function(self, name: str, callback: typing.Callable) -> None:
+    def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
         """Page.expose_function
 
         The method adds a function called `name` on the `window` object of every frame in the page. When called, the
@@ -8438,9 +9288,13 @@ def run(playwright: Playwright):
             Name of the function on the window object
         callback : Callable
             Callback function which will be called in Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.expose_function(
                     name=name, callback=self._wrap_handler(callback)
@@ -8453,8 +9307,8 @@ def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
-    ) -> None:
+        handle: typing.Optional[bool] = None,
+    ) -> "SyncContextManager":
         """Page.expose_binding
 
         The method adds a function called `name` on the `window` object of every frame in this page. When called, the
@@ -8496,22 +9350,6 @@ def run(playwright: Playwright):
             run(playwright)
         ```
 
-        An example of passing an element handle:
-
-        ```py
-        def print(source, element):
-            print(element.text_content())
-
-        page.expose_binding(\"clicked\", print, handle=true)
-        page.set_content(\"\"\"
-          <script>
-            document.addEventListener('click', event => window.clicked(event.target));
-          </script>
-          <div>Click me</div>
-          <div>Or click me</div>
-        \"\"\")
-        ```
-
         Parameters
         ----------
         name : str
@@ -8521,9 +9359,14 @@ def print(source, element):
         handle : Union[bool, None]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is
             supported. When passing by value, multiple arguments are supported.
+            Deprecated: This option will be removed in the future.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.expose_binding(
                     name=name, callback=self._wrap_handler(callback), handle=handle
@@ -8569,7 +9412,7 @@ def set_content(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> None:
         """Page.set_content
 
@@ -8611,7 +9454,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
 
@@ -8677,7 +9520,7 @@ def reload(
         timeout: typing.Optional[float] = None,
         wait_until: typing.Optional[
             Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
+        ] = None,
     ) -> typing.Optional["Response"]:
         """Page.reload
 
@@ -8716,7 +9559,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
 
@@ -8726,6 +9569,9 @@ def wait_for_load_state(
         committed when this method is called. If current document has already reached the required state, resolves
         immediately.
 
+        **NOTE** Most of the time, this method is not needed because Playwright
+        [auto-waits before every action](https://playwright.dev/python/docs/actionability).
+
         **Usage**
 
         ```py
@@ -8769,7 +9615,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
 
@@ -8785,7 +9631,7 @@ def wait_for_url(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -8811,100 +9657,280 @@ def wait_for_url(
             )
         )
 
+    @typing.overload
     def wait_for_event(
         self,
-        event: str,
-        predicate: typing.Optional[typing.Callable] = None,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
-        timeout: typing.Optional[float] = None
-    ) -> typing.Any:
-        """Page.wait_for_event
-
-        **NOTE** In most cases, you should use `page.expect_event()`.
-
-        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
-        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
-        `event` is fired.
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
 
-        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()`.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
 
-        Returns
-        -------
-        Any
-        """
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
 
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.wait_for_event(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
-            )
-        )
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
 
-    def go_back(
+    @typing.overload
+    def wait_for_event(
         self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
         timeout: typing.Optional[float] = None,
-        wait_until: typing.Optional[
-            Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
-    ) -> typing.Optional["Response"]:
-        """Page.go_back
+    ) -> "Page": ...
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
-        the last redirect. If can not go back, returns `null`.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
 
-        Navigate to the previous page in history.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "FileChooser": ...
 
-        Parameters
-        ----------
-        timeout : Union[float, None]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
-            be changed by using the `browser_context.set_default_navigation_timeout()`,
-            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
-            `page.set_default_timeout()` methods.
-        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
-            When to consider operation succeeded, defaults to `load`. Events can be either:
-            - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.
-            - `'load'` - consider operation to be finished when the `load` event is fired.
-            - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for
-              at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.
-            - `'commit'` - consider operation to be finished when network response is received and the document started
-              loading.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-        Returns
-        -------
-        Union[Response, None]
-        """
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.go_back(timeout=timeout, waitUntil=wait_until))
-        )
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
 
-    def go_forward(
+    @typing.overload
+    def wait_for_event(
         self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
         *,
         timeout: typing.Optional[float] = None,
-        wait_until: typing.Optional[
-            Literal["commit", "domcontentloaded", "load", "networkidle"]
-        ] = None
-    ) -> typing.Optional["Response"]:
-        """Page.go_forward
+    ) -> "Page": ...
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
-        the last redirect. If can not go forward, returns `null`.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Error": ...
 
-        Navigate to the next page in history.
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any:
+        """Page.wait_for_event
+
+        **NOTE** In most cases, you should use `page.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
+        `event` is fired.
+
+        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
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_event(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
+            )
+        )
+
+    def go_back(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_back
+
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect. If cannot go back, returns `null`.
+
+        Navigate to the previous page in history.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            When to consider operation succeeded, defaults to `load`. Events can be either:
+            - `'domcontentloaded'` - consider operation to be finished when the `DOMContentLoaded` event is fired.
+            - `'load'` - consider operation to be finished when the `load` event is fired.
+            - `'networkidle'` - **DISCOURAGED** consider operation to be finished when there are no network connections for
+              at least `500` ms. Don't use this method for testing, rely on web assertions to assess readiness instead.
+            - `'commit'` - consider operation to be finished when network response is received and the document started
+              loading.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(self._impl_obj.go_back(timeout=timeout, waitUntil=wait_until))
+        )
+
+    def go_forward(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_forward
+
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect. If cannot go forward, returns `null`.
+
+        Navigate to the next page in history.
 
         Parameters
         ----------
@@ -8931,6 +9957,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,
         *,
@@ -8941,7 +9989,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
 
@@ -8975,7 +10024,6 @@ def emulate_media(
         # → True
         page.evaluate(\"matchMedia('(prefers-color-scheme: light)').matches\")
         # → False
-        page.evaluate(\"matchMedia('(prefers-color-scheme: no-preference)').matches\")
         ```
 
         Parameters
@@ -8984,12 +10032,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(
@@ -8999,6 +10049,7 @@ def emulate_media(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                 )
             )
         )
@@ -9043,8 +10094,8 @@ def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
-    ) -> None:
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "SyncContextManager":
         """Page.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -9074,9 +10125,13 @@ def add_init_script(
         path : Union[pathlib.Path, str, None]
             Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
             directory. Optional.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(self._impl_obj.add_init_script(script=script, path=path))
         )
 
@@ -9088,8 +10143,8 @@ def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
-    ) -> None:
+        times: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
         """Page.route
 
         Routing provides the capability to modify network requests that are made by a page.
@@ -9101,7 +10156,10 @@ 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.
 
         **Usage**
 
@@ -9135,6 +10193,8 @@ def handle_route(route: Route):
         page.route(\"/api/**\", handle_route)
         ```
 
+        If a request matches multiple registered routes, the most recently registered route takes precedence.
+
         Page routes take precedence over browser context routes (set up with `browser_context.route()`) when request
         matches both handlers.
 
@@ -9145,16 +10205,20 @@ 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.
         times : Union[int, None]
             How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.route(
                     url=self._wrap_handler(url),
@@ -9182,7 +10246,7 @@ def unroute(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while routing.
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while routing.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
             Optional handler function to route the request.
         """
@@ -9195,10 +10259,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
 
@@ -9207,7 +10316,7 @@ def unroute_all(
         Parameters
         ----------
         behavior : Union["default", "ignoreErrors", "wait", None]
-            Specifies wether to wait for already running handlers and what to do if they throw errors:
+            Specifies whether to wait for already running handlers and what to do if they throw errors:
             - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may
               result in unhandled error
             - `'wait'` - wait for current handler calls (if any) to finish
@@ -9223,11 +10332,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
 
@@ -9236,7 +10345,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
         ----------
@@ -9259,7 +10368,8 @@ def route_from_har(
             separate files or entries in the ZIP archive. If `embed` is specified, content is stored inline the HAR file.
         update_mode : Union["full", "minimal", None]
             When set to `minimal`, only record information necessary for routing from HAR. This omits sizes, timing, page,
-            cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to `full`.
+            cookies, security and other types of HAR information that are not used when replaying from HAR. Defaults to
+            `minimal`.
         """
 
         return mapping.from_maybe_impl(
@@ -9280,7 +10390,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,
@@ -9290,7 +10400,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
 
@@ -9335,7 +10445,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`.
@@ -9381,11 +10493,44 @@ def title(self) -> str:
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
 
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+    ) -> str:
+        """Page.aria_snapshot
+
+        Captures the aria snapshot of the page. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots).
+
+        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.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption: including element references like `[ref=e2]`
+            and snapshots of `<iframe>`s. Defaults to `"default"`.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.aria_snapshot(timeout=timeout, depth=depth, mode=mode)
+            )
+        )
+
     def close(
         self,
         *,
         run_before_unload: typing.Optional[bool] = None,
-        reason: typing.Optional[str] = None
+        reason: typing.Optional[str] = None,
     ) -> None:
         """Page.close
 
@@ -9429,7 +10574,7 @@ def click(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -9439,7 +10584,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
 
@@ -9459,9 +10604,10 @@ def click(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9480,9 +10626,12 @@ def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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.
@@ -9511,7 +10660,7 @@ def dblclick(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -9520,7 +10669,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
 
@@ -9530,8 +10679,6 @@ def dblclick(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -9543,9 +10690,10 @@ def dblclick(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9559,15 +10707,16 @@ def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -9592,14 +10741,14 @@ def tap(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -9609,7 +10758,6 @@ def tap(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -9621,9 +10769,10 @@ def tap(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -9633,15 +10782,16 @@ def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
         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(
@@ -9667,7 +10817,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
 
@@ -9693,9 +10843,8 @@ def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -9720,10 +10869,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
 
@@ -9779,7 +10928,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
 
@@ -9816,7 +10965,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
 
@@ -9857,7 +11006,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
 
@@ -9986,10 +11135,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
 
@@ -10010,7 +11159,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -10043,6 +11192,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`.
 
@@ -10109,7 +11259,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         page.get_by_test_id(\"directions\").click()
@@ -10136,7 +11286,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
 
@@ -10200,7 +11350,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
 
@@ -10268,7 +11418,7 @@ def focus(
         selector: str,
         *,
         strict: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Page.focus
 
@@ -10299,7 +11449,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
 
@@ -10335,7 +11485,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
 
@@ -10371,7 +11521,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
 
@@ -10408,7 +11558,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
 
@@ -10446,14 +11596,14 @@ def hover(
         selector: str,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         timeout: typing.Optional[float] = None,
         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
 
@@ -10463,7 +11613,6 @@ def hover(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
@@ -10473,9 +11622,10 @@ def hover(
         selector : str
             A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
             used.
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -10483,9 +11633,8 @@ def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -10493,7 +11642,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(
@@ -10522,7 +11673,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
 
@@ -10559,9 +11711,8 @@ def drag_and_drop(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10571,6 +11722,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(
@@ -10585,6 +11739,7 @@ def drag_and_drop(
                     timeout=timeout,
                     strict=strict,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -10602,7 +11757,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
 
@@ -10648,9 +11803,8 @@ def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         strict : Union[bool, None]
@@ -10683,7 +11837,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
 
@@ -10731,12 +11885,13 @@ 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
 
         Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then
-        they are resolved relative to the current working directory. For empty array, clears the selected files.
+        they are resolved relative to the current working directory. For empty array, clears the selected files. For inputs
+        with a `[webkitdirectory]` attribute, only a single directory path is supported.
 
         This method expects `selector` to point to an
         [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input). However, if the element is inside
@@ -10756,9 +11911,8 @@ def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -10781,7 +11935,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
 
@@ -10805,9 +11959,8 @@ def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10834,7 +11987,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
 
@@ -10849,7 +12002,8 @@ def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -10889,6 +12043,7 @@ def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         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.
@@ -10916,7 +12071,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
 
@@ -10928,7 +12083,6 @@ def check(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -10948,9 +12102,8 @@ def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -10982,7 +12135,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
 
@@ -10994,7 +12147,6 @@ def uncheck(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -11014,9 +12166,8 @@ def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -11070,7 +12221,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
 
@@ -11137,14 +12288,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()))
@@ -11164,16 +12314,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()`:
 
@@ -11287,12 +12435,192 @@ def pdf(
             )
         )
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["FileChooser"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Error"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
     def expect_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """Page.expect_event
 
@@ -11332,7 +12660,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
 
@@ -11363,7 +12691,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
 
@@ -11394,7 +12722,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
 
@@ -11430,7 +12758,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
 
@@ -11457,7 +12785,7 @@ def expect_navigation(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str, None]
-            A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation. Note that if
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while waiting for the navigation. Note that if
             the parameter is a string without wildcard characters, the method will wait for navigation to URL that is exactly
             equal to the string.
         wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
@@ -11489,7 +12817,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
 
@@ -11522,7 +12850,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
 
@@ -11567,7 +12895,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
 
@@ -11600,7 +12928,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
 
@@ -11616,7 +12944,7 @@ def expect_response(
         return response.ok
 
         # or with a lambda
-        with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200) as response_info:
+        with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200 and response.request.method == \"get\") as response_info:
             page.get_by_text(\"trigger response\").click()
         response = response_info.value
         return response.ok
@@ -11647,7 +12975,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
 
@@ -11678,7 +13006,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
 
@@ -11715,7 +13043,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
 
@@ -11727,7 +13055,6 @@ def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -11749,9 +13076,8 @@ def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -11775,11 +13101,18 @@ def set_checked(
             )
         )
 
-    def add_locator_handler(self, locator: "Locator", handler: typing.Callable) -> None:
+    def add_locator_handler(
+        self,
+        locator: "Locator",
+        handler: typing.Union[
+            typing.Callable[["Locator"], typing.Any], typing.Callable[[], typing.Any]
+        ],
+        *,
+        no_wait_after: typing.Optional[bool] = None,
+        times: typing.Optional[int] = None,
+    ) -> None:
         """Page.add_locator_handler
 
-        **NOTE** This method is experimental and its behavior may change in the upcoming releases.
-
         When testing a web page, sometimes unexpected overlays like a \"Sign up\" dialog appear and block actions you want to
         automate, e.g. clicking a button. These overlays don't always show up in the same way or at the same time, making
         them tricky to handle in automated tests.
@@ -11795,6 +13128,8 @@ def add_locator_handler(self, locator: "Locator", handler: typing.Callable) -> N
           is visible, Playwright calls the handler first, and then proceeds with the action/assertion. Note that the
           handler is only called when you perform an action/assertion - if the overlay becomes visible but you don't
           perform any actions, the handler will not be triggered.
+        - After executing the handler, Playwright will ensure that overlay that triggered the handler is not visible
+          anymore. You can opt-out of this behavior with `noWaitAfter`.
         - The execution time of the handler counts towards the timeout of the action/assertion that executed the handler.
           If your handler takes too long, it might cause timeouts.
         - You can register multiple handlers. However, only a single handler will be running at a time. Make sure the
@@ -11802,13 +13137,16 @@ def add_locator_handler(self, locator: "Locator", handler: typing.Callable) -> N
 
         **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**
 
@@ -11816,7 +13154,7 @@ def add_locator_handler(self, locator: "Locator", handler: typing.Callable) -> N
 
         ```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)
 
@@ -11829,7 +13167,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)
 
@@ -11839,101 +13177,241 @@ def handler():
         ```
 
         An example with a custom callback on every actionability check. It uses a `<body>` locator that is always visible,
-        so the handler is called before every actionability check:
+        so the handler is called before every actionability check. It is important to specify `noWaitAfter`, because the
+        handler does not hide the `<body>` element.
 
         ```py
         # Setup the handler.
-        def handler():
+        async def handler():
           await page.evaluate(\"window.removeObstructionsForTestIfNeeded()\")
-        await page.add_locator_handler(page.locator(\"body\"), handler)
+        await page.add_locator_handler(page.locator(\"body\"), handler, no_wait_after=True)
 
         # Write the test as usual.
         await page.goto(\"https://example.com\")
         await page.get_by_role(\"button\", name=\"Start here\").click()
         ```
 
+        Handler takes the original locator as an argument. You can also automatically remove the handler after a number of
+        invocations by setting `times`:
+
+        ```py
+        async def handler(locator):
+          await locator.click()
+        await page.add_locator_handler(page.get_by_label(\"Close\"), handler, times=1)
+        ```
+
         Parameters
         ----------
         locator : Locator
             Locator that triggers the handler.
-        handler : Callable
+        handler : Union[Callable[[Locator], Any], Callable[[], Any]]
             Function that should be run once `locator` appears. This function should get rid of the element that blocks actions
             like click.
+        no_wait_after : Union[bool, None]
+            By default, after calling the handler Playwright will wait until the overlay becomes hidden, and only then
+            Playwright will continue with the action/assertion that triggered the handler. This option allows to opt-out of
+            this behavior, so that overlay can stay visible after the handler has run.
+        times : Union[int, None]
+            Specifies the maximum number of times this handler should be called. Unlimited by default.
         """
 
         return mapping.from_maybe_impl(
             self._sync(
                 self._impl_obj.add_locator_handler(
-                    locator=locator._impl_obj, handler=self._wrap_handler(handler)
+                    locator=locator._impl_obj,
+                    handler=self._wrap_handler(handler),
+                    noWaitAfter=no_wait_after,
+                    times=times,
                 )
             )
         )
 
+    def remove_locator_handler(self, locator: "Locator") -> None:
+        """Page.remove_locator_handler
 
-mapping.register(PageImpl, Page)
+        Removes all locator handlers added by `page.add_locator_handler()` for a specific locator.
 
+        Parameters
+        ----------
+        locator : Locator
+            Locator passed to `page.add_locator_handler()`.
+        """
 
-class WebError(SyncBase):
-    @property
-    def page(self) -> typing.Optional["Page"]:
-        """WebError.page
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.remove_locator_handler(locator=locator._impl_obj))
+        )
 
-        The page that produced this unhandled exception, if any.
+    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
         -------
-        Union[Page, None]
+        List[Request]
         """
-        return mapping.from_impl_nullable(self._impl_obj.page)
 
-    @property
-    def error(self) -> "Error":
-        """WebError.error
+        return mapping.from_impl_list(self._sync(self._impl_obj.requests()))
 
-        Unhandled error that was thrown.
+    def console_messages(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which messages are returned:
 
         Returns
         -------
-        Error
+        List[ConsoleMessage]
         """
-        return mapping.from_impl(self._impl_obj.error)
 
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.console_messages(filter=filter))
+        )
 
-mapping.register(WebErrorImpl, WebError)
+    def page_errors(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> 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.
 
-class BrowserContext(SyncContextManager):
-    @typing.overload
-    def on(
-        self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
-    ) -> None:
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
+        Returns
+        -------
+        List[Error]
         """
-        **NOTE** Only works with Chromium browser's persistent context.
 
-        Emitted when new background page is created in the context.
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.page_errors(filter=filter))
+        )
 
-        ```py
-        background_page = context.wait_for_event(\"backgroundpage\")
-        ```"""
+    def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
 
-    @typing.overload
-    def on(
-        self, event: Literal["close"], f: typing.Callable[["BrowserContext"], "None"]
-    ) -> None:
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
         """
-        Emitted when Browser context gets closed. This might happen because of one of the following:
-        - Browser context is closed.
-        - Browser application is closed or crashed.
-        - The `browser.close()` method was called."""
 
-    @typing.overload
-    def on(
-        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
-    ) -> None:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.clear_console_messages())
+        )
+
+    def clear_page_errors(self) -> None:
+        """Page.clear_page_errors
+
+        Clears all stored page errors from this page. Subsequent calls to `page.page_errors()` will only return
+        errors thrown after the clear.
         """
-        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
 
-        The arguments passed into `console.log` and the page are available on the `ConsoleMessage` event handler argument.
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.clear_page_errors()))
+
+    def pick_locator(self) -> "Locator":
+        """Page.pick_locator
+
+        Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+        Once the user clicks an element, the mode is deactivated and the `Locator` for the picked element is returned.
+
+        **Usage**
+
+        ```py
+        locator = page.pick_locator()
+        print(locator)
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.pick_locator()))
+
+    def cancel_pick_locator(self) -> None:
+        """Page.cancel_pick_locator
+
+        Cancels an ongoing `page.pick_locator()` call by deactivating pick locator mode. If no pick locator mode is
+        active, this method is a no-op.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.cancel_pick_locator()))
+
+
+mapping.register(PageImpl, Page)
+
+
+class WebError(SyncBase):
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """WebError.page
+
+        The page that produced this unhandled exception, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def error(self) -> "Error":
+        """WebError.error
+
+        Unhandled error that was thrown.
+
+        Returns
+        -------
+        Error
+        """
+        return mapping.from_impl(self._impl_obj.error)
+
+
+mapping.register(WebErrorImpl, WebError)
+
+
+class BrowserContext(SyncContextManager):
+
+    @typing.overload
+    def on(
+        self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["BrowserContext"], "None"]
+    ) -> None:
+        """
+        Emitted when Browser context gets closed. This might happen because of one of the following:
+        - Browser context is closed.
+        - Browser application is closed or crashed.
+        - The `browser.close()` method was called."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the page calls one of console API methods, e.g. `console.log` or `console.dir`.
+
+        The arguments passed into `console.log` and the page are available on the `ConsoleMessage` event handler argument.
 
         **Usage**
 
@@ -11974,7 +13452,9 @@ def on(self, event: Literal["page"], f: typing.Callable[["Page"], "None"]) -> No
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         with context.expect_page() as page_info:
@@ -12052,13 +13532,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(
@@ -12120,7 +13594,9 @@ def once(
 
         The earliest moment that page is available is when it has navigated to the initial url. For example, when opening a
         popup with `window.open('http://example.com')`, this event will fire when the network request to
-        \"http://example.com\" is done and its response has started loading in the popup.
+        \"http://example.com\" is done and its response has started loading in the popup. If you would like to route/listen
+        to this network request, use `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
 
         ```py
         with context.expect_page() as page_info:
@@ -12209,7 +13685,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
         -------
@@ -12221,9 +13698,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
         -------
@@ -12255,6 +13730,18 @@ def tracing(self) -> "Tracing":
         """
         return mapping.from_impl(self._impl_obj.tracing)
 
+    @property
+    def debugger(self) -> "Debugger":
+        """BrowserContext.debugger
+
+        Debugger allows to pause and resume the execution.
+
+        Returns
+        -------
+        Debugger
+        """
+        return mapping.from_impl(self._impl_obj.debugger)
+
     @property
     def request(self) -> "APIRequestContext":
         """BrowserContext.request
@@ -12267,6 +13754,18 @@ def request(self) -> "APIRequestContext":
         """
         return mapping.from_impl(self._impl_obj.request)
 
+    @property
+    def clock(self) -> "Clock":
+        """BrowserContext.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
     def set_default_navigation_timeout(self, timeout: float) -> None:
         """BrowserContext.set_default_navigation_timeout
 
@@ -12303,7 +13802,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(
@@ -12337,7 +13836,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(
@@ -12358,10 +13857,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]}]
-            Adds cookies to the browser context.
-
-            For the cookie to apply to all subdomains as well, prefix domain with a dot, like this: ".example.com".
+        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(
@@ -12371,9 +13867,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
 
@@ -12416,22 +13912,30 @@ def grant_permissions(
         Parameters
         ----------
         permissions : Sequence[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
-            - `'geolocation'`
-            - `'midi'`
-            - `'midi-sysex'` (system-exclusive midi)
-            - `'notifications'`
-            - `'camera'`
-            - `'microphone'`
-            - `'background-sync'`
-            - `'ambient-light-sensor'`
+            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'`
-            - `'gyroscope'`
-            - `'magnetometer'`
-            - `'accessibility-events'`
+            - `'ambient-light-sensor'`
+            - `'background-sync'`
+            - `'camera'`
             - `'clipboard-read'`
             - `'clipboard-write'`
+            - `'geolocation'`
+            - `'gyroscope'`
+            - `'local-fonts'`
+            - `'local-network-access'`
+            - `'magnetometer'`
+            - `'microphone'`
+            - `'midi-sysex'` (system-exclusive midi)
+            - `'midi'`
+            - `'notifications'`
             - `'payment-handler'`
+            - `'storage-access'`
+            - `'screen-wake-lock'`
         origin : Union[str, None]
             The [origin] to grant permissions to, e.g. "https://example.com".
         """
@@ -12523,8 +14027,8 @@ def add_init_script(
         self,
         script: typing.Optional[str] = None,
         *,
-        path: typing.Optional[typing.Union[str, pathlib.Path]] = None
-    ) -> None:
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "SyncContextManager":
         """BrowserContext.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -12554,9 +14058,13 @@ def add_init_script(
         path : Union[pathlib.Path, str, None]
             Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
             directory. Optional.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(self._impl_obj.add_init_script(script=script, path=path))
         )
 
@@ -12565,8 +14073,8 @@ def expose_binding(
         name: str,
         callback: typing.Callable,
         *,
-        handle: typing.Optional[bool] = None
-    ) -> None:
+        handle: typing.Optional[bool] = None,
+    ) -> "SyncContextManager":
         """BrowserContext.expose_binding
 
         The method adds a function called `name` on the `window` object of every frame in every page in the context. When
@@ -12606,22 +14114,6 @@ def run(playwright: Playwright):
             run(playwright)
         ```
 
-        An example of passing an element handle:
-
-        ```py
-        def print(source, element):
-            print(element.text_content())
-
-        context.expose_binding(\"clicked\", print, handle=true)
-        page.set_content(\"\"\"
-          <script>
-            document.addEventListener('click', event => window.clicked(event.target));
-          </script>
-          <div>Click me</div>
-          <div>Or click me</div>
-        \"\"\")
-        ```
-
         Parameters
         ----------
         name : str
@@ -12631,9 +14123,14 @@ def print(source, element):
         handle : Union[bool, None]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is
             supported. When passing by value, multiple arguments are supported.
+            Deprecated: This option will be removed in the future.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.expose_binding(
                     name=name, callback=self._wrap_handler(callback), handle=handle
@@ -12641,7 +14138,9 @@ def print(source, element):
             )
         )
 
-    def expose_function(self, name: str, callback: typing.Callable) -> None:
+    def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
         """BrowserContext.expose_function
 
         The method adds a function called `name` on the `window` object of every frame in every page in the context. When
@@ -12691,9 +14190,13 @@ def run(playwright: Playwright):
             Name of the function on the window object.
         callback : Callable
             Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.expose_function(
                     name=name, callback=self._wrap_handler(callback)
@@ -12709,8 +14212,8 @@ def route(
             typing.Callable[["Route", "Request"], typing.Any],
         ],
         *,
-        times: typing.Optional[int] = None
-    ) -> None:
+        times: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
         """BrowserContext.route
 
         Routing provides the capability to modify network requests that are made by any page in the browser context. Once
@@ -12718,7 +14221,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**
 
@@ -12766,16 +14269,20 @@ 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.
         times : Union[int, None]
             How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        SyncContextManager
         """
 
-        return mapping.from_maybe_impl(
+        return mapping.from_impl(
             self._sync(
                 self._impl_obj.route(
                     url=self._wrap_handler(url),
@@ -12803,7 +14310,7 @@ def unroute(
         Parameters
         ----------
         url : Union[Callable[[str], bool], Pattern[str], str]
-            A glob pattern, regex pattern or predicate receiving [URL] used to register a routing with
+            A glob pattern, regex pattern, or predicate receiving [URL] used to register a routing with
             `browser_context.route()`.
         handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
             Optional handler function used to register a routing with `browser_context.route()`.
@@ -12817,10 +14324,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
 
@@ -12829,7 +14383,7 @@ def unroute_all(
         Parameters
         ----------
         behavior : Union["default", "ignoreErrors", "wait", None]
-            Specifies wether to wait for already running handlers and what to do if they throw errors:
+            Specifies whether to wait for already running handlers and what to do if they throw errors:
             - `'default'` - do not wait for current handler calls (if any) to finish, if unrouted handler throws, it may
               result in unhandled error
             - `'wait'` - wait for current handler calls (if any) to finish
@@ -12845,11 +14399,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
 
@@ -12858,7 +14412,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
         ----------
@@ -12898,12 +14452,120 @@ def route_from_har(
             )
         )
 
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["BrowserContext"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebError"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
     def expect_event(
         self,
         event: str,
         predicate: typing.Optional[typing.Callable] = None,
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> EventContextManager:
         """BrowserContext.expect_event
 
@@ -12939,7 +14601,19 @@ def expect_event(
             ).future,
         )
 
-    def close(self, *, reason: typing.Optional[str] = None) -> None:
+    def is_closed(self) -> bool:
+        """BrowserContext.is_closed
+
+        Indicates that the browser context is in the process of closing or has already been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    def close(self, *, reason: typing.Optional[str] = None) -> None:
         """BrowserContext.close
 
         Closes the browser context. All the pages that belong to the browser context will be closed.
@@ -12955,31 +14629,176 @@ 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 set_storage_state(
+        self, storage_state: typing.Union[StorageState, str, pathlib.Path]
+    ) -> None:
+        """BrowserContext.set_storage_state
+
+        Clears the existing cookies, local storage and IndexedDB entries for all origins and sets the new storage state.
+
+        **Usage**
+
+        ```py
+        # Load storage state from a file and apply it to the context.
+        context.set_storage_state(\"state.json\")
+        ```
+
+        Parameters
+        ----------
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_storage_state(storageState=storage_state))
+        )
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "BrowserContext": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebError": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
 
     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
 
@@ -13018,7 +14837,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
 
@@ -13050,7 +14869,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
 
@@ -13102,6 +14921,35 @@ def new_cdp_session(self, page: typing.Union["Page", "Frame"]) -> "CDPSession":
 
 
 class CDPSession(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["CDPSession"], "None"]
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def on(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    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[["CDPSession"], "None"]
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def once(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
     def send(
         self, method: str, params: typing.Optional[typing.Dict] = None
     ) -> typing.Dict:
@@ -13139,6 +14987,8 @@ def detach(self) -> None:
 
 
 class Browser(SyncContextManager):
+
+    @typing.overload
     def on(
         self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
     ) -> None:
@@ -13147,8 +14997,14 @@ def on(
         following:
         - Browser application is closed or crashed.
         - The `browser.close()` method was called."""
+
+    @typing.overload
+    def on(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
         return super().on(event=event, f=f)
 
+    @typing.overload
     def once(
         self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
     ) -> None:
@@ -13157,6 +15013,11 @@ def once(
         following:
         - Browser application is closed or crashed.
         - The `browser.close()` method was called."""
+
+    @typing.overload
+    def once(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
         return super().once(event=event, f=f)
 
     @property
@@ -13169,9 +15030,9 @@ def contexts(self) -> typing.List["BrowserContext"]:
 
         ```py
         browser = pw.webkit.launch()
-        print(len(browser.contexts())) # prints `0`
+        print(len(browser.contexts)) # prints `0`
         context = browser.new_context()
-        print(len(browser.contexts())) # prints `1`
+        print(len(browser.contexts)) # prints `1`
         ```
 
         Returns
@@ -13243,12 +15104,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]
@@ -13257,10 +15119,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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """Browser.new_context
 
@@ -13322,7 +15185,7 @@ def new_context(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -13336,9 +15199,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
@@ -13347,14 +15210,14 @@ 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]
             Network proxy settings to use with this context. Defaults to none.
-
-            **NOTE** For Chromium on Windows the browser needs to be launched with the global proxy for this option to work. If
-            all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({
-            proxy: { server: 'http://per-context' } })`.
         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()`
@@ -13401,6 +15264,23 @@ def new_context(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -13430,6 +15310,7 @@ def new_context(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                     acceptDownloads=accept_downloads,
                     defaultBrowserType=default_browser_type,
                     proxy=proxy,
@@ -13444,6 +15325,7 @@ def new_context(
                     recordHarUrlFilter=record_har_url_filter,
                     recordHarMode=record_har_mode,
                     recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
                 )
             )
         )
@@ -13472,15 +15354,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]
@@ -13489,10 +15372,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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "Page":
         """Browser.new_page
 
@@ -13538,7 +15422,7 @@ def new_page(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -13552,13 +15436,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
@@ -13567,10 +15455,6 @@ def new_page(
             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]
             Network proxy settings to use with this context. Defaults to none.
-
-            **NOTE** For Chromium on Windows the browser needs to be launched with the global proxy for this option to work. If
-            all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({
-            proxy: { server: 'http://per-context' } })`.
         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()`
@@ -13617,6 +15501,23 @@ def new_page(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -13645,6 +15546,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,
@@ -13660,6 +15562,7 @@ def new_page(
                     recordHarUrlFilter=record_har_url_filter,
                     recordHarMode=record_har_mode,
                     recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
                 )
             )
         )
@@ -13673,9 +15576,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.
 
@@ -13701,13 +15604,58 @@ def new_browser_cdp_session(self) -> "CDPSession":
 
         return mapping.from_impl(self._sync(self._impl_obj.new_browser_cdp_session()))
 
+    def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BrowserBindResult:
+        """Browser.bind
+
+        Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
+
+        Parameters
+        ----------
+        title : str
+            Title of the browser server, used for identification.
+        workspace_dir : Union[str, None]
+            Working directory associated with this browser server.
+        host : Union[str, None]
+            Host to bind the web socket server to. When specified, a web socket server is created instead of a named pipe.
+        port : Union[int, None]
+            Port to bind the web socket server to. When specified, a web socket server is created instead of a named pipe. Use
+            `0` to let the OS pick an available port.
+
+        Returns
+        -------
+        {endpoint: str}
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.bind(
+                    title=title, workspaceDir=workspace_dir, host=host, port=port
+                )
+            )
+        )
+
+    def unbind(self) -> None:
+        """Browser.unbind
+
+        Unbinds the browser server previously bound with `browser.bind()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.unbind()))
+
     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
 
@@ -13772,6 +15720,7 @@ def stop_tracing(self) -> bytes:
 
 
 class BrowserType(SyncBase):
+
     @property
     def name(self) -> str:
         """BrowserType.name
@@ -13799,7 +15748,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[
@@ -13811,15 +15760,15 @@ 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,
+        artifacts_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
 
@@ -13857,9 +15806,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.
 
@@ -13882,12 +15834,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]
@@ -13899,12 +15846,19 @@ def launch(
             on.
         traces_dir : Union[pathlib.Path, str, None]
             If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
         chromium_sandbox : Union[bool, None]
             Enable Chromium sandboxing. Defaults to `false`.
         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.
+
         Returns
         -------
         Browser
@@ -13923,11 +15877,11 @@ def launch(
                     timeout=timeout,
                     env=mapping.to_impl(env),
                     headless=headless,
-                    devtools=devtools,
                     proxy=proxy,
                     downloadsPath=downloads_path,
                     slowMo=slow_mo,
                     tracesDir=traces_dir,
+                    artifactsDir=artifacts_dir,
                     chromiumSandbox=chromium_sandbox,
                     firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
                 )
@@ -13939,7 +15893,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]]
@@ -13950,9 +15904,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,
@@ -13978,24 +15931,27 @@ 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,
+        artifacts_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
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -14007,15 +15963,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,
@@ -14042,12 +16012,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]
@@ -14091,7 +16056,7 @@ def launch_persistent_context(
         offline : Union[bool, None]
             Whether to emulate network being offline. Defaults to `false`. Learn more about
             [network emulation](../emulation.md#offline).
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         device_scale_factor : Union[float, None]
@@ -14105,9 +16070,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
@@ -14116,15 +16081,26 @@ 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]
             If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
         chromium_sandbox : Union[bool, None]
             Enable Chromium sandboxing. Defaults to `false`.
         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()`
@@ -14166,6 +16142,23 @@ def launch_persistent_context(
             Optional setting to control resource content management. If `omit` is specified, content is not persisted. If
             `attach` is specified, resources are persisted as separate files and all of these files are archived along with the
             HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -14186,7 +16179,6 @@ def launch_persistent_context(
                     timeout=timeout,
                     env=mapping.to_impl(env),
                     headless=headless,
-                    devtools=devtools,
                     proxy=proxy,
                     downloadsPath=downloads_path,
                     slowMo=slow_mo,
@@ -14210,8 +16202,10 @@ def launch_persistent_context(
                     colorScheme=color_scheme,
                     reducedMotion=reduced_motion,
                     forcedColors=forced_colors,
+                    contrast=contrast,
                     acceptDownloads=accept_downloads,
                     tracesDir=traces_dir,
+                    artifactsDir=artifacts_dir,
                     chromiumSandbox=chromium_sandbox,
                     firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
                     recordHarPath=record_har_path,
@@ -14224,6 +16218,7 @@ def launch_persistent_context(
                     recordHarUrlFilter=record_har_url_filter,
                     recordHarMode=record_har_mode,
                     recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
                 )
             )
         )
@@ -14234,7 +16229,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
 
@@ -14244,6 +16240,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
@@ -14265,6 +16265,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
         -------
@@ -14278,29 +16281,31 @@ def connect_over_cdp(
                     timeout=timeout,
                     slowMo=slow_mo,
                     headers=mapping.to_impl(headers),
+                    isLocal=is_local,
                 )
             )
         )
 
     def connect(
         self,
-        ws_endpoint: str,
+        endpoint: str,
         *,
         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.
+        endpoint : str
+            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]
@@ -14331,7 +16336,7 @@ def connect(
         return mapping.from_impl(
             self._sync(
                 self._impl_obj.connect(
-                    wsEndpoint=ws_endpoint,
+                    endpoint=endpoint,
                     timeout=timeout,
                     slowMo=slow_mo,
                     headers=mapping.to_impl(headers),
@@ -14345,6 +16350,7 @@ def connect(
 
 
 class Playwright(SyncBase):
+
     @property
     def devices(self) -> typing.Dict:
         """Playwright.devices
@@ -14436,6 +16442,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:
@@ -14466,6 +16473,7 @@ def stop(self) -> None:
 
 
 class Tracing(SyncBase):
+
     def start(
         self,
         *,
@@ -14473,12 +16481,22 @@ 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,
+        live: 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
@@ -14492,8 +16510,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]
@@ -14504,6 +16522,10 @@ def start(
             Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
         sources : Union[bool, None]
             Whether to include source files for trace actions.
+        live : Union[bool, None]
+            When enabled, the trace is written to an unarchived file that is updated in real time as actions occur, instead of
+            caching changes and archiving them into a zip file at the end. This is useful for live trace viewing during test
+            execution.
         """
 
         return mapping.from_maybe_impl(
@@ -14514,6 +16536,7 @@ def start(
                     snapshots=snapshots,
                     screenshots=screenshots,
                     sources=sources,
+                    live=live,
                 )
             )
         )
@@ -14551,8 +16574,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(
@@ -14560,7 +16583,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
 
@@ -14575,7 +16598,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
 
@@ -14589,11 +16612,58 @@ 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
+    ) -> "SyncContextManager":
+        """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.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_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
@@ -14662,6 +16732,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]:
@@ -14712,7 +16805,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
 
@@ -14726,7 +16819,6 @@ def check(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -14751,9 +16843,8 @@ def check(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -14775,7 +16866,7 @@ def click(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -14784,7 +16875,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
 
@@ -14821,9 +16913,10 @@ def click(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -14842,9 +16935,15 @@ def click(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            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(
@@ -14859,6 +16958,7 @@ def click(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -14867,7 +16967,7 @@ def dblclick(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         delay: typing.Optional[float] = None,
@@ -14875,7 +16975,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
 
@@ -14887,8 +16988,6 @@ def dblclick(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if
-           the first click of the `dblclick()` triggers a navigation event, this method will throw.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -14899,9 +16998,10 @@ def dblclick(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -14915,12 +17015,16 @@ def dblclick(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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(
@@ -14934,6 +17038,7 @@ def dblclick(
                     force=force,
                     noWaitAfter=no_wait_after,
                     trial=trial,
+                    steps=steps,
                 )
             )
         )
@@ -14943,7 +17048,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
 
@@ -14979,7 +17084,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})
         ```
@@ -15008,7 +17112,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
 
@@ -15025,9 +17129,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
@@ -15038,8 +17144,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
         -------
@@ -15103,7 +17209,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
 
@@ -15132,8 +17238,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
         -------
@@ -15154,7 +17260,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
 
@@ -15186,9 +17292,8 @@ def fill(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -15206,7 +17311,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
 
@@ -15234,9 +17339,8 @@ def clear(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         """
@@ -15253,10 +17357,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
 
@@ -15311,7 +17415,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
 
@@ -15348,7 +17452,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
 
@@ -15389,7 +17493,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
 
@@ -15518,10 +17622,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
 
@@ -15542,7 +17646,7 @@ def get_by_role(
         <button>Submit</button>
         ```
 
-        You can locate each element by it's implicit role:
+        You can locate each element by its implicit role:
 
         ```py
         expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
@@ -15575,6 +17679,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`.
 
@@ -15641,7 +17746,7 @@ def get_by_test_id(
         <button data-testid=\"directions\">Itinéraire</button>
         ```
 
-        You can locate the element by it's test id:
+        You can locate the element by its test id:
 
         ```py
         page.get_by_test_id(\"directions\").click()
@@ -15668,7 +17773,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
 
@@ -15732,7 +17837,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
 
@@ -15849,13 +17954,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
 
@@ -15896,6 +18027,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
         -------
@@ -15908,23 +18041,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()
@@ -15952,7 +18093,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
@@ -16004,9 +18145,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**
 
@@ -16052,7 +18197,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
 
@@ -16085,9 +18231,8 @@ def drag_to(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         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.
@@ -16100,6 +18245,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(
@@ -16112,6 +18260,7 @@ def drag_to(
                     trial=trial,
                     sourcePosition=source_position,
                     targetPosition=target_position,
+                    steps=steps,
                 )
             )
         )
@@ -16147,13 +18296,13 @@ def hover(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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
 
@@ -16171,7 +18320,6 @@ def hover(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -16180,9 +18328,10 @@ def hover(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -16190,14 +18339,15 @@ def hover(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             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(
@@ -16353,7 +18503,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.
@@ -16470,7 +18622,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
 
@@ -16495,7 +18647,8 @@ def press(
         `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`,
         etc.
 
-        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`,
+        `ControlOrMeta`. `ControlOrMeta` resolves to `Control` on Windows and Linux and to `Meta` on macOS.
 
         Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
@@ -16518,6 +18671,7 @@ def press(
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
             can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
             navigating to inaccessible pages. Defaults to `false`.
+            Deprecated: This option will default to `true` in the future.
         """
 
         return mapping.from_maybe_impl(
@@ -16533,7 +18687,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,
@@ -16541,7 +18695,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
 
@@ -16604,7 +18758,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`.
@@ -16636,6 +18792,92 @@ def screenshot(
             )
         )
 
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = 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\"
+        ```
+
+        An AI-optimized snapshot, controlled by `mode`, is different from a default snapshot:
+        1. Includes element references `[ref=e2]`. 2. Does not wait for an element matching the locator, and throws when
+           no elements match. 3. Includes snapshots of `<iframe>`s inside the target.
+
+        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.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.aria_snapshot(timeout=timeout, depth=depth, mode=mode)
+            )
+        )
+
+    def normalize(self) -> "Locator":
+        """Locator.normalize
+
+        Returns a new locator that uses best practices for referencing the matched element, prioritizing test ids, aria
+        roles, and other user-facing attributes over CSS selectors. This is useful for converting implementation-detail
+        selectors into more resilient, human-readable locators.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.normalize()))
+
     def scroll_into_view_if_needed(
         self, *, timeout: typing.Optional[float] = None
     ) -> None:
@@ -16645,6 +18887,8 @@ def scroll_into_view_if_needed(
         it is completely visible as defined by
         [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
 
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
+
         Parameters
         ----------
         timeout : Union[float, None]
@@ -16667,7 +18911,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
 
@@ -16691,9 +18935,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>
         ```
 
@@ -16722,9 +18966,8 @@ def select_option(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
 
@@ -16751,7 +18994,7 @@ def select_text(
         self,
         *,
         force: typing.Optional[bool] = None,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """Locator.select_text
 
@@ -16786,11 +19029,12 @@ 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
 
-        Upload file or multiple files into `<input type=file>`.
+        Upload file or multiple files into `<input type=file>`. For inputs with a `[webkitdirectory]` attribute, only a
+        single directory path is supported.
 
         **Usage**
 
@@ -16801,6 +19045,9 @@ def set_input_files(
         # Select multiple files
         page.get_by_label(\"Upload files\").set_input_files(['file1.txt', 'file2.txt'])
 
+        # Select a directory
+        page.get_by_label(\"Upload directory\").set_input_files('mydir')
+
         # Remove all the selected files
         page.get_by_label(\"Upload file\").set_input_files([])
 
@@ -16829,9 +19076,8 @@ def set_input_files(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -16848,17 +19094,18 @@ def tap(
         self,
         *,
         modifiers: typing.Optional[
-            typing.Sequence[Literal["Alt", "Control", "Meta", "Shift"]]
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
         position: typing.Optional[Position] = None,
         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**
 
@@ -16866,7 +19113,6 @@ def tap(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
 
@@ -16877,9 +19123,10 @@ def tap(
 
         Parameters
         ----------
-        modifiers : Union[Sequence[Union["Alt", "Control", "Meta", "Shift"]], None]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
             Modifier keys to press. Ensures that only these modifiers are pressed during the operation, and then restores
-            current modifiers back. If not specified, currently pressed modifiers are used.
+            current modifiers back. If not specified, currently pressed modifiers are used. "ControlOrMeta" resolves to
+            "Control" on Windows and Linux and to "Meta" on macOS.
         position : Union[{x: float, y: float}, None]
             A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
             the element.
@@ -16889,12 +19136,13 @@ def tap(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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(
@@ -16941,7 +19189,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
 
@@ -16962,9 +19210,8 @@ def type(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -16981,7 +19228,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
 
@@ -17018,9 +19265,8 @@ def press_sequentially(
             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.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            Deprecated: This option has no effect.
         """
 
         return mapping.from_maybe_impl(
@@ -17038,7 +19284,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
 
@@ -17058,7 +19304,6 @@ def uncheck(
         1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now unchecked. If not, this method throws.
 
         If the element is detached from the DOM at any moment during the action, this method throws.
@@ -17077,9 +19322,8 @@ def uncheck(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -17145,7 +19389,7 @@ def wait_for(
         timeout: typing.Optional[float] = None,
         state: typing.Optional[
             Literal["attached", "detached", "hidden", "visible"]
-        ] = None
+        ] = None,
     ) -> None:
         """Locator.wait_for
 
@@ -17188,7 +19432,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
 
@@ -17209,7 +19453,6 @@ def set_checked(
            the element is detached during the checks, the whole action is retried.
         1. Scroll the element into view if needed.
         1. Use `page.mouse` to click in the center of the element.
-        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
         1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
         When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
@@ -17228,9 +19471,8 @@ def set_checked(
         force : Union[bool, None]
             Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
         no_wait_after : Union[bool, None]
-            Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You
-            can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as
-            navigating to inaccessible pages. Defaults to `false`.
+            This option has no effect.
+            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.
@@ -17263,6 +19505,7 @@ def highlight(self) -> None:
 
 
 class APIResponse(SyncBase):
+
     @property
     def ok(self) -> bool:
         """APIResponse.ok
@@ -17327,8 +19570,8 @@ def headers(self) -> typing.Dict[str, str]:
     def headers_array(self) -> typing.List[NameValue]:
         """APIResponse.headers_array
 
-        An array with all the request HTTP headers associated with this response. Header names are not lower-cased. Headers
-        with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+        An array with all the response HTTP headers associated with this response. Header names are not lower-cased.
+        Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
 
         Returns
         -------
@@ -17387,25 +19630,33 @@ def dispose(self) -> None:
 
 
 class APIRequestContext(SyncBase):
-    def dispose(self) -> None:
+
+    def dispose(self, *, reason: typing.Optional[str] = None) -> None:
         """APIRequestContext.dispose
 
         All responses returned by `a_pi_request_context.get()` and similar methods are stored in the memory, so that
         you can later call `a_pi_response.body()`.This method discards all its resources, calling any method on
         disposed `APIRequestContext` will throw an exception.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context disposal.
         """
 
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.dispose(reason=reason))
+        )
 
     def delete(
         self,
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17413,7 +19664,8 @@ def delete(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.delete
 
@@ -17425,7 +19677,7 @@ def delete(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17441,9 +19693,7 @@ def delete(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17454,6 +19704,9 @@ def delete(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17473,6 +19726,7 @@ def delete(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17482,10 +19736,10 @@ def head(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17493,7 +19747,8 @@ def head(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.head
 
@@ -17505,7 +19760,7 @@ def head(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17521,9 +19776,7 @@ def head(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17534,6 +19787,9 @@ def head(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17553,6 +19809,7 @@ def head(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17562,10 +19819,10 @@ def get(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17573,7 +19830,8 @@ def get(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.get
 
@@ -17597,7 +19855,7 @@ def get(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17613,9 +19871,7 @@ def get(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17626,6 +19882,9 @@ def get(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17645,6 +19904,7 @@ def get(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17654,10 +19914,10 @@ def patch(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17665,7 +19925,8 @@ def patch(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.patch
 
@@ -17677,7 +19938,7 @@ def patch(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17693,9 +19954,7 @@ def patch(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17706,6 +19965,9 @@ def patch(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17725,6 +19987,7 @@ def patch(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17734,10 +19997,10 @@ def put(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17745,7 +20008,8 @@ def put(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.put
 
@@ -17757,7 +20021,7 @@ def put(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17773,9 +20037,7 @@ def put(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17786,6 +20048,9 @@ def put(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17805,6 +20070,7 @@ def put(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17814,10 +20080,10 @@ def post(
         url: str,
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17825,7 +20091,8 @@ def post(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.post
 
@@ -17850,11 +20117,11 @@ def post(
         ```
 
         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. You can achieve that with Playwright API like this:
+        encoding. Use `FormData` to construct request body and pass it to the request as `multipart` parameter:
 
         ```python
         api_request_context.post(
-          \"https://example.com/api/uploadScrip'\",
+          \"https://example.com/api/uploadScript'\",
           multipart={
             \"fileField\": {
               \"name\": \"f.js\",
@@ -17868,7 +20135,7 @@ def post(
         ----------
         url : str
             Target URL.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         headers : Union[Dict[str, str], None]
             Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
@@ -17884,9 +20151,7 @@ def post(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17897,6 +20162,9 @@ def post(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -17916,6 +20184,7 @@ def post(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
@@ -17925,11 +20194,11 @@ def fetch(
         url_or_request: typing.Union[str, "Request"],
         *,
         params: typing.Optional[
-            typing.Dict[str, typing.Union[str, float, bool]]
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
         ] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
-        data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
         form: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
         multipart: typing.Optional[
             typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]]
@@ -17937,23 +20206,24 @@ def fetch(
         timeout: typing.Optional[float] = None,
         fail_on_status_code: typing.Optional[bool] = None,
         ignore_https_errors: typing.Optional[bool] = None,
-        max_redirects: typing.Optional[int] = None
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
     ) -> "APIResponse":
         """APIRequestContext.fetch
 
         Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and
-        update context cookies from the response. The method will automatically follow redirects. JSON objects can be
-        passed directly to the request.
+        update context cookies from the response. The method will automatically follow redirects.
 
         **Usage**
 
-        The common way to send file(s) in the body of a request is to encode it as form fields with `multipart/form-data`
-        encoding. You can achieve that with Playwright API like this:
+        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, by specifiying the `multipart` parameter:
 
         ```python
         api_request_context.fetch(
-          \"https://example.com/api/uploadScrip'\",
-          method=\"post\",
+          \"https://example.com/api/uploadScript\",  method=\"post\",
           multipart={
             \"fileField\": {
               \"name\": \"f.js\",
@@ -17967,7 +20237,7 @@ def fetch(
         ----------
         url_or_request : Union[Request, str]
             Target URL or Request to get all parameters from.
-        params : Union[Dict[str, Union[bool, float, str]], None]
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
             Query parameters to be sent with the URL.
         method : Union[str, None]
             If set changes the fetch method (e.g. [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) or
@@ -17986,9 +20256,7 @@ def fetch(
         multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], None]
             Provides an object that will be serialized as html form using `multipart/form-data` encoding and sent as this
             request body. If this parameter is specified `content-type` header will be set to `multipart/form-data` unless
-            explicitly provided. File values can be passed either as
-            [`fs.ReadStream`](https://nodejs.org/api/fs.html#fs_class_fs_readstream) or as file-like object containing file
-            name, mime-type and its content.
+            explicitly provided. File values can be passed as file-like object containing file name, mime-type and its content.
         timeout : Union[float, None]
             Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
         fail_on_status_code : Union[bool, None]
@@ -17999,6 +20267,9 @@ def fetch(
         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.
+        max_retries : Union[int, None]
+            Maximum number of times network errors should be retried. Currently only `ECONNRESET` error is retried. Does not
+            retry based on HTTP response codes. An error will be thrown if the limit is exceeded. Defaults to `0` - no retries.
 
         Returns
         -------
@@ -18019,12 +20290,16 @@ def fetch(
                     failOnStatusCode=fail_on_status_code,
                     ignoreHTTPSErrors=ignore_https_errors,
                     maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
         )
 
     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
 
@@ -18036,19 +20311,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,
         *,
@@ -18061,7 +20341,10 @@ def new_context(
         timeout: typing.Optional[float] = None,
         storage_state: typing.Optional[
             typing.Union[StorageState, str, pathlib.Path]
-        ] = None
+        ] = 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
 
@@ -18080,7 +20363,7 @@ def new_context(
               `http://localhost:3000/bar.html`
         extra_http_headers : Union[Dict[str, str], None]
             An object containing additional HTTP headers to be sent with every request. Defaults to none.
-        http_credentials : Union[{username: str, password: str, origin: Union[str, None]}, None]
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
             Credentials for [HTTP authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If no
             origin is specified, the username and password are sent to any servers upon unauthorized responses.
         ignore_https_errors : Union[bool, None]
@@ -18097,6 +20380,30 @@ def new_context(
             information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
             Either a path to the file with saved storage, or the value returned by one of
             `browser_context.storage_state()` or `a_pi_request_context.storage_state()` methods.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            TLS Client Authentication allows the server to request a client certificate and verify it.
+
+            **Details**
+
+            An array of client certificates to be used. Each certificate object must have either both `certPath` and `keyPath`,
+            a single `pfxPath`, or their corresponding direct value equivalents (`cert` and `key`, or `pfx`). Optionally,
+            `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.
+
+            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
         -------
@@ -18114,6 +20421,9 @@ def new_context(
                     userAgent=user_agent,
                     timeout=timeout,
                     storageState=storage_state,
+                    clientCertificates=client_certificates,
+                    failOnStatusCode=fail_on_status_code,
+                    maxRedirects=max_redirects,
                 )
             )
         )
@@ -18123,11 +20433,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
 
@@ -18164,7 +20475,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
 
@@ -18191,7 +20502,8 @@ def to_have_url(
         self,
         url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.to_have_url
 
@@ -18213,12 +20525,17 @@ def to_have_url(
             Expected URL string or RegExp.
         timeout : Union[float, None]
             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 parameter if specified. A provided predicate ignores this flag.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
             self._sync(
-                self._impl_obj.to_have_url(urlOrRegExp=url_or_reg_exp, timeout=timeout)
+                self._impl_obj.to_have_url(
+                    urlOrRegExp=url_or_reg_exp, timeout=timeout, ignoreCase=ignore_case
+                )
             )
         )
 
@@ -18226,7 +20543,8 @@ def not_to_have_url(
         self,
         url_or_reg_exp: typing.Union[typing.Pattern[str], str],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
+        ignore_case: typing.Optional[bool] = None,
     ) -> None:
         """PageAssertions.not_to_have_url
 
@@ -18238,13 +20556,16 @@ def not_to_have_url(
             Expected URL string or RegExp.
         timeout : Union[float, None]
             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.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
             self._sync(
                 self._impl_obj.not_to_have_url(
-                    urlOrRegExp=url_or_reg_exp, timeout=timeout
+                    urlOrRegExp=url_or_reg_exp, timeout=timeout, ignoreCase=ignore_case
                 )
             )
         )
@@ -18254,6 +20575,7 @@ def not_to_have_url(
 
 
 class LocatorAssertions(SyncBase):
+
     def to_contain_text(
         self,
         expected: typing.Union[
@@ -18266,7 +20588,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
 
@@ -18311,7 +20633,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\"])
@@ -18360,7 +20682,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
 
@@ -18397,7 +20719,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
 
@@ -18440,7 +20762,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
 
@@ -18478,33 +20800,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\"])
         ```
 
@@ -18535,7 +20859,7 @@ def not_to_have_class(
             str,
         ],
         *,
-        timeout: typing.Optional[float] = None
+        timeout: typing.Optional[float] = None,
     ) -> None:
         """LocatorAssertions.not_to_have_class
 
@@ -18558,39 +20882,129 @@ def not_to_have_class(
             )
         )
 
-    def to_have_count(
-        self, count: int, *, timeout: typing.Optional[float] = None
+    def to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
     ) -> None:
-        """LocatorAssertions.to_have_count
+        """LocatorAssertions.to_contain_class
 
-        Ensures the `Locator` resolves to an exact number of DOM nodes.
+        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(\"list > .component\")
-        expect(locator).to_have_count(3)
+        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
         ----------
-        count : int
-            Expected count.
+        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_have_count(count=count, timeout=timeout))
+            self._sync(
+                self._impl_obj.to_contain_class(
+                    expected=mapping.to_impl(expected), timeout=timeout
+                )
+            )
         )
 
-    def not_to_have_count(
-        self, count: int, *, timeout: typing.Optional[float] = None
+    def not_to_contain_class(
+        self,
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[float] = None,
     ) -> None:
-        """LocatorAssertions.not_to_have_count
+        """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:
+        """LocatorAssertions.to_have_count
+
+        Ensures the `Locator` resolves to an exact number of DOM nodes.
+
+        **Usage**
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.locator(\"list > .component\")
+        expect(locator).to_have_count(3)
+        ```
+
+        Parameters
+        ----------
+        count : int
+            Expected count.
+        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_count(count=count, timeout=timeout))
+        )
+
+    def not_to_have_count(
+        self, count: int, *, timeout: typing.Optional[float] = None
+    ) -> None:
+        """LocatorAssertions.not_to_have_count
 
         The opposite of `locator_assertions.to_have_count()`.
 
@@ -18612,7 +21026,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
 
@@ -18649,7 +21063,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
 
@@ -18676,7 +21090,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
 
@@ -18708,7 +21122,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
 
@@ -18793,7 +21207,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
 
@@ -18827,7 +21241,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
 
@@ -18854,7 +21268,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
 
@@ -18907,7 +21321,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
 
@@ -18942,7 +21356,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
 
@@ -19035,7 +21449,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
 
@@ -19070,7 +21484,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
 
@@ -19101,7 +21515,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
 
@@ -19121,18 +21536,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
 
@@ -19217,7 +21641,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
 
@@ -19250,7 +21674,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
 
@@ -19315,7 +21739,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
 
@@ -19346,7 +21770,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
 
@@ -19412,7 +21836,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
 
@@ -19453,7 +21877,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
 
@@ -19518,7 +21942,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
 
@@ -19557,7 +21981,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
 
@@ -19577,11 +22001,500 @@ def not_to_be_in_viewport(
             )
         )
 
+    def to_have_accessible_description(
+        self,
+        description: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_description
+
+        Ensures the `Locator` points to an element with a given
+        [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_accessible_description(\"Save results to disk\")
+        ```
+
+        Parameters
+        ----------
+        description : Union[Pattern[str], str]
+            Expected accessible description.
+        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_description(
+                    description=description, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def not_to_have_accessible_description(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_description
+
+        The opposite of `locator_assertions.to_have_accessible_description()`.
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible description.
+        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_description(
+                    name=name, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_name
+
+        Ensures the `Locator` points to an element with a given
+        [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_accessible_name(\"Save to disk\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        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_name(
+                    name=name, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def not_to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_name
+
+        The opposite of `locator_assertions.to_have_accessible_name()`.
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        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_name(
+                    name=name, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def to_have_role(
+        self,
+        role: Literal[
+            "alert",
+            "alertdialog",
+            "application",
+            "article",
+            "banner",
+            "blockquote",
+            "button",
+            "caption",
+            "cell",
+            "checkbox",
+            "code",
+            "columnheader",
+            "combobox",
+            "complementary",
+            "contentinfo",
+            "definition",
+            "deletion",
+            "dialog",
+            "directory",
+            "document",
+            "emphasis",
+            "feed",
+            "figure",
+            "form",
+            "generic",
+            "grid",
+            "gridcell",
+            "group",
+            "heading",
+            "img",
+            "insertion",
+            "link",
+            "list",
+            "listbox",
+            "listitem",
+            "log",
+            "main",
+            "marquee",
+            "math",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "navigation",
+            "none",
+            "note",
+            "option",
+            "paragraph",
+            "presentation",
+            "progressbar",
+            "radio",
+            "radiogroup",
+            "region",
+            "row",
+            "rowgroup",
+            "rowheader",
+            "scrollbar",
+            "search",
+            "searchbox",
+            "separator",
+            "slider",
+            "spinbutton",
+            "status",
+            "strong",
+            "subscript",
+            "superscript",
+            "switch",
+            "tab",
+            "table",
+            "tablist",
+            "tabpanel",
+            "term",
+            "textbox",
+            "time",
+            "timer",
+            "toolbar",
+            "tooltip",
+            "tree",
+            "treegrid",
+            "treeitem",
+        ],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_role
+
+        Ensures the `Locator` points to an element with a given [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles).
+
+        Note that role is matched as a string, disregarding the ARIA role hierarchy. For example, asserting  a superclass
+        role `\"checkbox\"` on an element with a subclass role `\"switch\"` will fail.
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_role(\"button\")
+        ```
+
+        Parameters
+        ----------
+        role : Union["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"]
+            Required aria role.
+        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_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[
+            "alert",
+            "alertdialog",
+            "application",
+            "article",
+            "banner",
+            "blockquote",
+            "button",
+            "caption",
+            "cell",
+            "checkbox",
+            "code",
+            "columnheader",
+            "combobox",
+            "complementary",
+            "contentinfo",
+            "definition",
+            "deletion",
+            "dialog",
+            "directory",
+            "document",
+            "emphasis",
+            "feed",
+            "figure",
+            "form",
+            "generic",
+            "grid",
+            "gridcell",
+            "group",
+            "heading",
+            "img",
+            "insertion",
+            "link",
+            "list",
+            "listbox",
+            "listitem",
+            "log",
+            "main",
+            "marquee",
+            "math",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "navigation",
+            "none",
+            "note",
+            "option",
+            "paragraph",
+            "presentation",
+            "progressbar",
+            "radio",
+            "radiogroup",
+            "region",
+            "row",
+            "rowgroup",
+            "rowheader",
+            "scrollbar",
+            "search",
+            "searchbox",
+            "separator",
+            "slider",
+            "spinbutton",
+            "status",
+            "strong",
+            "subscript",
+            "superscript",
+            "switch",
+            "tab",
+            "table",
+            "tablist",
+            "tabpanel",
+            "term",
+            "textbox",
+            "time",
+            "timer",
+            "toolbar",
+            "tooltip",
+            "tree",
+            "treegrid",
+            "treeitem",
+        ],
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_role
+
+        The opposite of `locator_assertions.to_have_role()`.
+
+        Parameters
+        ----------
+        role : Union["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"]
+            Required aria role.
+        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_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
 
@@ -19612,3 +22525,22 @@ def not_to_be_ok(self) -> None:
 
 
 mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
+
+
+class Disposable(SyncContextManager):
+
+    def dispose(self) -> None:
+        """Disposable.dispose
+
+        Removes the associated resource. For example, removes the init script installed via `page.add_init_script()`
+        or `browser_context.add_init_script()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
+
+    def close(self) -> None:
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+
+
+mapping.register(DisposableImpl, Disposable)
diff --git a/pyproject.toml b/pyproject.toml
index 2f6801904..1ff674eab 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,57 @@
 [build-system]
-requires = ["setuptools==68.2.2", "setuptools-scm==8.0.4", "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 457212913..e3f1f1ebd 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
@@ -38,12 +39,18 @@ def __init__(self, is_async: bool) -> None:
         )
         self.api = json.loads(process_output.stdout)
         self.errors: Set[str] = set()
+        self.class_aliases: Dict[str, str] = {
+            "Disposable": "AsyncContextManager" if is_async else "SyncContextManager",
+            "DisposableStub": (
+                "AsyncContextManager" if is_async else "SyncContextManager"
+            ),
+        }
         self._patch_case()
 
     def _patch_case(self) -> None:
         self.classes = {}
         for clazz in self.api:
-            if not works_for_python(clazz):
+            if not works_for_python(clazz) and clazz["name"] not in self.class_aliases:
                 continue
             members = {}
             self.classes[clazz["name"]] = clazz
@@ -96,9 +103,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 +139,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}")
@@ -202,36 +213,85 @@ def print_events(self, class_name: str) -> None:
         if events:
             doc = []
             for event_type in ["on", "once"]:
+                return_type = (
+                    "typing.Union[typing.Awaitable[None], None]"
+                    if self.is_async
+                    else "None"
+                )
                 for event in events:
-                    return_type = (
-                        "typing.Union[typing.Awaitable[None], None]"
-                        if self.is_async
-                        else "None"
-                    )
                     func_arg = self.serialize_doc_type(event["type"], "")
                     if func_arg.startswith("{"):
                         func_arg = "typing.Dict"
                     if "Union[" in func_arg:
                         func_arg = func_arg.replace("Union[", "typing.Union[")
-                    if len(events) > 1:
-                        doc.append("    @typing.overload")
-                    impl = ""
-                    if len(events) == 1:
-                        impl = f"        return super().{event_type}(event=event,f=f)"
+                    doc.append("    @typing.overload")
                     doc.append(
                         f"    def {event_type}(self, event: Literal['{event['name'].lower()}'], f: typing.Callable[['{func_arg}'], '{return_type}']) -> None:"
                     )
                     doc.append(
                         f'        """{self.beautify_method_comment(event["comment"], " " * 8)}"""'
                     )
-                    doc.append(impl)
-                if len(events) > 1:
+                if len(events) == 1:
+                    doc.append("    @typing.overload")
                     doc.append(
-                        f"    def {event_type}(self, event: str, f: typing.Callable[...,{return_type}]) -> None:"
+                        f"    def {event_type}(self, event: str, f: typing.Callable[...,{return_type}]) -> None: ..."
                     )
-                    doc.append(f"        return super().{event_type}(event=event,f=f)")
+                    doc.append("")
+                doc.append(
+                    f"    def {event_type}(self, event: str, f: typing.Callable[...,{return_type}]) -> None:"
+                )
+                doc.append(f"        return super().{event_type}(event=event,f=f)")
             print("\n".join(doc))
 
+    def print_event_overloads(self, class_name: str, method_name: str) -> None:
+        """Emit ``@typing.overload`` stubs for ``expect_event`` / ``wait_for_event``
+        keyed on ``Literal`` event names with their payload types from api.json,
+        so pyright/mypy can narrow the return type at call sites.
+        Must be called right before the implementation signature is emitted.
+        """
+        if class_name not in self.classes:
+            return
+        events = self.classes[class_name].get("events") or []
+        if not events:
+            return
+        is_expect = method_name == "expect_event"
+        async_prefix = "async " if not is_expect and self.is_async else ""
+        if is_expect:
+            ctx_mgr = (
+                "AsyncEventContextManager" if self.is_async else "EventContextManager"
+            )
+        for event in events:
+            payload = self.serialize_doc_type(event["type"], "")
+            if payload.startswith("{"):
+                payload = "typing.Dict"
+            if "Union[" in payload:
+                payload = payload.replace("Union[", "typing.Union[")
+            return_type = f'{ctx_mgr}["{payload}"]' if is_expect else f'"{payload}"'
+            event_literal = event["name"].lower()
+            print("    @typing.overload")
+            print(f"    {async_prefix}def {method_name}(")
+            print("        self,")
+            print(f'        event: typing.Literal["{event_literal}"],')
+            print(
+                f'        predicate: typing.Optional[typing.Callable[["{payload}"], bool]] = None,'
+            )
+            print("        *,")
+            print("        timeout: typing.Optional[float] = None,")
+            print(f"    ) -> {return_type}: ...")
+            print("")
+        # Catch-all overload for non-literal event names — keeps pyright happy
+        # with `event: str` callers without falling through to `Unknown`.
+        catchall_return = f"{ctx_mgr}[typing.Any]" if is_expect else "typing.Any"
+        print("    @typing.overload")
+        print(f"    {async_prefix}def {method_name}(")
+        print("        self,")
+        print("        event: str,")
+        print("        predicate: typing.Optional[typing.Callable[..., bool]] = None,")
+        print("        *,")
+        print("        timeout: typing.Optional[float] = None,")
+        print(f"    ) -> {catchall_return}: ...")
+        print("")
+
     def indent_paragraph(self, p: str, indent: str) -> str:
         lines = p.split("\n")
         result = [lines[0]]
@@ -338,6 +398,11 @@ def compare_types(
             doc_type = self.make_optional(doc_type)
 
         if doc_type != code_type:
+            if (
+                code_type in self.class_aliases
+                and doc_type == self.class_aliases[code_type]
+            ):
+                return
             self.errors.add(
                 f"Parameter type mismatch in {fqname}: documented as {doc_type}, code has {code_type}"
             )
@@ -350,9 +415,13 @@ def serialize_python_type(self, value: Any, direction: str) -> str:
             return "Error"
         if str_value == "<class 'NoneType'>":
             return "None"
+        if str_value == "<class 'datetime.datetime'>":
+            return "datetime.datetime"
         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,
@@ -363,7 +432,10 @@ def serialize_python_type(self, value: Any, direction: str) -> str:
         if match and "_api_structures" not in str_value and "_errors" not in str_value:
             if match.group(1) == "EventContextManagerImpl":
                 return "EventContextManager"
-            return match.group(1)
+            class_name = match.group(1)
+            if class_name in self.class_aliases:
+                return self.class_aliases[class_name]
+            return class_name
 
         match = re.match(r"^typing\.(\w+)$", str_value)
         if match:
@@ -385,6 +457,16 @@ def serialize_python_type(self, value: Any, direction: str) -> str:
             return f"{{{', '.join(signature)}}}"
         if origin == Union:
             args = get_args(value)
+            if not self.is_async:
+                # Sync API doesn't accept awaitable callbacks; drop the
+                # Awaitable arm so docstring types match the sync signature.
+                args = tuple(
+                    a
+                    for a in args
+                    if str(get_origin(a)) != "<class 'collections.abc.Awaitable'>"
+                )
+                if len(args) == 1:
+                    return self.serialize_python_type(args[0], direction)
             if len(args) == 2 and str(args[1]) == "<class 'NoneType'>":
                 return self.make_optional(
                     self.serialize_python_type(args[0], direction)
@@ -428,6 +510,8 @@ def serialize_doc_type(self, type: Any, direction: str) -> str:
 
     def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
         if type["name"] == "Promise":
+            if "templates" not in type:
+                return "Any"
             type = type["templates"][0]
 
         if "union" in type:
@@ -479,9 +563,11 @@ def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
             return f"{{{', '.join(items)}}}"
         if type_name == "boolean":
             return "bool"
+        if type_name == "long":
+            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"
@@ -489,14 +575,18 @@ def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
             return "Callable"
         if type_name == "Buffer" or type_name == "ReadStream":
             return "bytes"
+        if type_name == "Date":
+            return "datetime.datetime"
         if type_name == "URL":
             return "str"
         if type_name == "RegExp":
             return "Pattern[str]"
-        if type_name == "null":
+        if type_name == "null" or type_name == "void":
             return "None"
         if type_name == "EvaluationArgument":
             return "Dict"
+        if type_name in self.class_aliases:
+            return self.class_aliases[type_name]
         return type["name"]
 
     def print_remainder(self) -> None:
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 47c084c61..d9bcc41a0 100644
--- a/scripts/expected_api_mismatch.txt
+++ b/scripts/expected_api_mismatch.txt
@@ -4,11 +4,23 @@
 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]
+# python-specific adapter for context manager support
+Method not documented: Disposable.close
 
 # 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]
 Parameter type mismatch in Page.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
 Parameter type mismatch in Page.unroute(handler=): documented as Union[Callable[[Route, Request], Union[Any, Any]], None], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+
+# 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]
+
+# Async API additionally accepts an `async def` predicate.
+Parameter type mismatch in Page.expect_request(url_or_predicate=): documented as Union[Callable[[Request], bool], Pattern[str], str], code has Union[Callable[[Request], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
+Parameter type mismatch in Page.expect_response(url_or_predicate=): documented as Union[Callable[[Response], bool], Pattern[str], str], code has Union[Callable[[Response], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
diff --git a/scripts/generate_api.py b/scripts/generate_api.py
index b35c91cff..07a1f2182 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,
@@ -28,8 +27,11 @@
 from playwright._impl._browser_context import BrowserContext
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._cdp_session import CDPSession
+from playwright._impl._clock import Clock
 from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable
 from playwright._impl._download import Download
 from playwright._impl._element_handle import ElementHandle
 from playwright._impl._fetch import APIRequest, APIRequestContext, APIResponse
@@ -39,22 +41,41 @@
 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._screencast import Screencast
 from playwright._impl._selectors import Selectors
 from playwright._impl._tracing import Tracing
 from playwright._impl._video import Video
 from playwright._impl._web_error import WebError
 
+SYNC_API = False
+
 
 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)
     value = re.sub(r"playwright\._impl\.[\w]+\.([\w]+)", r'"\1"', value)
     value = re.sub(r"typing.Literal", "Literal", value)
+    if SYNC_API:
+        # Sync API does not accept awaitable callbacks; collapse
+        # Union[X, Awaitable[X]] (used for predicates the async API also
+        # accepts as `async def`) down to just X.
+        value = re.sub(
+            r"typing\.Union\[([^\[\],]+),\s*typing\.Awaitable\[\1\]\]",
+            r"\1",
+            value,
+        )
     if param:
         value = re.sub(r"^typing.Union\[([^,]+), None\]$", r"\1 = None", value)
         value = re.sub(
@@ -212,29 +233,33 @@ def return_value(value: Any) -> List[str]:
 
 import typing
 import pathlib
+import datetime
 
 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, 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, DebuggerLocation, DebuggerPausedDetails, ScreencastFrame, BrowserBindResult
 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
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
 from playwright._impl._file_chooser import FileChooser as FileChooserImpl
 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
 from playwright._impl._selectors import Selectors as SelectorsImpl
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._video import Video as VideoImpl
 from playwright._impl._tracing import Tracing as TracingImpl
 from playwright._impl._locator import Locator as LocatorImpl, FrameLocator as FrameLocatorImpl
@@ -249,20 +274,23 @@ def return_value(value: Any) -> List[str]:
     Response,
     Route,
     WebSocket,
+    WebSocketRoute,
     Keyboard,
     Mouse,
     Touchscreen,
     JSHandle,
     ElementHandle,
-    Accessibility,
     FileChooser,
     Frame,
     FrameLocator,
     Worker,
     Selectors,
+    Clock,
     ConsoleMessage,
+    Debugger,
     Dialog,
     Download,
+    Screencast,
     Video,
     Page,
     WebError,
@@ -279,6 +307,7 @@ def return_value(value: Any) -> List[str]:
     PageAssertions,
     LocatorAssertions,
     APIResponseAssertions,
+    Disposable,
 ]
 
 all_types = generated_types + [
diff --git a/scripts/generate_async_api.py b/scripts/generate_async_api.py
index ca52ef1a3..e844bc400 100755
--- a/scripts/generate_async_api.py
+++ b/scripts/generate_async_api.py
@@ -39,7 +39,7 @@ def generate(t: Any) -> None:
     print("")
     class_name = short_name(t)
     base_class = t.__bases__[0].__name__
-    if class_name in ["Page", "BrowserContext", "Browser"]:
+    if class_name in ["Page", "BrowserContext", "Browser", "Disposable"]:
         base_sync_class = "AsyncContextManager"
     elif base_class in ["ChannelOwner", "object", "AssertionsBase"]:
         base_sync_class = "AsyncBase"
@@ -88,7 +88,12 @@ def generate(t: Any) -> None:
             return_type_value = return_type_value.replace(
                 "EventContextManager", "AsyncEventContextManager"
             )
+            return_type_value = return_type_value.replace(
+                '"Disposable"', '"AsyncContextManager"'
+            ).replace('"DisposableStub"', '"AsyncContextManager"')
             print("")
+            if name in ("expect_event", "wait_for_event"):
+                documentation_provider.print_event_overloads(class_name, name)
             async_prefix = "async " if is_async else ""
             print(
                 f"    {async_prefix}def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:"
diff --git a/scripts/generate_sync_api.py b/scripts/generate_sync_api.py
index 01d6cb02b..fa6ac8702 100755
--- a/scripts/generate_sync_api.py
+++ b/scripts/generate_sync_api.py
@@ -19,6 +19,7 @@
 from types import FunctionType
 from typing import Any
 
+import generate_api
 from documentation_provider import DocumentationProvider
 from generate_api import (
     api_globals,
@@ -33,6 +34,8 @@
     signature,
 )
 
+generate_api.SYNC_API = True
+
 documentation_provider = DocumentationProvider(False)
 
 
@@ -40,7 +43,7 @@ def generate(t: Any) -> None:
     print("")
     class_name = short_name(t)
     base_class = t.__bases__[0].__name__
-    if class_name in ["Page", "BrowserContext", "Browser"]:
+    if class_name in ["Page", "BrowserContext", "Browser", "Disposable"]:
         base_sync_class = "SyncContextManager"
     elif base_class in ["ChannelOwner", "object", "AssertionsBase"]:
         base_sync_class = "SyncBase"
@@ -86,7 +89,12 @@ def generate(t: Any) -> None:
             is_async = inspect.iscoroutinefunction(value)
             return_type_value = return_type(value)
             return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value)
+            return_type_value = return_type_value.replace(
+                '"Disposable"', '"SyncContextManager"'
+            ).replace('"DisposableStub"', '"SyncContextManager"')
             print("")
+            if name in ("expect_event", "wait_for_event"):
+                documentation_provider.print_event_overloads(class_name, name)
             print(
                 f"    def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:"
             )
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 29cc21951..3bfa8d6f2 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.59.1"
+
+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.43.0"
+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==11.1.0",
-    ],
-    # TODO: Can be removed once we migrate to pypa/build or pypa/installer.
-    setup_requires=["setuptools-scm==8.0.4", "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
new file mode 100644
index 000000000..2c73bd92f
--- /dev/null
+++ b/tests/assets/client-certificates/README.md
@@ -0,0 +1,7 @@
+# Client Certificate test-certificates
+
+Regenerate all certificates by running:
+
+```
+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-----
+MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQC7FMh85NYnOwtJ
+hP9Fe7p5Rh73mgUDSAwzql1ADCxTTy59TxLrxTMEgBvrN3AOozosPkWouvBpOxRb
+vd0p59vTTcSADX0vexlMdLCdK/2D36ucrD/wQD7W2EWjuHcR91aQ7+e7Gc98Sce7
+mjEyT+YK76F2N+CHTWbFzTQ8g7/CKjFm26HMo0hS76pACPvQPBuTPLdlvVACeP7T
+YBRietVNiG6yY/imOt9iABZTXHhY35dNIjbsudAcTy3w7G4gIXCoQQ9wmDikIU1C
+CY7SBxENt3hTsmBDTExdn2dr2TR/UY6C2MqzPkggOsDAuesg4ReIhiU1pD+/bwGu
+VbK1o4cYUqYPEBsZcfPVa5+2ZHW9hCK8Ll+RdTf5ApagY9losiEDv9k4xJWCij5G
+/6ZLozN7/oumFq1QxwjWhhfhkFgWuxWwB4A78U9kNzBVy3Rt08JFEUFCmCXoPEzI
+i0cx7E0fBRGLhgfCFiIEF742NzW1OHp2eIDXUxRULlaYowTsLGBfEdVcTgxhx//D
+XHiw6fEed5vVsJryM48QtFzpvJHyaTbd9sE/jYQ+SuCkK0uFseCyQsqhssVq/jfF
+oiJgWfvjhTutsg0j7lF8nwEfkrAIHlGUCzKY/HAM1w9fLLJ4cQRQBCa2ck+sY9IY
+w39A4OAJZFcS9jnno0bHQPmuK7sxeQIDAQABAoICAA5XaYcpg8E+JX9dUrRg58qk
+NXuFsxytSUIsrTlbtYotZ8LzbN/mHiMaLwm5Fj4JBUye+XgV3Jg0jzr5MxsjSxbH
+v2iRoCcjqKzTxTZHSQfy/ZTlH4GrayXNLol+eqJF87zopzsQn3dHsKgRCfRxa5Er
+DZWicvPsWxSOxpJdBzY7Rc48yAqH+eNhvAtspOExumtvHCAQgzGtVNufYfCque9X
+piTGxSj5GmbI2u1JCXDGszKWjN9Y3ztMVplBhq+v4JMFacmX4b+zTdjiIrC3GfeT
+OQYxhm+iSbhjn+oEnKGl/ubI98EF5UGTP3OGzR+YIdW1cuTJ0pk6SUa0Cx8hihmR
+rnUgxbXjR/sB383ES4kYVT+tm/a8PIvPd1gu4j28sNRXGgVZ8GU76Y2ZITm3eoDr
+7PzVWsTe+vbxBXenlcmzO9rj91yK0eDBaJnwAIPxHGFxTkQkx3T2nnWStkHrvT6h
+15fHITgKWE+K2FMCIJQj5gIT3qGnZxZDLIgmyowVV9ZXuI2XchehD+L7nVsMhsby
+yIITglz1miYgy7zVL0oolIXuE0eQ4xAZlu1D5wjAQy/VzyB7OYY6bTErC0EmXjNS
+3QAYsI+Kn7YgjNJJNuJ5cC2S8nHNJ2uTJ54KWeA5s1Ry8B5kJrMGZxCT6Uk3POcG
+Ry5BxOczToKIgXeqm4IBAoIBAQDcvNBNXANexHn4r3yXgmL9IH4QXHAJ3h7tO6Ng
+zZh4K5VmoxSJ82CWQkJrs827F1kE2T9Mq6YPvXrh5VlKZjR+II2ZG7KqT00SULDy
+kSgG8OU/2+DWhyoQ6nt1RhXKDz0s4SjHwkeKwBFexTHf5ed+TILPfnPJIUX89gxV
+4EKL+EsqOsT6CMS7gruUuaA29VGVDneBw9KxKD9IdNXDrbot0DhidIYW1QkCed9g
+tnb2QvJrQmTkupUDI+HdWqOfpcBHwf9FIEI1q6cJtpVYSuaZfZX7hbvSHsTt9rwt
+b6gkiuPBy6qoXP1LWHc093tSzXEk1CWy0F4cCPi4r7UWqmWtAoIBAQDY95LGRUTn
+RKRSl2C5uZnsME5G/6XkqVcGhP5TOnT3/li/NLESZDaF+4iEhEh4M1oWVqShq4ps
+S98baYebriZDMmBm8L1YM63N+fhiI3q1+TF26f7zk6XPFQr88WIli58JmrK02EXG
+4XG/GBtzqfsnueBnwBGz5iE8phXqWyPs1/3qGyK+BHnUqnr3BAZpg8aw2PEjMzoC
+ChfLMzSJZRGDNp7sslkMJ9H9CXoMZsG5YJkQp7aSBD1SI5rJ2q7JC3PmOR913CgU
+0DDhxyJhD77aTEwrZOByaHq8F8KxZ8cl+YRl/tnWu7Gwa2pfjnC9DCk1ARCuDcSg
+OW7JTtsd3zx9AoIBAH17uM7BaAkPmGcPG7zlmnBbcE7MvcReSSaDqLT3K53k6OGY
+A60Idff1YtznMiUReMGQ3rMvQQ/hn2Gbh88Lmvu4dcZ8QG0g96dZx72dVyva9ff/
+fyl1XSyQn+5jES/0ycohlZU5lIID/dvqLhgiEh9yT0q1kAzepXLQTOLkwe/gDprL
+Hf8lzPDruMcrXzDe9KnPt5BFShj70D3YbUz4DcbNf8A4jaGdKaoGrj3EfIwyMq1W
+6RQ+HUfTtiqnxCyVhWFFn2Aknn70Pdj/upaevciz4/dAZy1j4H+GrCMIPoXHjwI0
+Tae4dSXH/LxXk/vWXmOZVnT4jwdQ8lPLTx67b2ECggEAK5t20IrTknflXwQ12J5J
+JYN/+B0hxpeSeij4xNmW8NEaHTQF8uBZZQxtH9VGi4ImtR6s8CF+LM4DBYtsSgny
+fsb9QTNZmwSoBiIbnf3rh++R1YiqSWJ/jON51eTeCRXK3S9Og7KEM7jUF8hMnC6p
+4A4n4DJmXHYAcCQhe3zd95hh3E+f5/kWU3wAQu14LHTj1l+D98MwAYDtz1V3VbYO
+kwTDZGdkJmFKf0UMVrnAbfXQTdyngSmA+aVWUwO05Yt7u+X3QMUC+UvuxzIy4rc7
+cLytAnu/8L63DF7qLqXhDOzdg3J5bgNDb2Xnd1U1q4lqLtEL/S+fOWTRs3w55gMc
+MQKCAQA0tO3yakIOlizE7qlJye2n2Y/q0nSx1iFlKqEe1ja0O7/t+UzfklBiaDhA
+NAqYOiUsDsL/vf76KQ0uE/v0No/36SKvBuQxozdNEGlZHf7CnsrIg1w9llrJgkYA
+1FoSHgHCbC84+dUoonjYg9vx3Lsszw5O1bmwqTBaGSSglIr3f+a3zxtQUquxNEPS
+advAKAdvXsNECj2cMkv3mxSokGQtd/s/rpvxJ8zi5nq5ig80Gfe/6GJpwJnC+sLr
++tn38FNfk5pKXk8jBXjyLtMNDb2iJbiTa1iX1P76Ae2jtexSd2gELNu7oWbotb/O
+DjCwHSmcSUmAmx7IXfoyRQuKLeRw
+-----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
new file mode 100644
index 000000000..d14ac95b2
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/cert.pem
@@ -0,0 +1,28 @@
+-----BEGIN CERTIFICATE-----
+MIIEyzCCArOgAwIBAgIUUo60oaPj20QM6oeGSn+2CT5j7GYwDQYJKoZIhvcNAQEL
+BQAwDjEMMAoGA1UEAwwDQm9iMB4XDTI1MDcyMTE1NTYyMFoXDTM1MDcxOTE1NTYy
+MFowDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC
+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
new file mode 100644
index 000000000..283dd45a6
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/csr.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEUzCCAjsCAQAwDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOC
+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
new file mode 100644
index 000000000..c3ddd1a91
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----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
new file mode 100644
index 000000000..3430d063c
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/cert.pem
@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFAzCCAuugAwIBAgIBATANBgkqhkiG9w0BAQsFADA2MRIwEAYDVQQDDAlsb2Nh
+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
new file mode 100644
index 000000000..fc930ea7c
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/csr.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEVTCCAj0CAQAwEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0GCSqGSIb3DQEBAQUA
+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
new file mode 100644
index 000000000..a11cdc8a7
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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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
new file mode 100644
index 000000000..18ee3d805
--- /dev/null
+++ b/tests/assets/client-certificates/server/server_cert.pem
@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFdTCCA12gAwIBAgIUFhAlW/DnHoHOFg2CXKBAvwYN4BIwDQYJKoZIhvcNAQEL
+BQAwNjESMBAGA1UEAwwJbG9jYWxob3N0MSAwHgYDVQQKDBdDbGllbnQgQ2VydGlm
+aWNhdGUgRGVtbzAeFw0yNTA3MjExNTU2MThaFw0zNTA3MTkxNTU2MThaMDYxEjAQ
+BgNVBAMMCWxvY2FsaG9zdDEgMB4GA1UECgwXQ2xpZW50IENlcnRpZmljYXRlIERl
+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
+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
new file mode 100644
index 000000000..3a762bde7
--- /dev/null
+++ b/tests/assets/client-certificates/server/server_key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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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/assets/input/folderupload.html b/tests/assets/input/folderupload.html
new file mode 100644
index 000000000..b6a2693b7
--- /dev/null
+++ b/tests/assets/input/folderupload.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Folder upload test</title>
+  </head>
+  <body>
+    <form action="/upload" method="post" enctype="multipart/form-data">
+      <input type="file" name="file1" webkitdirectory>
+      <input type="submit">
+    </form>
+  </body>
+</html>
diff --git a/tests/assets/input/handle-locator.html b/tests/assets/input/handle-locator.html
index 865fb5364..f8f2111c9 100644
--- a/tests/assets/input/handle-locator.html
+++ b/tests/assets/input/handle-locator.html
@@ -50,9 +50,16 @@
       }, false);
 
       close.addEventListener('click', () => {
-        interstitial.classList.remove('visible');
-        target.classList.remove('hidden');
-        target.classList.remove('removed');
+        const closeInterstitial = () => {
+          interstitial.classList.remove('visible');
+          target.classList.remove('hidden');
+          target.classList.remove('removed');
+        };
+
+        if (interstitial.classList.contains('timeout'))
+          setTimeout(closeInterstitial, 3000);
+        else
+          closeInterstitial();
       });
 
       let timesToShow = 0;
@@ -65,9 +72,11 @@
           if (!timesToShow && event !== 'none')
             target.removeEventListener(event, listener, capture === 'capture');
         };
-        if (event === 'hide') {
+        if (event === 'hide' || event === 'timeout') {
           target.classList.add('hidden');
           listener();
+          if (event === 'timeout')
+            interstitial.classList.add('timeout');
         } else if (event === 'remove') {
           target.classList.add('removed');
           listener();
diff --git a/tests/async/conftest.py b/tests/async/conftest.py
index 442d059f4..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:
@@ -84,6 +84,11 @@ async def browser(
     await browser.close()
 
 
+@pytest.fixture(scope="session")
+def browser_version(browser: Browser) -> str:
+    return browser.version
+
+
 @pytest.fixture
 async def context_factory(
     browser: Browser,
@@ -101,12 +106,14 @@ async def launch(**kwargs: Any) -> BrowserContext:
 
 
 @pytest.fixture(scope="session")
-async def default_same_site_cookie_value(browser_name: str) -> str:
+def default_same_site_cookie_value(browser_name: str, is_linux: bool) -> str:
     if browser_name == "chromium":
         return "Lax"
     if browser_name == "firefox":
         return "None"
-    if browser_name == "webkit":
+    if browser_name == "webkit" and is_linux:
+        return "Lax"
+    if browser_name == "webkit" and not is_linux:
         return "None"
     raise Exception(f"Invalid browser_name: {browser_name}")
 
@@ -130,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_add_init_script.py b/tests/async/test_add_init_script.py
index 33853780a..7dbae8aba 100644
--- a/tests/async/test_add_init_script.py
+++ b/tests/async/test_add_init_script.py
@@ -89,3 +89,13 @@ async def test_should_work_with_trailing_comments(page: Page) -> None:
     await page.add_init_script("window.secret = 42;")
     await page.goto("data:text/html,<html></html>")
     assert await page.evaluate("secret") == 42
+
+
+async def test_add_init_script_returns_disposable(page: Page) -> None:
+    async with await page.add_init_script("window.injected = 123"):
+        await page.goto(
+            "data:text/html,<script>window.result = window.injected</script>"
+        )
+        assert await page.evaluate("window.result") == 123
+    await page.goto("data:text/html,<script>window.result = window.injected</script>")
+    assert await page.evaluate("window.result") is None
diff --git a/tests/async/test_assertions.py b/tests/async/test_assertions.py
index b8936f4bf..49e3c3e7f 100644
--- a/tests/async/test_assertions.py
+++ b/tests/async/test_assertions.py
@@ -84,6 +84,11 @@ async def test_assertions_page_to_have_url_with_base_url(
     await page.close()
 
 
+async def test_assertions_page_to_have_url_support_ignore_case(page: Page) -> None:
+    await page.goto("data:text/html,<div>A</div>")
+    await expect(page).to_have_url("DATA:teXT/HTml,<div>a</div>", ignore_case=True)
+
+
 async def test_assertions_locator_to_contain_text(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content("<div id=foobar>kek</div>")
@@ -140,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>")
@@ -269,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(
@@ -481,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)
 
@@ -495,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)
 
@@ -505,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:
@@ -529,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:
@@ -574,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:
@@ -741,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")
@@ -768,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]
 
@@ -815,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:
@@ -823,8 +1028,107 @@ 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)
+
+
+async def test_to_have_accessible_name(page: Page) -> None:
+    await page.set_content('<div role="button" aria-label="Hello"></div>')
+    locator = page.locator("div")
+    await expect(locator).to_have_accessible_name("Hello")
+    await expect(locator).not_to_have_accessible_name("hello")
+    await expect(locator).to_have_accessible_name("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_name(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_name(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_name(
+        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>')
+    locator = page.locator("div")
+    await expect(locator).to_have_accessible_description("Hello")
+    await expect(locator).not_to_have_accessible_description("hello")
+    await expect(locator).to_have_accessible_description("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_description(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_description(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_description(
+        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>')
+    await expect(page.locator("div")).to_have_role("button")
+    await expect(page.locator("div")).not_to_have_role("checkbox")
+    with pytest.raises(Error) as excinfo:
+        await 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/async/test_asyncio.py b/tests/async/test_asyncio.py
index 1d4423afb..c78648430 100644
--- a/tests/async/test_asyncio.py
+++ b/tests/async/test_asyncio.py
@@ -13,11 +13,15 @@
 # limitations under the License.
 import asyncio
 import gc
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
 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 +71,74 @@ 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
+
+
+def test_stop_does_not_deadlock_with_asyncio_atexit(tmp_path: Path) -> None:
+    # Regression test for https://github.com/microsoft/playwright-python/issues/3004.
+    # asyncio.run() cancels all remaining tasks (including transport.run()) before
+    # calling loop.close(). asyncio-atexit hooks loop.close() to run async cleanup,
+    # so awaiting playwright.stop() at that point used to deadlock on a future that
+    # the (already cancelled) run task would never set.
+    script = tmp_path / "atexit_stop.py"
+    script.write_text(
+        textwrap.dedent(
+            """
+            import asyncio
+
+            import asyncio_atexit
+            from playwright.async_api import async_playwright
+
+
+            async def main():
+                pw = await async_playwright().start()
+                asyncio_atexit.register(lambda: stop(pw))
+
+
+            async def stop(pw):
+                await pw.stop()
+                print("STOPPED", flush=True)
+
+
+            asyncio.run(main())
+            """
+        )
+    )
+    result = subprocess.run(
+        [sys.executable, str(script)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, result.stderr
+    assert "STOPPED" in result.stdout
+
+
+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_browser.py b/tests/async/test_browser.py
index e23b3439b..fc3f836a8 100644
--- a/tests/async/test_browser.py
+++ b/tests/async/test_browser.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import re
+from typing import Dict
 
 import pytest
 
@@ -53,3 +54,17 @@ async def test_should_return_browser_type(
     browser: Browser, browser_type: BrowserType
 ) -> None:
     assert browser.browser_type is browser_type
+
+
+async def test_bind_should_return_endpoint_and_allow_unbind(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = await browser_type.launch(**launch_arguments)
+    try:
+        result = await browser.bind("test-server")
+        assert "endpoint" in result
+        assert isinstance(result["endpoint"], str)
+        assert len(result["endpoint"]) > 0
+        await browser.unbind()
+    finally:
+        await browser.close()
diff --git a/tests/async/test_browsercontext.py b/tests/async/test_browsercontext.py
index 877524b92..6b19791b1 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()
 
 
@@ -163,6 +168,13 @@ async def test_close_should_be_callable_twice(browser: Browser) -> None:
     await context.close()
 
 
+async def test_is_closed_should_reflect_state(browser: Browser) -> None:
+    context = await browser.new_context()
+    assert context.is_closed() is False
+    await context.close()
+    assert context.is_closed() is True
+
+
 async def test_user_agent_should_work(browser: Browser, server: Server) -> None:
     async def baseline() -> None:
         context = await browser.new_context()
@@ -472,13 +484,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 +578,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 +589,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 +610,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 +629,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()
 
 
@@ -774,7 +802,7 @@ async def test_page_event_should_work_with_shift_clicking(
 
 @pytest.mark.only_browser("chromium")
 async def test_page_event_should_work_with_ctrl_clicking(
-    context: BrowserContext, server: Server, is_mac: bool
+    context: BrowserContext, server: Server
 ) -> None:
     # Firefox: reports an opener in this case.
     # WebKit: Ctrl+Click does not open a new tab.
@@ -782,7 +810,7 @@ async def test_page_event_should_work_with_ctrl_clicking(
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<a href="/one-style.html">yo</a>')
     async with context.expect_page() as popup_info:
-        await page.click("a", modifiers=["Meta" if is_mac else "Control"])
+        await page.click("a", modifiers=["ControlOrMeta"])
     popup = await popup_info.value
     assert await popup.opener() is None
 
@@ -804,7 +832,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_add_cookies.py b/tests/async/test_browsercontext_add_cookies.py
index 9423ccd63..185a758b0 100644
--- a/tests/async/test_browsercontext_add_cookies.py
+++ b/tests/async/test_browsercontext_add_cookies.py
@@ -233,7 +233,9 @@ async def test_should_have_expires_set_to_neg_1_for_session_cookies(
 
 
 async def test_should_set_cookie_with_reasonable_defaults(
-    context: BrowserContext, server: Server, is_chromium: bool
+    context: BrowserContext,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "defaults", "value": "123456"}]
@@ -249,13 +251,16 @@ async def test_should_set_cookie_with_reasonable_defaults(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
 async def test_should_set_a_cookie_with_a_path(
-    context: BrowserContext, page: Page, server: Server, is_chromium: bool
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await page.goto(server.PREFIX + "/grid.html")
     await context.add_cookies(
@@ -277,7 +282,7 @@ async def test_should_set_a_cookie_with_a_path(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
     assert await page.evaluate("document.cookie") == "gridcookie=GRID"
@@ -342,7 +347,10 @@ async def test_should_be_able_to_set_unsecure_cookie_for_http_website(
 
 
 async def test_should_set_a_cookie_on_a_different_domain(
-    context: BrowserContext, page: Page, server: Server, is_chromium: bool
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
@@ -358,7 +366,7 @@ async def test_should_set_a_cookie_on_a_different_domain(
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
diff --git a/tests/async/test_browsercontext_client_certificates.py b/tests/async/test_browsercontext_client_certificates.py
new file mode 100644
index 000000000..9578a69f7
--- /dev/null
+++ b/tests/async/test_browsercontext_client_certificates.py
@@ -0,0 +1,268 @@
+# 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 sys
+import threading
+from pathlib import Path
+from typing import Dict, Generator, Optional, cast
+
+import OpenSSL.crypto
+import OpenSSL.SSL
+import pytest
+from twisted.internet import reactor as _twisted_reactor
+from twisted.internet import ssl
+from twisted.internet.selectreactor import SelectReactor
+from twisted.web import resource, server
+from twisted.web.http import Request
+
+from playwright.async_api import Browser, BrowserType, Playwright, expect
+
+ssl.optionsForClientTLS
+reactor = cast(SelectReactor, _twisted_reactor)
+
+
+@pytest.fixture(scope="function", autouse=True)
+def _skip_webkit_darwin(browser_name: str) -> None:
+    if browser_name == "webkit" and sys.platform == "darwin":
+        pytest.skip("WebKit does not proxy localhost on macOS")
+
+
+class HttpsResource(resource.Resource):
+    serverCertificate: ssl.PrivateCertificate
+    isLeaf = True
+
+    def _verify_cert_chain(self, cert: Optional[OpenSSL.crypto.X509]) -> bool:
+        if not cert:
+            return False
+        store = OpenSSL.crypto.X509Store()
+        store.add_cert(self.serverCertificate.original)
+        store_ctx = OpenSSL.crypto.X509StoreContext(store, cert)
+        try:
+            store_ctx.verify_certificate()
+            return True
+        except OpenSSL.crypto.X509StoreContextError:
+            return False
+
+    def render_GET(self, request: Request) -> bytes:
+        tls_socket: OpenSSL.SSL.Connection = request.transport.getHandle()  # type: ignore
+        cert = tls_socket.get_peer_certificate()
+        parts = []
+
+        if self._verify_cert_chain(cert):
+            request.setResponseCode(200)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Hello {cert.get_subject().CN}, your certificate was issued by {cert.get_issuer().CN}!",  # type: ignore
+                }
+            )
+        elif cert and cert.get_subject():
+            request.setResponseCode(403)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Sorry {cert.get_subject().CN}, certificates from {cert.get_issuer().CN} are not welcome here.",
+                }
+            )
+        else:
+            request.setResponseCode(401)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": "Sorry, but you need to provide a client certificate to continue.",
+                }
+            )
+        return b"".join(
+            [
+                f'<div data-testid="{part["key"]}">{part["value"]}</div>'.encode()
+                for part in parts
+            ]
+        )
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _client_certificate_server(assetdir: Path) -> Generator[None, None, None]:
+    certAuthCert = ssl.Certificate.loadPEM(
+        (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+    serverCert = ssl.PrivateCertificate.loadPEM(
+        (assetdir / "client-certificates/server/server_key.pem").read_text()
+        + (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+
+    contextFactory = serverCert.options(certAuthCert)
+    contextFactory.requireCertificate = False
+    resource = HttpsResource()
+    resource.serverCertificate = serverCert
+    site = server.Site(resource)
+
+    def _run() -> None:
+        reactor.listenSSL(8000, site, contextFactory)
+
+    thread = threading.Thread(target=_run)
+    thread.start()
+    yield
+    thread.join()
+
+
+async def test_should_throw_with_untrusted_client_certs(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    serverURL = "https://localhost:8000/"
+    request = await playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": serverURL,
+                "certPath": assetdir
+                / "client-certificates/client/self-signed/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/self-signed/key.pem",
+            }
+        ],
+    )
+    with pytest.raises(Exception, match="alert unknown ca"):
+        await request.get(serverURL)
+    await request.dispose()
+
+
+async def test_should_work_with_new_context(browser: Browser, assetdir: Path) -> None:
+    context = await browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = await page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await page.context.request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await context.close()
+
+
+async def test_should_work_with_new_context_passing_as_content(
+    browser: Browser, assetdir: Path
+) -> None:
+    context = await browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "cert": (
+                    assetdir / "client-certificates/client/trusted/cert.pem"
+                ).read_bytes(),
+                "key": (
+                    assetdir / "client-certificates/client/trusted/key.pem"
+                ).read_bytes(),
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = await page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await page.context.request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await context.close()
+
+
+async def test_should_work_with_new_persistent_context(
+    browser_type: BrowserType, assetdir: Path, launch_arguments: Dict
+) -> None:
+    context = await browser_type.launch_persistent_context(
+        "",
+        **launch_arguments,
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+    await context.close()
+
+
+async def test_should_work_with_global_api_request_context(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    request = await playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    response = await request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await request.dispose()
diff --git a/tests/async/test_browsercontext_cookies.py b/tests/async/test_browsercontext_cookies.py
index e99439507..087d00613 100644
--- a/tests/async/test_browsercontext_cookies.py
+++ b/tests/async/test_browsercontext_cookies.py
@@ -27,7 +27,10 @@ async def test_should_return_no_cookies_in_pristine_browser_context(
 
 
 async def test_should_get_a_cookie(
-    context: BrowserContext, page: Page, server: Server, is_chromium: bool
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await page.goto(server.EMPTY_PAGE)
     document_cookie = await page.evaluate(
@@ -46,13 +49,16 @@ async def test_should_get_a_cookie(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
 async def test_should_get_a_non_session_cookie(
-    context: BrowserContext, page: Page, server: Server, is_chromium: bool
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await page.goto(server.EMPTY_PAGE)
     # @see https://en.wikipedia.org/wiki/Year_2038_problem
@@ -85,7 +91,7 @@ async def test_should_get_a_non_session_cookie(
             "path": "/",
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
@@ -146,7 +152,10 @@ async def test_should_properly_report_lax_sameSite_cookie(
 
 
 async def test_should_get_multiple_cookies(
-    context: BrowserContext, page: Page, server: Server, is_chromium: bool
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
 ) -> None:
     await page.goto(server.EMPTY_PAGE)
     document_cookie = await page.evaluate(
@@ -168,7 +177,7 @@ async def test_should_get_multiple_cookies(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         },
         {
             "name": "username",
@@ -178,13 +187,13 @@ async def test_should_get_multiple_cookies(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         },
     ]
 
 
 async def test_should_get_cookies_from_multiple_urls(
-    context: BrowserContext, is_chromium: bool
+    context: BrowserContext, default_same_site_cookie_value: str
 ) -> None:
     await context.add_cookies(
         [
@@ -205,7 +214,7 @@ async def test_should_get_cookies_from_multiple_urls(
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         },
         {
             "name": "doggo",
@@ -215,6 +224,6 @@ async def test_should_get_cookies_from_multiple_urls(
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         },
     ]
diff --git a/tests/async/test_browsercontext_events.py b/tests/async/test_browsercontext_events.py
index a0a3b90eb..cfe585c77 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
@@ -197,4 +197,12 @@ async def test_page_error_event_should_work(page: Page) -> None:
         await page.set_content('<script>throw new Error("boom")</script>')
     page_error = await page_error_info.value
     assert page_error.page == page
-    assert "boom" in page_error.error.stack
+    assert page_error.error.stack and "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 6f2f21440..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
@@ -48,6 +47,29 @@ async def test_should_use_proxy(
     assert await page.title() == "Served by the proxy"
 
 
+async def test_proxy_should_allow_none_for_optional_settings(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    context = await context_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": None,
+            "password": None,
+            "bypass": None,
+        }
+    )
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
 async def test_should_use_proxy_for_second_page(
     context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
 ) -> None:
@@ -85,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:
@@ -116,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..02fb0e2b0 100644
--- a/tests/async/test_browsercontext_storage_state.py
+++ b/tests/async/test_browsercontext_storage_state.py
@@ -15,8 +15,11 @@
 import asyncio
 import json
 from pathlib import Path
+from typing import Optional
 
-from playwright.async_api import Browser, BrowserContext, Page
+import pytest
+
+from playwright.async_api import Browser, BrowserContext, Page, StorageState
 from tests.server import Server
 
 
@@ -44,16 +47,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 +79,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 +116,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)
@@ -102,6 +136,34 @@ async def test_should_round_trip_through_the_file(
     await context2.close()
 
 
+async def test_set_storage_state_should_apply_state_to_existing_context(
+    browser: Browser, browser_channel: Optional[str]
+) -> None:
+    if browser_channel and browser_channel.startswith("msedge"):
+        pytest.skip("Network.clearBrowserCache sometimes stalls on msedge")
+    src = await browser.new_context()
+    src_page = await src.new_page()
+    await src_page.route(
+        "**/*",
+        lambda route: asyncio.create_task(route.fulfill(body="<html></html>")),
+    )
+    await src_page.goto("https://www.example.com")
+    await src_page.evaluate('() => localStorage.setItem("k", "v")')
+    state = await src.storage_state()
+    await src.close()
+
+    dst = await browser.new_context()
+    dst_page = await dst.new_page()
+    await dst_page.route(
+        "**/*",
+        lambda route: asyncio.create_task(route.fulfill(body="<html></html>")),
+    )
+    await dst.set_storage_state(state)
+    await dst_page.goto("https://www.example.com")
+    assert await dst_page.evaluate('() => localStorage.getItem("k")') == "v"
+    await dst.close()
+
+
 async def test_should_serialiser_storage_state_with_lone_surrogates(
     page: Page, context: BrowserContext, server: Server
 ) -> None:
@@ -112,3 +174,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 34bf42245..ccb112ab9 100644
--- a/tests/async/test_browsertype_connect.py
+++ b/tests/async/test_browsertype_connect.py
@@ -16,15 +16,30 @@
 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
-from tests.utils import parse_trace
+from tests.server import Server, TestServerRequest, WebSocketProtocol
+from tests.utils import chromium_version_less_than
+
+from .conftest import TraceViewerPage
+
+
+async def test_should_print_custom_ws_close_error(
+    server: Server, browser_type: BrowserType
+) -> None:
+    def _handle_ws(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendClose(code=4123, reason="Oh my!")
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws)
+    with pytest.raises(Error, match="Oh my!"):
+        await browser_type.connect(f"ws://localhost:{server.PORT}/ws")
 
 
 async def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
@@ -195,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
@@ -252,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],
@@ -313,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)
@@ -329,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(
@@ -391,3 +420,59 @@ async def test_set_input_files_should_preserve_last_modified_timestamp(
     # rounds it to seconds in WebKit: 1696272058110 -> 1696272058000.
     for i in range(len(timestamps)):
         assert abs(timestamps[i] - expected_timestamps[i]) < 1000
+
+
+async def test_should_upload_a_folder(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    server: Server,
+    tmp_path: Path,
+    browser_name: str,
+    browser_version: str,
+    headless: bool,
+) -> None:
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    (dir / "file2").write_text("file2 content")
+    (dir / "sub-dir").mkdir()
+    (dir / "sub-dir" / "really.txt").write_text("sub-dir file content")
+    await input.set_input_files(dir)
+    assert set(
+        await input.evaluate("e => [...e.files].map(f => f.webkitRelativePath)")
+    ) == set(
+        [
+            "file-upload-test/file1.txt",
+            "file-upload-test/file2",
+            # https://issues.chromium.org/issues/345393164
+            *(
+                []
+                if browser_name == "chromium"
+                and headless
+                and chromium_version_less_than(browser_version, "127.0.6533.0")
+                else ["file-upload-test/sub-dir/really.txt"]
+            ),
+        ]
+    )
+    webkit_relative_paths = await input.evaluate(
+        "e => [...e.files].map(f => f.webkitRelativePath)"
+    )
+    for i, webkit_relative_path in enumerate(webkit_relative_paths):
+        content = await input.evaluate(
+            """(e, i) => {
+            const reader = new FileReader();
+            const promise = new Promise(fulfill => reader.onload = fulfill);
+            reader.readAsText(e.files[i]);
+            return promise.then(() => reader.result);
+        }""",
+            i,
+        )
+        assert content == (dir / ".." / webkit_relative_path).read_text()
diff --git a/tests/async/test_browsertype_connect_cdp.py b/tests/async/test_browsertype_connect_cdp.py
index de3d96e77..dc66d3a07 100644
--- a/tests/async/test_browsertype_connect_cdp.py
+++ b/tests/async/test_browsertype_connect_cdp.py
@@ -19,7 +19,7 @@
 import requests
 
 from playwright.async_api import BrowserType, Error
-from tests.server import Server, find_free_port
+from tests.server import Server, WebSocketProtocol, find_free_port
 
 pytestmark = pytest.mark.only_browser("chromium")
 
@@ -92,9 +92,28 @@ async def test_conect_over_a_ws_endpoint(
 async def test_connect_over_cdp_passing_header_works(
     browser_type: BrowserType, server: Server
 ) -> None:
+    server.send_on_web_socket_connection(b"incoming")
     request = asyncio.create_task(server.wait_for_request("/ws"))
     with pytest.raises(Error):
         await browser_type.connect_over_cdp(
-            f"ws://127.0.0.1:{server.PORT}/ws", headers={"foo": "bar"}
+            f"ws://127.0.0.1:{server.PORT}/ws",
+            headers={"foo": "bar"},
+            timeout=5000,
         )
     assert (await request).getHeader("foo") == "bar"
+
+
+async def test_should_print_custom_ws_close_error(
+    browser_type: BrowserType, server: Server
+) -> None:
+    def _handle_ws(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendClose(code=4123, reason="Oh my!")
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws)
+    with pytest.raises(Error, match="Browser logs:\n\nOh my!\n"):
+        await browser_type.connect_over_cdp(
+            f"ws://127.0.0.1:{server.PORT}/ws", headers={"foo": "bar"}
+        )
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 038d6239d..144823e6d 100644
--- a/tests/async/test_click.py
+++ b/tests/async/test_click.py
@@ -435,32 +435,30 @@ async def test_click_the_button_with_device_scale_factor_set(
 
 
 async def test_click_the_button_with_px_border_with_offset(
-    page: Page, server: Server, is_webkit: bool
+    page: Page, server: Server
 ) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '8px'")
     await page.click("button", position={"x": 20, "y": 10})
     assert await page.evaluate("result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 20 + 8 if is_webkit else 20
-    assert await page.evaluate("offsetY") == 10 + 8 if is_webkit else 10
+    assert await page.evaluate("offsetX") == 20
+    assert await page.evaluate("offsetY") == 10
 
 
 async def test_click_the_button_with_em_border_with_offset(
-    page: Page, server: Server, is_webkit: bool
+    page: Page, server: Server
 ) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '2em'")
     await page.eval_on_selector("button", "button => button.style.fontSize = '12px'")
     await page.click("button", position={"x": 20, "y": 10})
     assert await page.evaluate("result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 12 * 2 + 20 if is_webkit else 20
-    assert await page.evaluate("offsetY") == 12 * 2 + 10 if is_webkit else 10
+    assert await page.evaluate("offsetX") == 20
+    assert await page.evaluate("offsetY") == 10
 
 
 async def test_click_a_very_large_button_with_offset(
-    page: Page, server: Server, is_webkit: bool
+    page: Page, server: Server
 ) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '8px'")
@@ -469,13 +467,12 @@ async def test_click_a_very_large_button_with_offset(
     )
     await page.click("button", position={"x": 1900, "y": 1910})
     assert await page.evaluate("() => window.result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("() => offsetX") == 1900 + 8 if is_webkit else 1900
-    assert await page.evaluate("() => offsetY") == 1910 + 8 if is_webkit else 1910
+    assert await page.evaluate("() => offsetX") == 1900
+    assert await page.evaluate("() => offsetY") == 1910
 
 
 async def test_click_a_button_in_scrolling_container_with_offset(
-    page: Page, server: Server, is_webkit: bool
+    page: Page, server: Server
 ) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector(
@@ -495,9 +492,8 @@ async def test_click_a_button_in_scrolling_container_with_offset(
 
     await page.click("button", position={"x": 1900, "y": 1910})
     assert await page.evaluate("window.result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 1900 + 8 if is_webkit else 1900
-    assert await page.evaluate("offsetY") == 1910 + 8 if is_webkit else 1910
+    assert await page.evaluate("offsetX") == 1900
+    assert await page.evaluate("offsetY") == 1910
 
 
 @pytest.mark.skip_browser("firefox")
@@ -547,6 +543,10 @@ async def test_wait_for_stable_position(page: Page, server: Server) -> None:
             document.body.style.margin = '0';
         }""",
     )
+    # rafraf for Firefox to kick in the animation.
+    await page.evaluate(
+        "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+    )
 
     await page.click("button")
     assert await page.evaluate("window.result") == "Clicked"
@@ -564,6 +564,10 @@ async def test_timeout_waiting_for_stable_position(page: Page, server: Server) -
             button.style.marginLeft = '200px'
         }"""
     )
+    # rafraf for Firefox to kick in the animation.
+    await page.evaluate(
+        "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+    )
 
     with pytest.raises(Error) as exc_info:
         await button.click(timeout=3000)
@@ -1103,3 +1107,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_debugger.py b/tests/async/test_debugger.py
new file mode 100644
index 000000000..9613fcb34
--- /dev/null
+++ b/tests/async/test_debugger.py
@@ -0,0 +1,43 @@
+# 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 BrowserContext, Page
+from tests.server import Server
+
+
+async def test_should_expose_debugger_property(context: BrowserContext) -> None:
+    assert context.debugger is context.debugger
+    assert context.debugger.paused_details is None
+
+
+async def test_should_pause_and_resume(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    paused_event = asyncio.Event()
+    context.debugger.on("pausedstatechanged", lambda: paused_event.set())
+
+    await context.debugger.request_pause()
+    next_call = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+
+    await asyncio.wait_for(paused_event.wait(), timeout=5)
+    assert context.debugger.paused_details is not None
+
+    paused_event.clear()
+    await context.debugger.resume()
+    await asyncio.wait_for(paused_event.wait(), timeout=5)
+    assert context.debugger.paused_details is None
+
+    await next_call
diff --git a/tests/async/test_defaultbrowsercontext.py b/tests/async/test_defaultbrowsercontext.py
index e5d06ff96..f5d2a606d 100644
--- a/tests/async/test_defaultbrowsercontext.py
+++ b/tests/async/test_defaultbrowsercontext.py
@@ -15,11 +15,29 @@
 import asyncio
 import os
 from pathlib import Path
-from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, Optional, Tuple
+from typing import (
+    Any,
+    AsyncGenerator,
+    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
 
@@ -28,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
 
@@ -37,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)
@@ -49,7 +67,7 @@ async def _launch(**options: Any) -> Tuple[Page, BrowserContext]:
 async def test_context_cookies_should_work(
     server: Server,
     launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
-    is_chromium: bool,
+    default_same_site_cookie_value: str,
 ) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
@@ -61,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",
@@ -70,7 +88,7 @@ async def test_context_cookies_should_work(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
@@ -78,15 +96,22 @@ async def test_context_cookies_should_work(
 async def test_context_add_cookies_should_work(
     server: Server,
     launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
-    is_chromium: bool,
+    default_same_site_cookie_value: Literal["Lax", "None", "Strict"],
 ) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
     await page.context.add_cookies(
-        [{"url": server.EMPTY_PAGE, "name": "username", "value": "John Doe"}]
+        [
+            {
+                "url": server.EMPTY_PAGE,
+                "name": "username",
+                "value": "John Doe",
+                "sameSite": default_same_site_cookie_value,
+            }
+        ]
     )
     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",
@@ -95,11 +120,17 @@ async def test_context_add_cookies_should_work(
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "Lax" if is_chromium else "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
+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]]]",
@@ -115,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") == ""
 
 
@@ -287,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:
@@ -333,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(
@@ -386,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_dialog.py b/tests/async/test_dialog.py
index 7ad32f8bc..a25c6468f 100644
--- a/tests/async/test_dialog.py
+++ b/tests/async/test_dialog.py
@@ -102,3 +102,15 @@ async def test_should_auto_dismiss_the_alert_without_listeners(page: Page) -> No
     )
     await page.click("div")
     assert await page.evaluate('"window._clicked"')
+
+
+async def test_dismiss_should_swallow_target_closed_error(browser: Browser) -> None:
+    context = await browser.new_context()
+    page = await context.new_page()
+    async with page.expect_event("dialog") as dialog_info:
+        await page.evaluate("() => setTimeout(() => alert('hello'), 0)", None)
+    dialog = await dialog_info.value
+    await page.close()
+    # Dialog.dismiss should be a no-op once the target is closed.
+    await dialog.dismiss()
+    await context.close()
diff --git a/tests/async/test_download.py b/tests/async/test_download.py
index 96d06820e..6b0d6be1a 100644
--- a/tests/async/test_download.py
+++ b/tests/async/test_download.py
@@ -65,6 +65,7 @@ async def test_should_report_downloads_with_accept_downloads_false(
         == f"<Download url={download.url!r} suggested_filename={download.suggested_filename!r}>"
     )
     assert await download.path()
+    assert await download.failure() is None
 
 
 async def test_should_report_downloads_with_accept_downloads_true(
@@ -82,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"
@@ -97,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"
@@ -116,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"
@@ -136,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"
@@ -169,32 +170,36 @@ 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 (
-        "Pass { accept_downloads: True } when you are creating your browser context"
+        "Pass 'accept_downloads=True' when you are creating your browser context"
         in exc.value.message
     )
+    assert (
+        "Pass 'accept_downloads=True' when you are creating your browser context."
+        == await download.failure()
+    )
     await page.close()
 
 
 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_browser_context.py b/tests/async/test_fetch_browser_context.py
index 695b140b7..cc4e2b555 100644
--- a/tests/async/test_fetch_browser_context.py
+++ b/tests/async/test_fetch_browser_context.py
@@ -13,14 +13,15 @@
 # limitations under the License.
 
 import asyncio
+import base64
 import json
-from typing import Any, cast
+from typing import Any, Callable, cast
 from urllib.parse import parse_qs
 
 import pytest
 
-from playwright.async_api import BrowserContext, Error, FilePayload, Page
-from tests.server import Server
+from playwright.async_api import Browser, BrowserContext, Error, FilePayload, Page
+from tests.server import Server, TestServerRequest
 from tests.utils import must
 
 
@@ -96,8 +97,48 @@ async def test_should_support_query_params(
             server.EMPTY_PAGE + "?p1=foo", params=expected_params
         ),
     )
-    assert server_req.args["p1".encode()][0].decode() == "v1"
-    assert len(server_req.args["p1".encode()]) == 1
+    assert list(map(lambda x: x.decode(), server_req.args["p1".encode()])) == [
+        "foo",
+        "v1",
+    ]
+    assert server_req.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_params_passed_as_object(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = {
+        "param1": "value1",
+        "парам2": "знач2",
+    }
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params),
+    )
+    assert server_req.args["param1".encode()][0].decode() == "value1"
+    assert len(server_req.args["param1".encode()]) == 1
+    assert server_req.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_params_passed_as_strings(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = "?param1=value1&param1=value2&парам2=знач2"
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params),
+    )
+    assert list(map(lambda x: x.decode(), server_req.args["param1".encode()])) == [
+        "value1",
+        "value2",
+    ]
+    assert len(server_req.args["param1".encode()]) == 2
     assert server_req.args["парам2".encode()][0].decode() == "знач2"
 
 
@@ -150,6 +191,66 @@ async def test_should_not_add_context_cookie_if_cookie_header_passed_as_paramete
     assert server_req.getHeader("Cookie") == "foo=bar"
 
 
+async def test_should_support_http_credentials_send_immediately_for_browser_context(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]", server: Server
+) -> None:
+    context = await context_factory(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    # First request
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), context.request.get(server.EMPTY_PAGE)
+    )
+    expected_auth = "Basic " + base64.b64encode(b"user:pass").decode()
+    assert server_request.getHeader("authorization") == expected_auth
+    assert response.status == 200
+
+    # Second request
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+
+async def test_support_http_credentials_send_immediately_for_browser_new_page(
+    server: Server, browser: Browser
+) -> None:
+    page = await browser.new_page(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), page.request.get(server.EMPTY_PAGE)
+    )
+    assert (
+        server_request.getHeader("authorization")
+        == "Basic " + base64.b64encode(b"user:pass").decode()
+    )
+    assert response.status == 200
+
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        page.request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+    await page.close()
+
+
 @pytest.mark.parametrize("method", ["delete", "patch", "post", "put"])
 async def test_should_support_post_data(
     context: BrowserContext, method: str, server: Server
@@ -243,3 +344,32 @@ async def test_should_add_default_headers(
     assert request.getHeader("User-Agent") == await page.evaluate(
         "() => navigator.userAgent"
     )
+
+
+async def test_should_work_after_context_dispose(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.close(reason="Test ended.")
+    with pytest.raises(Error, match="Test ended."):
+        await context.request.get(server.EMPTY_PAGE)
+
+
+async def test_should_retry_ECONNRESET(context: BrowserContext, server: Server) -> None:
+    request_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal request_count
+        request_count += 1
+        if request_count <= 3:
+            assert req.transport
+            req.transport.abortConnection()
+            return
+        req.setHeader("content-type", "text/plain")
+        req.write(b"Hello!")
+        req.finish()
+
+    server.set_route("/test", _handle_request)
+    response = await context.request.fetch(server.PREFIX + "/test", max_retries=3)
+    assert response.status == 200
+    assert await response.text() == "Hello!"
+    assert request_count == 4
diff --git a/tests/async/test_fetch_global.py b/tests/async/test_fetch_global.py
index 5e26f4550..1f7593194 100644
--- a/tests/async/test_fetch_global.py
+++ b/tests/async/test_fetch_global.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import base64
 import json
 import sys
 from pathlib import Path
@@ -22,7 +23,7 @@
 import pytest
 
 from playwright.async_api import APIResponse, Error, Playwright, StorageState
-from tests.server import Server
+from tests.server import Server, TestServerRequest
 
 
 @pytest.mark.parametrize(
@@ -56,6 +57,15 @@ async def test_should_dispose_global_request(
         await response.body()
 
 
+async def test_should_dispose_with_custom_error_message(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    await request.dispose(reason="My reason")
+    with pytest.raises(Error, match="My reason"):
+        await request.get(server.EMPTY_PAGE)
+
+
 async def test_should_support_global_user_agent_option(
     playwright: Playwright, server: Server
 ) -> None:
@@ -75,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:
@@ -204,6 +223,35 @@ async def test_should_return_error_with_correct_credentials_and_mismatching_port
     await response.dispose()
 
 
+async def test_support_http_credentials_send_immediately(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), request.get(server.EMPTY_PAGE)
+    )
+    assert (
+        server_request.getHeader("authorization")
+        == "Basic " + base64.b64encode(b"user:pass").decode()
+    )
+    assert response.status == 200
+
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+
 async def test_should_support_global_ignore_https_errors_option(
     playwright: Playwright, https_server: Server
 ) -> None:
@@ -250,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": [
@@ -268,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
 
@@ -409,12 +457,99 @@ async def test_should_throw_an_error_when_max_redirects_is_less_than_0(
         assert "'max_redirects' must be greater than or equal to '0'" in str(exc_info)
 
 
-async def test_should_serialize_null_values_in_json(
+async def test_should_serialize_request_data(
     playwright: Playwright, server: Server
 ) -> None:
     request = await playwright.request.new_context()
     server.set_route("/echo", lambda req: (req.write(req.post_body), req.finish()))
-    response = await request.post(server.PREFIX + "/echo", data={"foo": None})
+    for data, expected in [
+        ({"foo": None}, '{"foo": null}'),
+        ([], "[]"),
+        ({}, "{}"),
+        ("", ""),
+    ]:
+        response = await request.post(server.PREFIX + "/echo", data=data)
+        assert response.status == 200
+        assert await response.text() == expected
+    await request.dispose()
+
+
+async def test_should_retry_ECONNRESET(playwright: Playwright, server: Server) -> None:
+    request_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal request_count
+        request_count += 1
+        if request_count <= 3:
+            assert req.transport
+            req.transport.abortConnection()
+            return
+        req.setHeader("content-type", "text/plain")
+        req.write(b"Hello!")
+        req.finish()
+
+    server.set_route("/test", _handle_request)
+    request = await playwright.request.new_context()
+    response = await request.fetch(server.PREFIX + "/test", max_retries=3)
     assert response.status == 200
-    assert await response.text() == '{"foo": null}'
+    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 5898d1a6f..b7bd3d799 100644
--- a/tests/async/test_input.py
+++ b/tests/async/test_input.py
@@ -21,12 +21,11 @@
 from typing import Any
 
 import pytest
-from flaky import flaky
 
 from playwright._impl._path_utils import get_file_dirname
-from playwright.async_api import FilePayload, Page
+from playwright.async_api import Error, FilePayload, Page
 from tests.server import Server
-from tests.utils import must
+from tests.utils import chromium_version_less_than, must
 
 _dirname = get_file_dirname()
 FILE_TO_UPLOAD = _dirname / ".." / "assets/file-to-upload.txt"
@@ -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:
@@ -412,3 +409,101 @@ async def test_should_upload_multiple_large_file(
     assert files_len == files_count
     for path in upload_files:
         path.unlink()
+
+
+async def test_should_upload_a_folder(
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    browser_name: str,
+    browser_version: str,
+    headless: bool,
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    (dir / "file2").write_text("file2 content")
+    (dir / "sub-dir").mkdir()
+    (dir / "sub-dir" / "really.txt").write_text("sub-dir file content")
+    await input.set_input_files(dir)
+    assert set(
+        await input.evaluate("e => [...e.files].map(f => f.webkitRelativePath)")
+    ) == set(
+        [
+            "file-upload-test/file1.txt",
+            "file-upload-test/file2",
+            # https://issues.chromium.org/issues/345393164
+            *(
+                []
+                if browser_name == "chromium"
+                and headless
+                and chromium_version_less_than(browser_version, "127.0.6533.0")
+                else ["file-upload-test/sub-dir/really.txt"]
+            ),
+        ]
+    )
+    webkit_relative_paths = await input.evaluate(
+        "e => [...e.files].map(f => f.webkitRelativePath)"
+    )
+    for i, webkit_relative_path in enumerate(webkit_relative_paths):
+        content = await input.evaluate(
+            """(e, i) => {
+            const reader = new FileReader();
+            const promise = new Promise(fulfill => reader.onload = fulfill);
+            reader.readAsText(e.files[i]);
+            return promise.then(() => reader.result);
+        }""",
+            i,
+        )
+        assert content == (dir / ".." / webkit_relative_path).read_text()
+
+
+async def test_should_upload_a_folder_and_throw_for_multiple_directories(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = page.locator("input")
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "folder1").mkdir()
+    (dir / "folder1" / "file1.txt").write_text("file1 content")
+    (dir / "folder2").mkdir()
+    (dir / "folder2" / "file2.txt").write_text("file2 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files([dir / "folder1", dir / "folder2"])
+    assert "Multiple directories are not supported" in exc_info.value.message
+
+
+async def test_should_throw_if_a_directory_and_files_are_passed(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = page.locator("input")
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files([dir, dir / "file1.txt"])
+    assert (
+        "File paths must be all files or a single directory" in exc_info.value.message
+    )
+
+
+async def test_should_throw_when_upload_a_folder_in_a_normal_file_upload_input(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/fileupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files(dir)
+    assert (
+        "File input does not support directories, pass individual files instead"
+        in exc_info.value.message
+    )
diff --git a/tests/async/test_keyboard.py b/tests/async/test_keyboard.py
index 3a449ffe7..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:
@@ -459,24 +461,19 @@ async def test_should_type_emoji_into_an_iframe(
     )
 
 
-async def test_should_handle_select_all(
-    page: Page, server: Server, is_mac: bool
-) -> None:
+async def test_should_handle_select_all(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
     assert textarea
     await textarea.type("some text")
-    modifier = "Meta" if is_mac else "Control"
-    await page.keyboard.down(modifier)
+    await page.keyboard.down("ControlOrMeta")
     await page.keyboard.press("a")
-    await page.keyboard.up(modifier)
+    await page.keyboard.up("ControlOrMeta")
     await page.keyboard.press("Backspace")
     assert await page.eval_on_selector("textarea", "textarea => textarea.value") == ""
 
 
-async def test_should_be_able_to_prevent_select_all(
-    page: Page, server: Server, is_mac: bool
-) -> None:
+async def test_should_be_able_to_prevent_select_all(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
     assert textarea
@@ -491,10 +488,9 @@ async def test_should_be_able_to_prevent_select_all(
   }""",
     )
 
-    modifier = "Meta" if is_mac else "Control"
-    await page.keyboard.down(modifier)
+    await page.keyboard.down("ControlOrMeta")
     await page.keyboard.press("a")
-    await page.keyboard.up(modifier)
+    await page.keyboard.up("ControlOrMeta")
     await page.keyboard.press("Backspace")
     assert (
         await page.eval_on_selector("textarea", "textarea => textarea.value")
diff --git a/tests/async/test_launcher.py b/tests/async/test_launcher.py
index d29b20989..2b954fd61 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
 
@@ -109,37 +109,10 @@ async def test_browser_close_should_be_callable_twice(
     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,
+async def test_browser_type_launch_should_accept_ignore_default_args_false(
+    browser_type: BrowserType, 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
+    # Regression for https://github.com/microsoft/playwright-python/issues/3005:
+    # passing False used to crash with "expected array, got boolean".
+    browser = await browser_type.launch(**launch_arguments, ignore_default_args=False)
+    await browser.close()
diff --git a/tests/async/test_locators.py b/tests/async/test_locators.py
index b12a25a56..1ab16c39d 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,57 @@ 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
+
+
+async def test_normalize_should_resolve_to_a_locator(page: Page) -> None:
+    await page.set_content("<button>Click me</button>")
+    normalized = await page.get_by_role("button").normalize()
+    assert await normalized.text_content() == "Click me"
diff --git a/tests/async/test_navigation.py b/tests/async/test_navigation.py
index de4a2f5e9..a74d67533 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")
 
 
@@ -800,7 +801,7 @@ async def test_wait_for_load_state_should_work_with_pages_that_have_loaded_befor
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_empty_url_popup(
-    page: Page, is_firefox: bool
+    page: Page,
 ) -> None:
     ready_state = []
     async with page.expect_popup() as popup_info:
@@ -815,7 +816,7 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_empty_url_popup
 
     popup = await popup_info.value
     await popup.wait_for_load_state()
-    assert ready_state == ["uninitialized"] if is_firefox else ["complete"]
+    assert ready_state == ["complete"]
     assert await popup.evaluate("() => document.readyState") == ready_state[0]
 
 
diff --git a/tests/async/test_network.py b/tests/async/test_network.py
index b97d38f29..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
@@ -28,6 +27,14 @@
 from .utils import Utils
 
 
+def adjust_server_headers(headers: Dict[str, str], browser_name: str) -> Dict[str, str]:
+    if browser_name != "firefox":
+        return headers
+    headers = headers.copy()
+    headers.pop("priority", None)
+    return headers
+
+
 async def test_request_fulfill(page: Page, server: Server) -> None:
     async def handle_request(route: Route, request: Request) -> None:
         headers = await route.request.all_headers()
@@ -193,7 +200,11 @@ async def test_request_headers_should_work(
 
 
 async def test_request_headers_should_get_the_same_headers_as_the_server(
-    page: Page, server: Server, is_webkit: bool, is_win: bool
+    page: Page,
+    server: Server,
+    is_webkit: bool,
+    is_win: bool,
+    browser_name: str,
 ) -> None:
     if is_webkit and is_win:
         pytest.xfail("Curl does not show accept-encoding and accept-language")
@@ -211,12 +222,14 @@ def handle(request: http.Request) -> None:
     server.set_route("/empty.html", handle)
     response = await page.goto(server.EMPTY_PAGE)
     assert response
-    server_headers = await server_request_headers_future
+    server_headers = adjust_server_headers(
+        await server_request_headers_future, browser_name
+    )
     assert await response.request.all_headers() == server_headers
 
 
 async def test_request_headers_should_get_the_same_headers_as_the_server_cors(
-    page: Page, server: Server, is_webkit: bool, is_win: bool
+    page: Page, server: Server, is_webkit: bool, is_win: bool, browser_name: str
 ) -> None:
     if is_webkit and is_win:
         pytest.xfail("Curl does not show accept-encoding and accept-language")
@@ -246,7 +259,9 @@ def handle_something(request: http.Request) -> None:
         )
     request = await request_info.value
     assert text == "done"
-    server_headers = await server_request_headers_future
+    server_headers = adjust_server_headers(
+        await server_request_headers_future, browser_name
+    )
     assert await request.all_headers() == server_headers
 
 
@@ -260,6 +275,8 @@ async def test_should_report_request_headers_array(
     def handle(request: http.Request) -> None:
         for name, values in request.requestHeaders.getAllRawHeaders():
             for value in values:
+                if browser_name == "firefox" and name.decode().lower() == "priority":
+                    continue
                 expected_headers.append(
                     {"name": name.decode().lower(), "value": value.decode()}
                 )
@@ -801,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:
@@ -837,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..2fcf4c92d 100644
--- a/tests/async/test_page.py
+++ b/tests/async/test_page.py
@@ -16,7 +16,7 @@
 import os
 import re
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import pytest
 
@@ -352,6 +352,53 @@ async def test_wait_for_response_should_work_with_predicate(
     assert response.url == server.PREFIX + "/digits/2.png"
 
 
+async def test_wait_for_response_should_work_with_async_predicate(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    async def predicate(response: Any) -> bool:
+        await asyncio.sleep(0)
+        return response.url == server.PREFIX + "/digits/2.png"
+
+    async with page.expect_response(predicate) as response_info:
+        await page.evaluate(
+            """() => {
+                fetch('/digits/1.png')
+                fetch('/digits/2.png')
+                fetch('/digits/3.png')
+            }"""
+        )
+    response = await response_info.value
+    assert response.url == server.PREFIX + "/digits/2.png"
+
+
+async def test_expect_response_should_reject_when_async_predicate_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    async def predicate(response: Any) -> bool:
+        raise Exception("Async oops!")
+
+    with pytest.raises(Exception, match="Async oops!"):
+        async with page.expect_response(predicate):
+            await page.evaluate("() => fetch('/digits/1.png')")
+
+
+async def test_expect_response_should_reject_when_sync_predicate_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    def predicate(response: Any) -> bool:
+        raise Exception("Sync oops!")
+
+    with pytest.raises(Exception, match="Sync oops!"):
+        async with page.expect_response(predicate):
+            await page.evaluate("() => fetch('/digits/1.png')")
+
+
 async def test_wait_for_response_should_work_with_no_timeout(
     page: Page, server: Server
 ) -> None:
@@ -662,7 +709,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 +1367,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 +1497,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 +1507,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 +1550,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 +1597,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 8eb08c59d..5f44170f8 100644
--- a/tests/async/test_page_add_locator_handler.py
+++ b/tests/async/test_page_add_locator_handler.py
@@ -16,7 +16,7 @@
 
 import pytest
 
-from playwright.async_api import Error, Page, expect
+from playwright.async_api import Error, Locator, Page, expect
 from tests.server import Server
 from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
@@ -27,16 +27,17 @@ async def test_should_work(page: Page, server: Server) -> None:
     before_count = 0
     after_count = 0
 
-    async def handler() -> None:
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    async def handler(locator: Locator) -> None:
+        assert locator == original_locator
         nonlocal before_count
         nonlocal after_count
         before_count += 1
         await page.locator("#close").click()
         after_count += 1
 
-    await page.add_locator_handler(
-        page.locator("text=This interstitial covers the button"), handler
-    )
+    await page.add_locator_handler(original_locator, handler)
 
     for args in [
         ["mouseover", 1],
@@ -72,7 +73,7 @@ async def handler() -> None:
         if await page.get_by_text("This interstitial covers the button").is_visible():
             await page.locator("#close").click()
 
-    await page.add_locator_handler(page.locator("body"), handler)
+    await page.add_locator_handler(page.locator("body"), handler, no_wait_after=True)
 
     for args in [
         ["mouseover", 2],
@@ -196,3 +197,192 @@ async def handler() -> None:
     await expect(page.locator("#target")).to_be_visible()
     await expect(page.locator("#interstitial")).not_to_be_visible()
     assert called == 1
+
+
+async def test_should_work_when_owner_frame_detaches(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """
+    () => {
+        const iframe = document.createElement('iframe');
+        iframe.src = 'data:text/html,<body>hello from iframe</body>';
+        document.body.append(iframe);
+
+        const target = document.createElement('button');
+        target.textContent = 'Click me';
+        target.id = 'target';
+        target.addEventListener('click', () => window._clicked = true);
+        document.body.appendChild(target);
+
+        const closeButton = document.createElement('button');
+        closeButton.textContent = 'close';
+        closeButton.id = 'close';
+        closeButton.addEventListener('click', () => iframe.remove());
+        document.body.appendChild(closeButton);
+    }
+    """
+    )
+    await page.add_locator_handler(
+        page.frame_locator("iframe").locator("body"),
+        lambda: page.locator("#close").click(),
+    )
+    await page.locator("#target").click()
+    assert await page.query_selector("iframe") is None
+    assert await page.evaluate("window._clicked") is True
+
+
+async def test_should_work_with_times_option(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    await page.add_locator_handler(
+        page.locator("body"), _handler, no_wait_after=True, times=2
+    )
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('mouseover', 4);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.locator("#target").click(timeout=3000)
+    assert called == 2
+    assert await page.evaluate("window.clicked") == 0
+    await expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in exc_info.value.message
+    assert (
+        '<div>This interstitial covers the button</div> from <div class="visible" id="interstitial">…</div> subtree intercepts pointer events'
+        in exc_info.value.message
+    )
+
+
+async def test_should_wait_for_hidden_by_default(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        await button.click()
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+async def test_should_wait_for_hidden_by_default_2(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.locator("#target").click(timeout=3000)
+    assert await page.evaluate("window.clicked") == 0
+    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'
+        in exc_info.value.message
+    )
+
+
+async def test_should_work_with_noWaitAfter(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        if called == 1:
+            await button.click()
+        else:
+            await page.locator("#interstitial").wait_for(state="hidden")
+
+    await page.add_locator_handler(
+        page.get_by_role("button", name="close"), _handler, no_wait_after=True
+    )
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 2
+
+
+async def test_should_removeLocatorHandler(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(locator: Locator) -> None:
+        nonlocal called
+        called += 1
+        await locator.click()
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert called == 1
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    await page.remove_locator_handler(page.get_by_role("button", name="close"))
+    with pytest.raises(Error) as error:
+        await page.locator("#target").click(timeout=3000)
+    assert called == 1
+    assert await page.evaluate("window.clicked") == 0
+    await expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in error.value.message
diff --git a/tests/async/test_page_aria_snapshot.py b/tests/async/test_page_aria_snapshot.py
new file mode 100644
index 000000000..302ff37cb
--- /dev/null
+++ b/tests/async/test_page_aria_snapshot.py
@@ -0,0 +1,233 @@
+# 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=/
+      """,
+    )
+
+
+async def test_should_snapshot_with_depth(page: Page) -> None:
+    await page.set_content("<ul><li><a href=about:blank>link</a></li></ul>")
+    snapshot = await page.locator("body").aria_snapshot(depth=1)
+    assert "listitem" in snapshot
+    assert "/url" not in snapshot
+
+
+async def test_page_aria_snapshot_should_work(page: Page) -> None:
+    await page.set_content("<h1>title</h1>")
+    snapshot = await page.aria_snapshot()
+    assert _unshift(snapshot) == _unshift(
+        """
+      - heading "title" [level=1]
+    """
+    )
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
new file mode 100644
index 000000000..cbe7740ea
--- /dev/null
+++ b/tests/async/test_page_clock.py
@@ -0,0 +1,487 @@
+# 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 datetime
+from typing import Any, AsyncGenerator, List
+
+import pytest
+
+from playwright.async_api import Error, Page
+from tests.server import Server
+
+
+@pytest.fixture(autouse=True)
+async def calls(page: Page) -> List[Any]:
+    calls: List[Any] = []
+    await page.expose_function("stub", lambda *args: calls.append(list(args)))
+    return calls
+
+
+class TestRunFor:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1000)
+        yield
+
+    async def test_run_for_triggers_immediately_without_specified_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub)")
+        await page.clock.run_for(0)
+        assert len(calls) == 1
+
+    async def test_run_for_does_not_trigger_without_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 100)")
+        await page.clock.run_for(10)
+        assert len(calls) == 0
+
+    async def test_run_for_triggers_after_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 100)")
+        await page.clock.run_for(100)
+        assert len(calls) == 1
+
+    async def test_run_for_triggers_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100)"
+        )
+        await page.clock.run_for(100)
+        assert len(calls) == 2
+
+    async def test_run_for_triggers_multiple_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100); setTimeout(window.stub, 99); setTimeout(window.stub, 100)"
+        )
+        await page.clock.run_for(100)
+        assert len(calls) == 4
+
+    async def test_run_for_waits_after_setTimeout_was_called(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 150)")
+        await page.clock.run_for(50)
+        assert len(calls) == 0
+        await page.clock.run_for(100)
+        assert len(calls) == 1
+
+    async def test_run_for_triggers_event_when_some_throw(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { throw new Error(); }, 100); setTimeout(window.stub, 120)"
+        )
+        with pytest.raises(Error):
+            await page.clock.run_for(120)
+        assert len(calls) == 1
+
+    async def test_run_for_creates_updated_Date_while_ticking(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.set_system_time(0)
+        await page.evaluate(
+            "setInterval(() => { window.stub(new Date().getTime()); }, 10)"
+        )
+        await page.clock.run_for(100)
+        assert calls == [
+            [10],
+            [20],
+            [30],
+            [40],
+            [50],
+            [60],
+            [70],
+            [80],
+            [90],
+            [100],
+        ]
+
+    async def test_run_for_passes_8_seconds(self, page: Page, calls: List[Any]) -> None:
+        await page.evaluate("setInterval(window.stub, 4000)")
+        await page.clock.run_for("08")
+        assert len(calls) == 2
+
+    async def test_run_for_passes_1_minute(self, page: Page, calls: List[Any]) -> None:
+        await page.evaluate("setInterval(window.stub, 6000)")
+        await page.clock.run_for("01:00")
+        assert len(calls) == 10
+
+    async def test_run_for_passes_2_hours_34_minutes_and_10_seconds(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 10000)")
+        await page.clock.run_for("02:34:10")
+        assert len(calls) == 925
+
+    async def test_run_for_throws_for_invalid_format(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 10000)")
+        with pytest.raises(Error):
+            await page.clock.run_for("12:02:34:10")
+        assert len(calls) == 0
+
+    async def test_run_for_returns_the_current_now_value(self, page: Page) -> None:
+        await page.clock.set_system_time(0)
+        value = 200
+        await page.clock.run_for(value)
+        assert await page.evaluate("Date.now()") == value
+
+
+class TestFastForward:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        yield
+
+    async def test_ignores_timers_which_wouldnt_be_run(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { window.stub('should not be logged'); }, 1000)"
+        )
+        await page.clock.fast_forward(500)
+        assert len(calls) == 0
+
+    async def test_pushes_back_execution_time_for_skipped_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(() => { window.stub(Date.now()); }, 1000)")
+        await page.clock.fast_forward(2000)
+        assert calls == [[1000 + 2000]]
+
+    async def test_supports_string_time_arguments(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { window.stub(Date.now()); }, 100000)"
+        )  # 100000 = 1:40
+        await page.clock.fast_forward("01:50")
+        assert calls == [[1000 + 110000]]
+
+
+class TestStubTimers:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        yield
+
+    async def test_sets_initial_timestamp(self, page: Page) -> None:
+        await page.clock.set_system_time(1.4)
+        assert await page.evaluate("Date.now()") == 1400
+
+    async def test_replaces_global_setTimeout(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 1000)")
+        await page.clock.run_for(1000)
+        assert len(calls) == 1
+
+    async def test_global_fake_setTimeout_should_return_id(self, page: Page) -> None:
+        to = await page.evaluate("setTimeout(window.stub, 1000)")
+        assert isinstance(to, int)
+
+    async def test_replaces_global_clearTimeout(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            """
+            const to = setTimeout(window.stub, 1000);
+            clearTimeout(to);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    async def test_replaces_global_setInterval(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 500)")
+        await page.clock.run_for(1000)
+        assert len(calls) == 2
+
+    async def test_replaces_global_clearInterval(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            """
+            const to = setInterval(window.stub, 500);
+            clearInterval(to);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    async def test_replaces_global_performance_now(self, page: Page) -> None:
+        promise = asyncio.create_task(
+            page.evaluate(
+                """async () => {
+            const prev = performance.now();
+            await new Promise(f => setTimeout(f, 1000));
+            const next = performance.now();
+            return { prev, next };
+        }"""
+            )
+        )
+        await asyncio.sleep(0)  # Make sure the promise is scheduled.
+        await page.clock.run_for(1000)
+        assert await promise == {"prev": 1000, "next": 2000}
+
+    async def test_fakes_Date_constructor(self, page: Page) -> None:
+        now = await page.evaluate("new Date().getTime()")
+        assert now == 1000
+
+
+class TestStubTimersPerformance:
+    async def test_replaces_global_performance_time_origin(self, page: Page) -> None:
+        await page.clock.install(time=1)
+        await page.clock.pause_at(2)
+        promise = asyncio.create_task(
+            page.evaluate(
+                """async () => {
+            const prev = performance.now();
+            await new Promise(f => setTimeout(f, 1000));
+            const next = performance.now();
+            return { prev, next };
+        }"""
+            )
+        )
+        await asyncio.sleep(0)  # Make sure the promise is scheduled.
+        await page.clock.run_for(1000)
+        assert await page.evaluate("performance.timeOrigin") == 1000
+        assert await promise == {"prev": 1000, "next": 2000}
+
+
+class TestPopup:
+    async def test_should_tick_after_popup(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        await page.clock.pause_at(now)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"), page.evaluate("window.open('about:blank')")
+        )
+        popup_time = await popup.evaluate("Date.now()")
+        assert popup_time == now.timestamp() * 1000
+        await page.clock.run_for(1000)
+        popup_time_after = await popup.evaluate("Date.now()")
+        assert popup_time_after == now.timestamp() * 1000 + 1000
+
+    async def test_should_tick_before_popup(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        await page.clock.pause_at(now)
+        await page.clock.run_for(1000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"), page.evaluate("window.open('about:blank')")
+        )
+        popup_time = await popup.evaluate("Date.now()")
+        assert popup_time == int(now.timestamp() * 1000 + 1000)
+        assert datetime.datetime.fromtimestamp(popup_time / 1_000).year == 2015
+
+    async def test_should_run_time_before_popup(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        await page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        await page.wait_for_timeout(2000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"),
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html")),
+        )
+        popup_time = await popup.evaluate("window.time")
+        assert popup_time >= 2000
+
+    async def test_should_not_run_time_before_popup_on_pause(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        await page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        await page.wait_for_timeout(2000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"),
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html")),
+        )
+        popup_time = await popup.evaluate("window.time")
+        assert popup_time == 1000
+
+
+class TestSetFixedTime:
+    async def test_does_not_fake_methods(self, page: Page) -> None:
+        await page.clock.set_fixed_time(0)
+        # Should not stall.
+        await page.evaluate("new Promise(f => setTimeout(f, 1))")
+
+    async def test_allows_setting_time_multiple_times(self, page: Page) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.set_fixed_time(0.2)
+        assert await page.evaluate("Date.now()") == 200
+
+    async def test_fixed_time_is_not_affected_by_clock_manipulation(
+        self, page: Page
+    ) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.fast_forward(20)
+        assert await page.evaluate("Date.now()") == 100
+
+    async def test_allows_installing_fake_timers_after_setting_time(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.set_fixed_time(0.2)
+        await page.evaluate("setTimeout(() => window.stub(Date.now()))")
+        await page.clock.run_for(0)
+        assert calls == [[200]]
+
+
+class TestWhileRunning:
+    async def test_should_progress_time(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.wait_for_timeout(1000)
+        now = await page.evaluate("Date.now()")
+        assert 1000 <= now <= 2000
+
+    async def test_should_run_for(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.run_for(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_fast_forward(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.fast_forward(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_fast_forward_to(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.fast_forward(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_pause(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        await page.wait_for_timeout(1000)
+        now = await page.evaluate("Date.now()")
+        assert 0 <= now <= 1000
+
+    async def test_should_pause_and_fast_forward(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        await page.clock.fast_forward(1000)
+        now = await page.evaluate("Date.now()")
+        assert now == 2000
+
+    async def test_should_set_system_time_on_pause(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        now = await page.evaluate("Date.now()")
+        assert now == 1000
+
+
+class TestWhileOnPause:
+    async def test_fast_forward_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        await page.clock.fast_forward(1000)
+        assert calls == [["outer"]]
+        await page.clock.fast_forward(1)
+        assert calls == [["outer"], ["inner"]]
+
+    async def test_run_for_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        await page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
+
+    async def test_run_for_should_not_run_nested_immediate_from_microtask(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                void Promise.resolve().then(() => setTimeout(() => window.stub('inner'), 0));
+            }, 1000);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        await page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
diff --git a/tests/async/test_evaluate.py b/tests/async/test_page_evaluate.py
similarity index 77%
rename from tests/async/test_evaluate.py
rename to tests/async/test_page_evaluate.py
index 0b2143769..058263b18 100644
--- a/tests/async/test_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
@@ -208,8 +231,52 @@ async def test_evaluate_throw_if_underlying_element_was_disposed(page: Page) ->
 
 
 async def test_evaluate_evaluate_exception(page: Page) -> None:
-    error = await page.evaluate('new Error("error message")')
-    assert "Error: error message" in error
+    error = await page.evaluate(
+        """() => {
+        function innerFunction() {
+        const e = new Error('error message');
+        e.name = 'foobar';
+        return e;
+        }
+        return innerFunction();
+    }"""
+    )
+    assert isinstance(error, Error)
+    assert error.message == "error message"
+    assert error.name == "foobar"
+    assert error.stack
+    assert "innerFunction" in error.stack
+
+
+async def test_should_pass_exception_argument(page: Page) -> None:
+    def _raise_and_get_exception(exception: Exception) -> Exception:
+        try:
+            raise exception
+        except Exception as e:
+            return e
+
+    error_for_roundtrip = Error("error message")
+    error_for_roundtrip._name = "foobar"
+    error_for_roundtrip._stack = "test stack"
+    error = await page.evaluate(
+        """e => {
+            return { message: e.message, name: e.name, stack: e.stack };
+        }""",
+        error_for_roundtrip,
+    )
+    assert error["message"] == "error message"
+    assert error["name"] == "foobar"
+    assert "test stack" in error["stack"]
+
+    error = await page.evaluate(
+        """e => {
+            return { message: e.message, name: e.name, stack: e.stack };
+        }""",
+        _raise_and_get_exception(Exception("error message")),
+    )
+    assert error["message"] == "error message"
+    assert error["name"] == "Exception"
+    assert "error message" in error["stack"]
 
 
 async def test_evaluate_evaluate_date(page: Page) -> None:
diff --git a/tests/async/test_page_event_console.py b/tests/async/test_page_event_console.py
new file mode 100644
index 000000000..2b6bc5ddf
--- /dev/null
+++ b/tests/async/test_page_event_console.py
@@ -0,0 +1,65 @@
+# 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_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"
+
+
+async def test_should_have_a_timestamp(page: Page) -> None:
+    async with page.expect_console_message() as message_info:
+        await page.evaluate("() => console.log('hello')")
+    message = await message_info.value
+    assert message.timestamp > 0
+
+
+async def test_clear_console_messages_should_drop_buffered_messages(page: Page) -> None:
+    await page.evaluate("() => console.log('first')")
+    assert any(m.text == "first" for m in await page.console_messages())
+    await page.clear_console_messages()
+    assert not any(m.text == "first" for m in await page.console_messages())
+    await page.evaluate("() => console.log('second')")
+    assert any(m.text == "second" for m in await page.console_messages())
+
+
+async def test_console_messages_filter_since_navigation_drops_pre_nav_messages(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => console.log('before-nav')")
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => console.log('after-nav')")
+    after = await page.console_messages(filter="since-navigation")
+    texts = [m.text for m in after]
+    assert "after-nav" in texts
+    assert "before-nav" not in texts
diff --git a/tests/async/test_page_event_pageerror.py b/tests/async/test_page_event_pageerror.py
new file mode 100644
index 000000000..a072f009e
--- /dev/null
+++ b/tests/async/test_page_event_pageerror.py
@@ -0,0 +1,60 @@
+# 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_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"
+
+
+async def test_clear_page_errors_should_drop_buffered_errors(page: Page) -> None:
+    await page.evaluate("() => setTimeout(() => { throw new Error('first'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    assert any(e.message == "first" for e in await page.page_errors())
+    await page.clear_page_errors()
+    assert not any(e.message == "first" for e in await page.page_errors())
+
+
+async def test_page_errors_filter_since_navigation_drops_pre_nav_errors(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => setTimeout(() => { throw new Error('before-nav'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => setTimeout(() => { throw new Error('after-nav'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    after = await page.page_errors(filter="since-navigation")
+    messages = [e.message for e in after]
+    assert "after-nav" in messages
+    assert "before-nav" not in messages
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_network_request.py b/tests/async/test_page_network_request.py
index 779875eda..bab4d5fd0 100644
--- a/tests/async/test_page_network_request.py
+++ b/tests/async/test_page_network_request.py
@@ -61,3 +61,24 @@ async def test_should_parse_the_data_if_content_type_is_application_x_www_form_u
     request = await request_info.value
     assert request
     assert request.post_data_json == {"foo": "bar", "baz": "123"}
+
+
+async def test_existing_response_should_return_response_after_it_is_received(
+    page: Page, server: Server
+) -> None:
+    async with page.expect_event("requestfinished") as request_finished_info:
+        await page.goto(server.EMPTY_PAGE)
+    request = await request_finished_info.value
+    assert request.existing_response is not None
+    assert request.existing_response.status == 200
+
+
+async def test_existing_response_should_return_none_before_response_arrives(
+    page: Page, server: Server
+) -> None:
+    captured = []
+    page.on("request", lambda req: captured.append(req.existing_response))
+    await page.goto(server.EMPTY_PAGE)
+    assert captured
+    # When the "request" event fires, the response has not been received yet.
+    assert captured[0] is None
diff --git a/tests/async/test_page_network_response.py b/tests/async/test_page_network_response.py
index 58988fabc..55bd5ff54 100644
--- a/tests/async/test_page_network_response.py
+++ b/tests/async/test_page_network_response.py
@@ -70,3 +70,10 @@ def handle_get(request: TestServerRequest) -> None:
         await finish_coroutine
     error = exc_info.value
     assert "closed" in error.message
+
+
+async def test_should_return_http_version(page: Page, server: Server) -> None:
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    http_version = await response.http_version()
+    assert http_version in ("HTTP/1.0", "HTTP/1.1", "HTTP/2.0")
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..d294031d5 100644
--- a/tests/async/test_page_request_intercept.py
+++ b/tests/async/test_page_request_intercept.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import asyncio
-from typing import cast
 
 import pytest
 
@@ -34,7 +33,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:
@@ -98,4 +97,4 @@ async def route_handler(route: Route) -> None:
     [popup, _] = await asyncio.gather(
         page.wait_for_event("popup"), page.get_by_text("click me").click()
     )
-    await expect(cast(Page, popup).locator("body")).to_have_text("hello")
+    await expect(popup.locator("body")).to_have_text("hello")
diff --git a/tests/async/test_page_route.py b/tests/async/test_page_route.py
index 8e0b74130..ecfac7f73 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,181 @@ 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")
+
+
+async def test_page_route_returns_disposable(page: Page, server: Server) -> None:
+    intercepted: List[str] = []
+
+    async def handler(route: Route) -> None:
+        intercepted.append(route.request.url)
+        await route.continue_()
+
+    async with await page.route("**/*", handler):
+        await page.goto(server.EMPTY_PAGE)
+        assert any(server.EMPTY_PAGE in url for url in intercepted)
+    intercepted.clear()
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == []
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_popup.py b/tests/async/test_popup.py
index ff3b346ff..3c14b87f0 100644
--- a/tests/async/test_popup.py
+++ b/tests/async/test_popup.py
@@ -15,6 +15,8 @@
 import asyncio
 from typing import List, Optional
 
+import pytest
+
 from playwright.async_api import Browser, BrowserContext, Request, Route
 from tests.server import Server
 from tests.utils import must
@@ -136,9 +138,13 @@ async def test_should_inherit_http_credentials_from_browser_context(
     await context.close()
 
 
+@pytest.mark.skip_browser("firefox")
 async def test_should_inherit_touch_support_from_browser_context(
     browser: Browser, server: Server
 ) -> None:
+    # Firefox 148+ does not expose `ontouchstart` on freshly window.open()'d
+    # popups (https://bugzilla.mozilla.org/show_bug.cgi?id=2014330);
+    # upstream marks this as fixme for the same reason.
     context = await browser.new_context(
         viewport={"width": 400, "height": 500}, has_touch=True
     )
diff --git a/tests/async/test_proxy.py b/tests/async/test_proxy.py
index d85613964..694786aae 100644
--- a/tests/async/test_proxy.py
+++ b/tests/async/test_proxy.py
@@ -46,6 +46,29 @@ async def test_should_use_proxy(
     assert await page.title() == "Served by the proxy"
 
 
+async def test_proxy_should_allow_none_for_optional_settings(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    browser = await browser_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": None,
+            "password": None,
+            "bypass": None,
+        }
+    )
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
 async def test_should_use_proxy_for_second_page(
     browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
 ) -> None:
diff --git a/tests/async/test_request_continue.py b/tests/async/test_request_continue.py
index eb7dfbfda..b322d01fb 100644
--- a/tests/async/test_request_continue.py
+++ b/tests/async/test_request_continue.py
@@ -16,7 +16,7 @@
 from typing import Optional
 
 from playwright.async_api import Page, Route
-from tests.server import Server
+from tests.server import Server, TestServerRequest
 
 
 async def test_request_continue_should_work(page: Page, server: Server) -> None:
@@ -145,3 +145,52 @@ async def test_should_amend_binary_post_data(page: Page, server: Server) -> None
     )
     assert server_request.method == b"POST"
     assert server_request.post_body == b"\x00\x01\x02\x03\x04"
+
+
+async def test_continue_should_not_change_multipart_form_data_body(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/upload",
+        lambda context: (
+            context.write(b"done"),
+            context.setHeader("Content-Type", "text/plain"),
+            context.finish(),
+        ),
+    )
+
+    async def send_form_data() -> TestServerRequest:
+        req_task = asyncio.create_task(server.wait_for_request("/upload"))
+        status = await page.evaluate(
+            """async () => {
+            const newFile = new File(['file content'], 'file.txt');
+            const formData = new FormData();
+            formData.append('file', newFile);
+            const response = await fetch('/upload', {
+                method: 'POST',
+                credentials: 'include',
+                body: formData,
+            });
+            return response.status;
+        }"""
+        )
+        req = await req_task
+        assert status == 200
+        return req
+
+    req_before = await send_form_data()
+    await page.route("**/*", lambda route: route.continue_())
+    req_after = await send_form_data()
+
+    file_content = (
+        'Content-Disposition: form-data; name="file"; filename="file.txt"\r\n'
+        "Content-Type: application/octet-stream\r\n"
+        "\r\n"
+        "file content\r\n"
+        "------"
+    )
+    assert req_before.post_body
+    assert req_after.post_body
+    assert file_content in req_before.post_body.decode()
+    assert file_content in req_after.post_body.decode()
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..e764e3159 100644
--- a/tests/async/test_resource_timing.py
+++ b/tests/async/test_resource_timing.py
@@ -12,12 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
 
 import pytest
-from flaky import flaky
 
-from playwright.async_api import Browser, Page
+from playwright.async_api import Browser, Page, ResourceTiming
 from tests.server import Server
 
 
@@ -33,7 +31,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 +48,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:
@@ -98,7 +94,7 @@ def verify_timing_value(value: float, previous: float) -> None:
     assert value == -1 or value > 0 and value >= previous
 
 
-def verify_connections_timing_consistency(timing: Dict) -> None:
+def verify_connections_timing_consistency(timing: ResourceTiming) -> None:
     verify_timing_value(timing["domainLookupStart"], -1)
     verify_timing_value(timing["domainLookupEnd"], timing["domainLookupStart"])
     verify_timing_value(timing["connectStart"], timing["domainLookupEnd"])
diff --git a/tests/async/test_route_web_socket.py b/tests/async/test_route_web_socket.py
new file mode 100644
index 000000000..da6ce8757
--- /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],
+    server: Server,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    await target.goto(server.EMPTY_PAGE)
+    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": server.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, "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(server.EMPTY_PAGE)
+    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, "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, "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, "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(server.EMPTY_PAGE)
+    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_screencast.py b/tests/async/test_screencast.py
new file mode 100644
index 000000000..5532f7847
--- /dev/null
+++ b/tests/async/test_screencast.py
@@ -0,0 +1,72 @@
+# 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 pytest
+
+from playwright.async_api import Page, ScreencastFrame
+from tests.server import Server
+
+
+async def test_should_expose_screencast_property(page: Page) -> None:
+    assert page.screencast is page.screencast
+
+
+async def test_start_should_deliver_frames_via_callback(
+    page: Page, server: Server
+) -> None:
+    received: list = []
+    event = asyncio.Event()
+
+    def on_frame(frame: ScreencastFrame) -> None:
+        received.append(frame["data"])
+        event.set()
+
+    await page.screencast.start(on_frame=on_frame)
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => document.body.style.backgroundColor = 'red'")
+    # Force a couple of paint cycles so engines that only emit on visual change
+    # still produce a frame. Mirrors upstream `ensureSomeFrames`.
+    for _ in range(3):
+        await page.evaluate(
+            "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+        )
+    await page.screenshot()
+    await asyncio.wait_for(event.wait(), timeout=10)
+    await page.screencast.stop()
+    assert len(received) >= 1
+    assert all(isinstance(d, bytes) and len(d) > 0 for d in received)
+
+
+async def test_starting_twice_should_throw(page: Page) -> None:
+    await page.screencast.start(on_frame=lambda f: None)
+    try:
+        with pytest.raises(Exception, match="already started"):
+            await page.screencast.start(on_frame=lambda f: None)
+    finally:
+        await page.screencast.stop()
+
+
+async def test_show_overlays_and_overlay_apis_should_not_throw(page: Page) -> None:
+    await page.screencast.start(on_frame=lambda f: None)
+    try:
+        await page.screencast.show_overlay("<div>hello</div>", duration=100)
+        await page.screencast.show_chapter("ch", description="desc", duration=100)
+        await page.screencast.hide_overlays()
+        await page.screencast.show_overlays()
+        await page.screencast.show_actions(duration=100, position="top-right")
+        await page.screencast.hide_actions()
+    finally:
+        await page.screencast.stop()
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 8575aabad..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,19 +60,27 @@ 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()
     await saved
     await page.context.close()
     assert os.path.exists(out_path)
+
+
+async def test_should_be_None_if_not_recording(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = await browser.new_page()
+    assert page.video is None
+    await page.close()
diff --git a/tests/async/test_websocket.py b/tests/async/test_websocket.py
index eb90f95d3..c4729a4a5 100644
--- a/tests/async/test_websocket.py
+++ b/tests/async/test_websocket.py
@@ -16,14 +16,13 @@
 from typing import Union
 
 import pytest
-from flaky import flaky
 
 from playwright.async_api import Error, Page, WebSocket
-from tests.conftest import WebSocketServerServer
-from tests.server import Server
+from tests.server import Server, WebSocketProtocol
 
 
-async def test_should_work(page: Page, ws_server: WebSocketServerServer) -> None:
+async def test_should_work(page: Page, server: Server) -> None:
+    server.send_on_web_socket_connection(b"incoming")
     value = await page.evaluate(
         """port => {
         let cb;
@@ -32,39 +31,42 @@ async def test_should_work(page: Page, ws_server: WebSocketServerServer) -> None
         ws.addEventListener('message', data => { ws.close(); cb(data.data); });
         return result;
     }""",
-        ws_server.PORT,
+        server.PORT,
     )
     assert value == "incoming"
     pass
 
 
-async def test_should_emit_close_events(
-    page: Page, ws_server: WebSocketServerServer
-) -> None:
+async def test_should_emit_close_events(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    close_future: asyncio.Future[None] = asyncio.Future()
     async with page.expect_websocket() as ws_info:
         await page.evaluate(
             """port => {
-            let cb;
-            const result = new Promise(f => cb = f);
             const ws = new WebSocket('ws://localhost:' + port + '/ws');
-            ws.addEventListener('message', data => { ws.close(); cb(data.data); });
-            return result;
+            ws.addEventListener('open', data => ws.close());
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
     ws = await ws_info.value
-    assert ws.url == f"ws://localhost:{ws_server.PORT}/ws"
+    ws.on("close", lambda ws: close_future.set_result(None))
+    assert ws.url == f"ws://localhost:{server.PORT}/ws"
     assert repr(ws) == f"<WebSocket url={ws.url!r}>"
-    if not ws.is_closed():
-        await ws.wait_for_event("close")
+    await close_future
     assert ws.is_closed()
 
 
-async def test_should_emit_frame_events(
-    page: Page, ws_server: WebSocketServerServer
-) -> None:
+async def test_should_emit_frame_events(page: Page, server: Server) -> None:
+    def _handle_ws_connection(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendMessage(b"incoming", False)
+            ws.sendClose()
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws_connection)
     log = []
-    socke_close_future: "asyncio.Future[None]" = asyncio.Future()
+    socket_close_future: "asyncio.Future[None]" = asyncio.Future()
 
     def on_web_socket(ws: WebSocket) -> None:
         log.append("open")
@@ -83,7 +85,7 @@ def _on_framereceived(payload: Union[bytes, str]) -> None:
 
         def _handle_close(ws: WebSocket) -> None:
             log.append("close")
-            socke_close_future.set_result(None)
+            socket_close_future.set_result(None)
 
         ws.on("close", _handle_close)
 
@@ -95,18 +97,30 @@ def _handle_close(ws: WebSocket) -> None:
             ws.addEventListener('open', () => ws.send('outgoing'));
             ws.addEventListener('message', () => ws.close())
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
-    await socke_close_future
+    await socket_close_future
     assert log[0] == "open"
     assert log[3] == "close"
     log.sort()
     assert log == ["close", "open", "received<incoming>", "sent<outgoing>"]
 
 
-async def test_should_emit_binary_frame_events(
-    page: Page, ws_server: WebSocketServerServer
-) -> None:
+async def test_should_emit_binary_frame_events(page: Page, server: Server) -> None:
+    def _handle_ws_connection(ws: WebSocketProtocol) -> None:
+        ws.sendMessage(b"incoming")
+
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            if payload == b"echo-bin":
+                ws.sendMessage(b"\x04\x02", True)
+                ws.sendClose()
+            if payload == b"echo-text":
+                ws.sendMessage(b"text", False)
+                ws.sendClose()
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws_connection)
     done_task: "asyncio.Future[None]" = asyncio.Future()
     sent = []
     received = []
@@ -129,23 +143,23 @@ def on_web_socket(ws: WebSocket) -> None:
                 ws.send('echo-bin');
             });
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
     await done_task
     assert sent == [b"\x00\x01\x02\x03\x04", "echo-bin"]
     assert received == ["incoming", b"\x04\x02"]
 
 
-@flaky
 async def test_should_reject_wait_for_event_on_close_and_error(
-    page: Page, ws_server: WebSocketServerServer
+    page: Page, server: Server
 ) -> None:
+    server.send_on_web_socket_connection(b"incoming")
     async with page.expect_event("websocket") as ws_info:
         await page.evaluate(
             """port => {
             window.ws = new WebSocket('ws://localhost:' + port + '/ws');
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
     ws = await ws_info.value
     await ws.wait_for_event("framereceived")
@@ -156,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()
 
@@ -178,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 d5e9226f1..d12a065c0 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,9 +19,10 @@
 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 _pytest.terminal import TerminalReporter
 from PIL import Image
 from pixelmatch import pixelmatch
 from pixelmatch.contrib.PIL import from_PIL_to_raw_data
@@ -30,24 +30,22 @@
 import playwright
 from playwright._impl._path_utils import get_file_dirname
 
-from .server import Server, WebSocketServerServer, test_server
+from .server import Server, test_server
 
 _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 +58,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
@@ -76,13 +76,8 @@ def https_server() -> Generator[Server, None, None]:
     yield test_server.https_server
 
 
-@pytest.fixture
-def ws_server() -> Generator[WebSocketServerServer, None, None]:
-    yield test_server.ws_server
-
-
 @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()
@@ -104,6 +99,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"
@@ -261,6 +264,25 @@ def kill(self) -> None:
         self.process.wait()
 
 
+_failed_node_ids: List[str] = []
+
+
+def pytest_runtest_logreport(report: pytest.TestReport) -> None:
+    if report.failed and report.when in ("setup", "call"):
+        if report.nodeid not in _failed_node_ids:
+            _failed_node_ids.append(report.nodeid)
+
+
+def pytest_terminal_summary(
+    terminalreporter: TerminalReporter, exitstatus: int, config: pytest.Config
+) -> None:
+    if not _failed_node_ids:
+        return
+    terminalreporter.write_sep("=", "Failed tests", red=True, bold=True)
+    for index, nodeid in enumerate(_failed_node_ids, 1):
+        terminalreporter.write_line(f"  {index}) {nodeid}", red=True)
+
+
 @pytest.fixture
 def launch_server(
     browser_name: str, launch_arguments: Dict, tmp_path: Path
diff --git a/tests/server.py b/tests/server.py
index 06e344653..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
@@ -27,16 +28,20 @@
     Dict,
     Generator,
     Generic,
+    List,
     Optional,
     Set,
     Tuple,
     TypeVar,
+    Union,
     cast,
 )
 from urllib.parse import urlparse
 
+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
@@ -81,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:
@@ -91,6 +95,10 @@ def process(self) -> None:
             )
             server.request_subscribers.pop(path)
 
+        if path == "/ws":
+            server._ws_resource.render(self)
+            return
+
         if server.auth.get(path):
             authorization_header = self.requestHeaders.getRawHeaders("authorization")
             creds_correct = False
@@ -102,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):
@@ -109,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:
@@ -125,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()
 
 
@@ -161,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] = {}
@@ -171,10 +191,17 @@ def start(self) -> None:
         self.auth = auth
         self.csp = csp
         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
+        setattr(ws_factory, "server_instance", self)
+        self._ws_resource = WebSocketResource(ws_factory)
+
         self.listen(factory)
 
     async def wait_for_request(self, path: str) -> TestServerRequest:
@@ -184,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
@@ -198,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)
 
@@ -210,6 +256,7 @@ def reset(self) -> None:
         self.csp.clear()
         self.gzip_routes.clear()
         self.routes.clear()
+        self._ws_handlers.clear()
 
     def set_route(
         self, path: str, callback: Callable[[TestServerRequest], Any]
@@ -227,19 +274,44 @@ def handle_redirect(request: http.Request) -> None:
 
         self.set_route(from_, handle_redirect)
 
+    def send_on_web_socket_connection(self, data: bytes) -> None:
+        self.once_web_socket_connection(lambda ws: ws.sendMessage(data))
+
+    def once_web_socket_connection(
+        self, handler: Callable[["WebSocketProtocol"], None]
+    ) -> None:
+        self._ws_handlers.append(handler)
+
 
 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(
@@ -250,55 +322,52 @@ 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
 
-
-class WebSocketServerServer(WebSocketServerProtocol):
-    def __init__(self) -> None:
-        super().__init__()
-        self.PORT = find_free_port()
-
-    def start(self) -> None:
-        ws = WebSocketServerFactory("ws://127.0.0.1:" + str(self.PORT))
-        ws.protocol = WebSocketProtocol
-        reactor.listenTCP(self.PORT, ws)
+    def stop(self) -> None:
+        for listener in self._listeners:
+            listener.stopListening()
+        self._listeners.clear()
 
 
 class WebSocketProtocol(WebSocketServerProtocol):
-    def onConnect(self, request: Any) -> None:
-        pass
+    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:
-        self.sendMessage(b"incoming")
-
-    def onMessage(self, payload: bytes, isBinary: bool) -> None:
-        if payload == b"echo-bin":
-            self.sendMessage(b"\x04\x02", True)
-            self.sendClose()
-        if payload == b"echo-text":
-            self.sendMessage(b"text", False)
-            self.sendClose()
-        if payload == b"close":
-            self.sendClose()
-
-    def onClose(self, wasClean: Any, code: Any, reason: Any) -> None:
-        pass
+        for handler in getattr(self.factory, "server_instance")._ws_handlers.copy():
+            getattr(self.factory, "server_instance")._ws_handlers.remove(handler)
+            handler(self)
 
 
 class TestServer:
     def __init__(self) -> None:
         self.server = HTTPServer()
         self.https_server = HTTPSServer()
-        self.ws_server = WebSocketServerServer()
 
     def start(self) -> None:
         self.server.start()
         self.https_server.start()
-        self.ws_server.start()
         self.thread = threading.Thread(
             target=lambda: reactor.run(installSignalHandlers=False)
         )
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_add_init_script.py b/tests/sync/test_add_init_script.py
index e17fc5e8b..cd508cf4d 100644
--- a/tests/sync/test_add_init_script.py
+++ b/tests/sync/test_add_init_script.py
@@ -85,3 +85,11 @@ def test_should_work_with_trailing_comments(page: Page) -> None:
     page.add_init_script("window.secret = 42;")
     page.goto("data:text/html,<html></html>")
     assert page.evaluate("secret") == 42
+
+
+def test_add_init_script_returns_disposable(page: Page) -> None:
+    with page.add_init_script("window.injected = 123"):
+        page.goto("data:text/html,<script>window.result = window.injected</script>")
+        assert page.evaluate("window.result") == 123
+    page.goto("data:text/html,<script>window.result = window.injected</script>")
+    assert page.evaluate("window.result") is None
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_browser.py b/tests/sync/test_browser.py
index ded881c67..2551571da 100644
--- a/tests/sync/test_browser.py
+++ b/tests/sync/test_browser.py
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Dict
+
 from playwright.sync_api import Browser, BrowserType
 
 
@@ -19,3 +21,17 @@ def test_should_return_browser_type(
     browser: Browser, browser_type: BrowserType
 ) -> None:
     assert browser.browser_type is browser_type
+
+
+def test_bind_should_return_endpoint_and_allow_unbind(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = browser_type.launch(**launch_arguments)
+    try:
+        result = browser.bind("test-server")
+        assert "endpoint" in result
+        assert isinstance(result["endpoint"], str)
+        assert len(result["endpoint"]) > 0
+        browser.unbind()
+    finally:
+        browser.close()
diff --git a/tests/sync/test_browsercontext_client_certificates.py b/tests/sync/test_browsercontext_client_certificates.py
new file mode 100644
index 000000000..7a6d4f8cf
--- /dev/null
+++ b/tests/sync/test_browsercontext_client_certificates.py
@@ -0,0 +1,258 @@
+# 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 sys
+import threading
+from pathlib import Path
+from typing import Dict, Generator, Optional, cast
+
+import OpenSSL.crypto
+import OpenSSL.SSL
+import pytest
+from twisted.internet import reactor as _twisted_reactor
+from twisted.internet import ssl
+from twisted.internet.selectreactor import SelectReactor
+from twisted.web import resource, server
+from twisted.web.http import Request
+
+from playwright.sync_api import Browser, BrowserType, Playwright, expect
+
+reactor = cast(SelectReactor, _twisted_reactor)
+
+
+@pytest.fixture(scope="function", autouse=True)
+def _skip_webkit_darwin(browser_name: str) -> None:
+    if browser_name == "webkit" and sys.platform == "darwin":
+        pytest.skip("WebKit does not proxy localhost on macOS")
+
+
+class HttpsResource(resource.Resource):
+    serverCertificate: ssl.PrivateCertificate
+    isLeaf = True
+
+    def _verify_cert_chain(self, cert: Optional[OpenSSL.crypto.X509]) -> bool:
+        if not cert:
+            return False
+        store = OpenSSL.crypto.X509Store()
+        store.add_cert(self.serverCertificate.original)
+        store_ctx = OpenSSL.crypto.X509StoreContext(store, cert)
+        try:
+            store_ctx.verify_certificate()
+            return True
+        except OpenSSL.crypto.X509StoreContextError:
+            return False
+
+    def render_GET(self, request: Request) -> bytes:
+        tls_socket: OpenSSL.SSL.Connection = request.transport.getHandle()  # type: ignore
+        cert = tls_socket.get_peer_certificate()
+        parts = []
+
+        if self._verify_cert_chain(cert):
+            request.setResponseCode(200)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Hello {cert.get_subject().CN}, your certificate was issued by {cert.get_issuer().CN}!",  # type: ignore
+                }
+            )
+        elif cert and cert.get_subject():
+            request.setResponseCode(403)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Sorry {cert.get_subject().CN}, certificates from {cert.get_issuer().CN} are not welcome here.",
+                }
+            )
+        else:
+            request.setResponseCode(401)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": "Sorry, but you need to provide a client certificate to continue.",
+                }
+            )
+        return b"".join(
+            [
+                f'<div data-testid="{part["key"]}">{part["value"]}</div>'.encode()
+                for part in parts
+            ]
+        )
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _client_certificate_server(assetdir: Path) -> Generator[None, None, None]:
+    certAuthCert = ssl.Certificate.loadPEM(
+        (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+    serverCert = ssl.PrivateCertificate.loadPEM(
+        (assetdir / "client-certificates/server/server_key.pem").read_text()
+        + (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+
+    contextFactory = serverCert.options(certAuthCert)
+    contextFactory.requireCertificate = False
+    resource = HttpsResource()
+    resource.serverCertificate = serverCert
+    site = server.Site(resource)
+
+    def _run() -> None:
+        reactor.listenSSL(8000, site, contextFactory)
+
+    thread = threading.Thread(target=_run)
+    thread.start()
+    yield
+    thread.join()
+
+
+def test_should_throw_with_untrusted_client_certs(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    serverURL = "https://localhost:8000/"
+    request = playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": serverURL,
+                "certPath": assetdir
+                / "client-certificates/client/self-signed/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/self-signed/key.pem",
+            }
+        ],
+    )
+    with pytest.raises(Exception, match="alert unknown ca"):
+        request.get(serverURL)
+    request.dispose()
+
+
+def test_should_work_with_new_context(browser: Browser, assetdir: Path) -> None:
+    context = browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = page.context.request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    context.close()
+
+
+def test_should_work_with_new_context_passing_as_content(
+    browser: Browser, assetdir: Path
+) -> None:
+    context = browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "cert": (
+                    assetdir / "client-certificates/client/trusted/cert.pem"
+                ).read_bytes(),
+                "key": (
+                    assetdir / "client-certificates/client/trusted/key.pem"
+                ).read_bytes(),
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = page.context.request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    context.close()
+
+
+def test_should_work_with_new_persistent_context(
+    browser_type: BrowserType, assetdir: Path, launch_arguments: Dict
+) -> None:
+    context = browser_type.launch_persistent_context(
+        "",
+        **launch_arguments,
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+    context.close()
+
+
+def test_should_work_with_global_api_request_context(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    request = playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    response = request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    request.dispose()
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_debugger.py b/tests/sync/test_debugger.py
new file mode 100644
index 000000000..c6be1ec89
--- /dev/null
+++ b/tests/sync/test_debugger.py
@@ -0,0 +1,20 @@
+# 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 BrowserContext
+
+
+def test_should_expose_debugger_property(context: BrowserContext) -> None:
+    assert context.debugger is context.debugger
+    assert context.debugger.paused_details is None
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_browser_context.py b/tests/sync/test_fetch_browser_context.py
index dd10d5adf..e4d880631 100644
--- a/tests/sync/test_fetch_browser_context.py
+++ b/tests/sync/test_fetch_browser_context.py
@@ -89,8 +89,43 @@ def test_should_support_query_params(
         getattr(context.request, method)(
             server.EMPTY_PAGE + "?p1=foo", params=expected_params
         )
-    assert server_req.value.args["p1".encode()][0].decode() == "v1"
-    assert len(server_req.value.args["p1".encode()]) == 1
+    assert list(map(lambda x: x.decode(), server_req.value.args["p1".encode()])) == [
+        "foo",
+        "v1",
+    ]
+    assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_params_passed_as_object(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = {
+        "param1": "value1",
+        "парам2": "знач2",
+    }
+    with server.expect_request("/empty.html") as server_req:
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params)
+    assert server_req.value.args["param1".encode()][0].decode() == "value1"
+    assert len(server_req.value.args["param1".encode()]) == 1
+    assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_params_passed_as_strings(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = "?param1=value1&param1=value2&парам2=знач2"
+    with server.expect_request("/empty.html") as server_req:
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params)
+    assert list(
+        map(lambda x: x.decode(), server_req.value.args["param1".encode()])
+    ) == ["value1", "value2"]
+    assert len(server_req.value.args["param1".encode()]) == 2
     assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
 
 
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..6b89b79a8 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
 
@@ -90,37 +90,8 @@ def test_browser_close_should_be_callable_twice(
     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,
+def test_browser_type_launch_should_accept_ignore_default_args_false(
+    browser_type: BrowserType, 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
+    browser = browser_type.launch(**launch_arguments, ignore_default_args=False)
+    browser.close()
diff --git a/tests/sync/test_locators.py b/tests/sync/test_locators.py
index 07509e10e..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")
@@ -356,7 +362,7 @@ def test_locators_should_select_textarea(
     textarea = page.locator("textarea")
     textarea.evaluate("textarea => textarea.value = 'some value'")
     textarea.select_text()
-    textarea.select_text(timeout=1_000)
+    textarea.select_text(timeout=25_000)
     if browser_name == "firefox" or browser_name == "webkit":
         assert textarea.evaluate("el => el.selectionStart") == 0
         assert textarea.evaluate("el => el.selectionEnd") == 10
@@ -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 e4ba14462..7a2b6a438 100644
--- a/tests/sync/test_page_add_locator_handler.py
+++ b/tests/sync/test_page_add_locator_handler.py
@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 import pytest
 
-from playwright.sync_api import Error, Page, expect
+from playwright.sync_api import Error, Locator, Page, expect
 from tests.server import Server
 from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
@@ -25,16 +26,17 @@ def test_should_work(page: Page, server: Server) -> None:
     before_count = 0
     after_count = 0
 
-    def handler() -> None:
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    def handler(locator: Locator) -> None:
+        assert locator == original_locator
         nonlocal before_count
         nonlocal after_count
         before_count += 1
         page.locator("#close").click()
         after_count += 1
 
-    page.add_locator_handler(
-        page.locator("text=This interstitial covers the button"), handler
-    )
+    page.add_locator_handler(original_locator, handler)
 
     for args in [
         ["mouseover", 1],
@@ -70,7 +72,7 @@ def handler() -> None:
         if page.get_by_text("This interstitial covers the button").is_visible():
             page.locator("#close").click()
 
-    page.add_locator_handler(page.locator("body"), handler)
+    page.add_locator_handler(page.locator("body"), handler, no_wait_after=True)
 
     for args in [
         ["mouseover", 2],
@@ -152,7 +154,7 @@ def handler() -> None:
         # Deliberately timeout.
         try:
             page.wait_for_timeout(9999999)
-        except Error:
+        except Exception:
             pass
 
     page.add_locator_handler(
@@ -195,3 +197,190 @@ def handler() -> None:
     expect(page.locator("#target")).to_be_visible()
     expect(page.locator("#interstitial")).not_to_be_visible()
     assert called == 1
+
+
+def test_should_work_when_owner_frame_detaches(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """
+    () => {
+        const iframe = document.createElement('iframe');
+        iframe.src = 'data:text/html,<body>hello from iframe</body>';
+        document.body.append(iframe);
+
+        const target = document.createElement('button');
+        target.textContent = 'Click me';
+        target.id = 'target';
+        target.addEventListener('click', () => window._clicked = true);
+        document.body.appendChild(target);
+
+        const closeButton = document.createElement('button');
+        closeButton.textContent = 'close';
+        closeButton.id = 'close';
+        closeButton.addEventListener('click', () => iframe.remove());
+        document.body.appendChild(closeButton);
+    }
+    """
+    )
+    page.add_locator_handler(
+        page.frame_locator("iframe").locator("body"),
+        lambda: page.locator("#close").click(),
+    )
+    page.locator("#target").click()
+    assert page.query_selector("iframe") is None
+    assert page.evaluate("window._clicked") is True
+
+
+def test_should_work_with_times_option(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    page.add_locator_handler(
+        page.locator("body"), _handler, no_wait_after=True, times=2
+    )
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('mouseover', 4);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        page.locator("#target").click(timeout=3000)
+    assert called == 2
+    assert page.evaluate("window.clicked") == 0
+    expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in exc_info.value.message
+    assert (
+        '<div>This interstitial covers the button</div> from <div class="visible" id="interstitial">…</div> subtree intercepts pointer events'
+        in exc_info.value.message
+    )
+
+
+def test_should_wait_for_hidden_by_default(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        button.click()
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+def test_should_wait_for_hidden_by_default_2(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        page.locator("#target").click(timeout=3000)
+    assert page.evaluate("window.clicked") == 0
+    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'
+        in exc_info.value.message
+    )
+
+
+def test_should_work_with_noWaitAfter(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        if called == 1:
+            button.click()
+        else:
+            page.locator("#interstitial").wait_for(state="hidden")
+
+    page.add_locator_handler(
+        page.get_by_role("button", name="close"), _handler, no_wait_after=True
+    )
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 2
+
+
+def test_should_removeLocatorHandler(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(locator: Locator) -> None:
+        nonlocal called
+        called += 1
+        locator.click()
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert called == 1
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    page.remove_locator_handler(page.get_by_role("button", name="close"))
+    with pytest.raises(Error) as error:
+        page.locator("#target").click(timeout=3000)
+    assert called == 1
+    assert page.evaluate("window.clicked") == 0
+    expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in error.value.message
diff --git a/tests/sync/test_page_aria_snapshot.py b/tests/sync/test_page_aria_snapshot.py
new file mode 100644
index 000000000..b2e3d81ca
--- /dev/null
+++ b/tests/sync/test_page_aria_snapshot.py
@@ -0,0 +1,233 @@
+# 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=/
+      """,
+    )
+
+
+def test_should_snapshot_with_depth(page: Page) -> None:
+    page.set_content("<ul><li><a href=about:blank>link</a></li></ul>")
+    snapshot = page.locator("body").aria_snapshot(depth=1)
+    assert "listitem" in snapshot
+    assert "/url" not in snapshot
+
+
+def test_page_aria_snapshot_should_work(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    snapshot = page.aria_snapshot()
+    assert _unshift(snapshot) == _unshift(
+        """
+      - heading "title" [level=1]
+    """
+    )
diff --git a/tests/sync/test_page_clock.py b/tests/sync/test_page_clock.py
new file mode 100644
index 000000000..72d5e5a3e
--- /dev/null
+++ b/tests/sync/test_page_clock.py
@@ -0,0 +1,470 @@
+# 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 datetime
+from typing import Any, Generator, List
+
+import pytest
+
+from playwright.sync_api import Error, Page
+from tests.server import Server
+
+
+@pytest.fixture(autouse=True)
+def calls(page: Page) -> List[Any]:
+    calls: List[Any] = []
+    page.expose_function("stub", lambda *args: calls.append(list(args)))
+    return calls
+
+
+class TestRunFor:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1000)
+        yield
+
+    def test_run_for_triggers_immediately_without_specified_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub)")
+        page.clock.run_for(0)
+        assert len(calls) == 1
+
+    def test_run_for_does_not_trigger_without_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100)")
+        page.clock.run_for(10)
+        assert len(calls) == 0
+
+    def test_run_for_triggers_after_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100)")
+        page.clock.run_for(100)
+        assert len(calls) == 1
+
+    def test_run_for_triggers_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100); setTimeout(window.stub, 100)")
+        page.clock.run_for(100)
+        assert len(calls) == 2
+
+    def test_run_for_triggers_multiple_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100); setTimeout(window.stub, 99); setTimeout(window.stub, 100)"
+        )
+        page.clock.run_for(100)
+        assert len(calls) == 4
+
+    def test_run_for_waits_after_setTimeout_was_called(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 150)")
+        page.clock.run_for(50)
+        assert len(calls) == 0
+        page.clock.run_for(100)
+        assert len(calls) == 1
+
+    def test_run_for_triggers_event_when_some_throw(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(() => { throw new Error(); }, 100); setTimeout(window.stub, 120)"
+        )
+        with pytest.raises(Error):
+            page.clock.run_for(120)
+        assert len(calls) == 1
+
+    def test_run_for_creates_updated_Date_while_ticking(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.set_system_time(0)
+        page.evaluate("setInterval(() => { window.stub(new Date().getTime()); }, 10)")
+        page.clock.run_for(100)
+        assert calls == [
+            [10],
+            [20],
+            [30],
+            [40],
+            [50],
+            [60],
+            [70],
+            [80],
+            [90],
+            [100],
+        ]
+
+    def test_run_for_passes_8_seconds(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 4000)")
+        page.clock.run_for("08")
+        assert len(calls) == 2
+
+    def test_run_for_passes_1_minute(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 6000)")
+        page.clock.run_for("01:00")
+        assert len(calls) == 10
+
+    def test_run_for_passes_2_hours_34_minutes_and_10_seconds(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setInterval(window.stub, 10000)")
+        page.clock.run_for("02:34:10")
+        assert len(calls) == 925
+
+    def test_run_for_throws_for_invalid_format(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setInterval(window.stub, 10000)")
+        with pytest.raises(Error):
+            page.clock.run_for("12:02:34:10")
+        assert len(calls) == 0
+
+    def test_run_for_returns_the_current_now_value(self, page: Page) -> None:
+        page.clock.set_system_time(0)
+        value = 200
+        page.clock.run_for(value)
+        assert page.evaluate("Date.now()") == value
+
+
+class TestFastForward:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        yield
+
+    def test_ignores_timers_which_wouldnt_be_run(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(() => { window.stub('should not be logged'); }, 1000)"
+        )
+        page.clock.fast_forward(500)
+        assert len(calls) == 0
+
+    def test_pushes_back_execution_time_for_skipped_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(() => { window.stub(Date.now()); }, 1000)")
+        page.clock.fast_forward(2000)
+        assert calls == [[1000 + 2000]]
+
+    def test_supports_string_time_arguments(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            "setTimeout(() => { window.stub(Date.now()); }, 100000)"
+        )  # 100000 = 1:40
+        page.clock.fast_forward("01:50")
+        assert calls == [[1000 + 110000]]
+
+
+class TestStubTimers:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        yield
+
+    def test_sets_initial_timestamp(self, page: Page) -> None:
+        page.clock.set_system_time(1.4)
+        assert page.evaluate("Date.now()") == 1400
+
+    def test_replaces_global_setTimeout(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setTimeout(window.stub, 1000)")
+        page.clock.run_for(1000)
+        assert len(calls) == 1
+
+    def test_global_fake_setTimeout_should_return_id(self, page: Page) -> None:
+        to = page.evaluate("setTimeout(window.stub, 1000)")
+        assert isinstance(to, int)
+
+    def test_replaces_global_clearTimeout(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            """
+            const to = setTimeout(window.stub, 1000);
+            clearTimeout(to);
+        """
+        )
+        page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    def test_replaces_global_setInterval(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 500)")
+        page.clock.run_for(1000)
+        assert len(calls) == 2
+
+    def test_replaces_global_clearInterval(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            """
+            const to = setInterval(window.stub, 500);
+            clearInterval(to);
+        """
+        )
+        page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    def test_replaces_global_performance_now(self, page: Page) -> None:
+        page.evaluate(
+            """() => {
+            window.waitForPromise = new Promise(async resolve => {
+                const prev = performance.now();
+                await new Promise(f => setTimeout(f, 1000));
+                const next = performance.now();
+                resolve({ prev, next });
+            });
+        }"""
+        )
+        page.clock.run_for(1000)
+        assert page.evaluate("window.waitForPromise") == {"prev": 1000, "next": 2000}
+
+    def test_fakes_Date_constructor(self, page: Page) -> None:
+        now = page.evaluate("new Date().getTime()")
+        assert now == 1000
+
+
+class TestStubTimersPerformance:
+    def test_replaces_global_performance_time_origin(self, page: Page) -> None:
+        page.clock.install(time=1)
+        page.clock.pause_at(2)
+        page.evaluate(
+            """() => {
+            window.waitForPromise = new Promise(async resolve => {
+                const prev = performance.now();
+                await new Promise(f => setTimeout(f, 1000));
+                const next = performance.now();
+                resolve({ prev, next });
+            });
+        }"""
+        )
+        page.clock.run_for(1000)
+        assert page.evaluate("performance.timeOrigin") == 1000
+        assert page.evaluate("window.waitForPromise") == {"prev": 1000, "next": 2000}
+
+
+class TestPopup:
+    def test_should_tick_after_popup(self, page: Page) -> None:
+        page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        page.clock.pause_at(now)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('about:blank')")
+        popup = popup_info.value
+        popup_time = popup.evaluate("Date.now()")
+        assert popup_time == now.timestamp() * 1000
+        page.clock.run_for(1000)
+        popup_time_after = popup.evaluate("Date.now()")
+        assert popup_time_after == now.timestamp() * 1000 + 1000
+
+    def test_should_tick_before_popup(self, page: Page) -> None:
+        page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        page.clock.pause_at(now)
+        page.clock.run_for(1000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('about:blank')")
+        popup = popup_info.value
+        popup_time = popup.evaluate("Date.now()")
+        assert popup_time == int(now.timestamp() * 1_000 + 1000)
+        assert datetime.datetime.fromtimestamp(popup_time / 1_000).year == 2015
+
+    def test_should_run_time_before_popup(self, page: Page, server: Server) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        page.wait_for_timeout(2000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html"))
+        popup = popup_info.value
+        popup_time = popup.evaluate("window.time")
+        assert popup_time >= 2000
+
+    def test_should_not_run_time_before_popup_on_pause(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        page.wait_for_timeout(2000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html"))
+        popup = popup_info.value
+        popup_time = popup.evaluate("window.time")
+        assert popup_time == 1000
+
+
+class TestSetFixedTime:
+    def test_allows_passing_as_int(self, page: Page) -> None:
+        page.clock.set_fixed_time(1)
+        assert page.evaluate("Date.now()") == 1000
+        page.clock.set_fixed_time(int(2))
+        assert page.evaluate("Date.now()") == 2000
+
+    def test_does_not_fake_methods(self, page: Page) -> None:
+        page.clock.set_fixed_time(0)
+        # Should not stall.
+        page.evaluate("new Promise(f => setTimeout(f, 1))")
+
+    def test_allows_setting_time_multiple_times(self, page: Page) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.set_fixed_time(0.2)
+        assert page.evaluate("Date.now()") == 200
+
+    def test_fixed_time_is_not_affected_by_clock_manipulation(self, page: Page) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.fast_forward(20)
+        assert page.evaluate("Date.now()") == 100
+
+    def test_allows_installing_fake_timers_after_setting_time(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.set_fixed_time(0.2)
+        page.evaluate("setTimeout(() => window.stub(Date.now()))")
+        page.clock.run_for(0)
+        assert calls == [[200]]
+
+
+class TestWhileRunning:
+    def test_should_progress_time(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.wait_for_timeout(1000)
+        now = page.evaluate("Date.now()")
+        assert 1000 <= now <= 2000
+
+    def test_should_run_for(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.run_for(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_fast_forward(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.fast_forward(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_fast_forward_to(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.fast_forward(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_pause(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        page.wait_for_timeout(1000)
+        now = page.evaluate("Date.now()")
+        assert 0 <= now <= 1000
+
+    def test_should_pause_and_fast_forward(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        page.clock.fast_forward(1000)
+        now = page.evaluate("Date.now()")
+        assert now == 2000
+
+    def test_should_set_system_time_on_pause(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        now = page.evaluate("Date.now()")
+        assert now == 1000
+
+
+class TestWhileOnPause:
+    def test_fast_forward_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        page.clock.fast_forward(1000)
+        assert calls == [["outer"]]
+        page.clock.fast_forward(1)
+        assert calls == [["outer"], ["inner"]]
+
+    def test_run_for_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
+
+    def test_run_for_should_not_run_nested_immediate_from_microtask(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                void Promise.resolve().then(() => setTimeout(() => window.stub('inner'), 0));
+            }, 1000);
+        """
+        )
+        page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
diff --git a/tests/sync/test_page_event_console.py b/tests/sync/test_page_event_console.py
new file mode 100644
index 000000000..34dd192e4
--- /dev/null
+++ b/tests/sync/test_page_event_console.py
@@ -0,0 +1,49 @@
+# 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"
+
+
+def test_should_have_a_timestamp(page: Page) -> None:
+    with page.expect_console_message() as message_info:
+        page.evaluate("() => console.log('hello')")
+    assert message_info.value.timestamp > 0
+
+
+def test_clear_console_messages_should_drop_buffered_messages(page: Page) -> None:
+    page.evaluate("() => console.log('first')")
+    assert any(m.text == "first" for m in page.console_messages())
+    page.clear_console_messages()
+    assert not any(m.text == "first" for m in page.console_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_network_response.py b/tests/sync/test_page_network_response.py
index 4f4213d0d..7e11f4501 100644
--- a/tests/sync/test_page_network_response.py
+++ b/tests/sync/test_page_network_response.py
@@ -64,3 +64,9 @@ def handle_get(request: http.Request) -> None:
         page_response.finished()
     error = exc_info.value
     assert "closed" in error.message
+
+
+def test_should_return_http_version(page: Page, server: Server) -> None:
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.http_version() in ("HTTP/1.0", "HTTP/1.1", "HTTP/2.0")
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..1c6efab6a 100644
--- a/tests/sync/test_resource_timing.py
+++ b/tests/sync/test_resource_timing.py
@@ -12,12 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
-
 import pytest
-from flaky import flaky
 
-from playwright.sync_api import Browser, Page
+from playwright.sync_api import Browser, Page, ResourceTiming
 from tests.server import Server
 
 
@@ -33,7 +30,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 +47,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:
@@ -102,7 +97,7 @@ def verify_timing_value(value: float, previous: float) -> None:
     assert value == -1 or value > 0 and value >= previous
 
 
-def verify_connections_timing_consistency(timing: Dict) -> None:
+def verify_connections_timing_consistency(timing: ResourceTiming) -> None:
     verify_timing_value(timing["domainLookupStart"], -1)
     verify_timing_value(timing["domainLookupEnd"], timing["domainLookupStart"])
     verify_timing_value(timing["connectStart"], timing["domainLookupEnd"])
diff --git a/tests/sync/test_route_web_socket.py b/tests/sync/test_route_web_socket.py
new file mode 100644
index 000000000..6d9eb09a6
--- /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],
+    server: Server,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    target.goto(server.EMPTY_PAGE)
+    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": server.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, "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(server.EMPTY_PAGE)
+    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, "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, "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, "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(server.EMPTY_PAGE)
+    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_screencast.py b/tests/sync/test_screencast.py
new file mode 100644
index 000000000..0dcd30530
--- /dev/null
+++ b/tests/sync/test_screencast.py
@@ -0,0 +1,53 @@
+# 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 time
+
+import pytest
+
+from playwright.sync_api import Page
+from tests.server import Server
+
+
+def test_should_expose_screencast_property(page: Page) -> None:
+    assert page.screencast is page.screencast
+
+
+def test_start_should_deliver_frames_via_callback(page: Page, server: Server) -> None:
+    received: list = []
+    page.screencast.start(on_frame=lambda f: received.append(f["data"]))
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate("() => document.body.style.backgroundColor = 'red'")
+    # Force a couple of paint cycles so engines that only emit on visual change
+    # still produce a frame. Mirrors upstream `ensureSomeFrames`.
+    for _ in range(3):
+        page.evaluate(
+            "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+        )
+    page.screenshot()
+    deadline = time.time() + 10
+    while not received and time.time() < deadline:
+        page.wait_for_timeout(100)
+    page.screencast.stop()
+    assert len(received) >= 1
+    assert all(isinstance(d, bytes) and len(d) > 0 for d in received)
+
+
+def test_starting_twice_should_throw(page: Page) -> None:
+    page.screencast.start(on_frame=lambda f: None)
+    try:
+        with pytest.raises(Exception, match="already started"):
+            page.screencast.start(on_frame=lambda f: None)
+    finally:
+        page.screencast.stop()
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_unroute_behavior.py b/tests/sync/test_unroute_behavior.py
index 12ae9e22d..f37146582 100644
--- a/tests/sync/test_unroute_behavior.py
+++ b/tests/sync/test_unroute_behavior.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from playwright.sync_api import BrowserContext, Page
+from playwright.sync_api import BrowserContext, Page, Route
 from tests.server import Server
 from tests.utils import must
 
@@ -44,3 +44,18 @@ def test_page_unroute_all_removes_all_routes(page: Page, server: Server) -> None
     page.unroute_all()
     response = must(page.goto(server.EMPTY_PAGE))
     assert response.ok
+
+
+def test_page_route_returns_disposable(page: Page, server: Server) -> None:
+    intercepted: list = []
+
+    def handler(route: Route) -> None:
+        intercepted.append(route.request.url)
+        route.continue_()
+
+    with page.route("**/*", handler):
+        page.goto(server.EMPTY_PAGE)
+        assert any(server.EMPTY_PAGE in url for url in intercepted)
+    intercepted.clear()
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == []
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 4a9faf9a1..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"
 
@@ -65,3 +22,14 @@ def get_trace_actions(events: List[Any]) -> List[str]:
 def must(value: Optional[MustType]) -> MustType:
     assert value
     return value
+
+
+def chromium_version_less_than(a: str, b: str) -> bool:
+    left = list(map(int, a.split(".")))
+    right = list(map(int, b.split(".")))
+    for i in range(4):
+        if left[i] > right[i]:
+            return False
+        if left[i] < right[i]:
+            return True
+    return False
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.focal b/utils/docker/Dockerfile.noble
similarity index 85%
rename from utils/docker/Dockerfile.focal
rename to utils/docker/Dockerfile.noble
index 247b58b49..2458236a3 100644
--- a/utils/docker/Dockerfile.focal
+++ b/utils/docker/Dockerfile.noble
@@ -1,14 +1,20 @@
-FROM ubuntu:focal
+FROM ubuntu:noble
 
 ARG DEBIAN_FRONTEND=noninteractive
 ARG TZ=America/Los_Angeles
-ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-focal"
+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 && \
     # Install Python
-    apt-get install -y python3 python3-distutils curl && \
+    apt-get install -y python3 curl && \
+    # Align with upstream Python image and don't be externally managed:
+    # https://github.com/docker-library/python/issues/948
+    rm /usr/lib/python3.12/EXTERNALLY-MANAGED && \
     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 && \
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 2b4e73a53..3af48306b 100755
--- a/utils/docker/publish_docker.sh
+++ b/utils/docker/publish_docker.sh
@@ -15,35 +15,22 @@ if [[ "${RELEASE_CHANNEL}" == "stable" ]]; then
     echo "ERROR: cannot publish stable docker with Playwright version '${PW_VERSION}'"
     exit 1
   fi
-elif [[ "${RELEASE_CHANNEL}" == "canary" ]]; then
-  if [[ "${PW_VERSION}" != *dev* ]]; then
-    echo "ERROR: cannot publish canary docker with Playwright version '${PW_VERSION}'"
-    exit 1
-  fi
 else
   echo "ERROR: unknown release channel - ${RELEASE_CHANNEL}"
   echo "Must be either 'stable' or 'canary'"
   exit 1
 fi
 
-FOCAL_TAGS=(
-  "next-focal"
+# Ubuntu 22.04
+JAMMY_TAGS=(
+  "v${PW_VERSION}-jammy"
 )
-if [[ "$RELEASE_CHANNEL" == "stable" ]]; then
-  FOCAL_TAGS+=("focal")
-  FOCAL_TAGS+=("v${PW_VERSION}-focal")
-fi
 
-JAMMY_TAGS=(
-  "next"
-  "next-jammy"
+# Ubuntu 24.04
+NOBLE_TAGS=(
+  "v${PW_VERSION}"
+  "v${PW_VERSION}-noble"
 )
-if [[ "$RELEASE_CHANNEL" == "stable" ]]; then
-  JAMMY_TAGS+=("latest")
-  JAMMY_TAGS+=("jammy")
-  JAMMY_TAGS+=("v${PW_VERSION}-jammy")
-  JAMMY_TAGS+=("v${PW_VERSION}")
-fi
 
 tag_and_push() {
   local source="$1"
@@ -77,12 +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"
@@ -103,12 +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
 
@@ -127,12 +114,11 @@ 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
 publish_docker_manifest jammy amd64 arm64
+
+publish_docker_images_with_arch_suffix noble amd64
+publish_docker_images_with_arch_suffix noble arm64
+publish_docker_manifest noble amd64 arm64