diff --git a/README.md b/README.md
index c5e2d70b0..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 -->145.0.7632.6<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->146.0.1<!-- 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/playwright/_impl/_api_structures.py b/playwright/_impl/_api_structures.py
index c0d0ee442..b7674b07e 100644
--- a/playwright/_impl/_api_structures.py
+++ b/playwright/_impl/_api_structures.py
@@ -214,7 +214,7 @@ class FrameExpectOptions(TypedDict, total=False):
     timeout: Optional[float]
 
 
-class FrameExpectResult(TypedDict):
+class FrameExpectResult(TypedDict, total=False):
     matches: bool
     received: Any
     log: List[str]
@@ -307,7 +307,26 @@ class FrameExpectResult(TypedDict):
 ]
 
 
-class TracingGroupLocation(TypedDict):
+class TracingGroupLocation(TypedDict, total=False):
     file: str
     line: Optional[int]
     column: Optional[int]
+
+
+class BindResult(TypedDict):
+    endpoint: str
+
+
+class PausedDetailsLocation(TypedDict, total=False):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class PausedDetails(TypedDict):
+    location: PausedDetailsLocation
+    title: str
+
+
+class OnFrame(TypedDict):
+    data: bytes
diff --git a/playwright/_impl/_browser.py b/playwright/_impl/_browser.py
index 5a9a87450..ab8a78c32 100644
--- a/playwright/_impl/_browser.py
+++ b/playwright/_impl/_browser.py
@@ -27,6 +27,7 @@
 )
 
 from playwright._impl._api_structures import (
+    BindResult,
     ClientCertificate,
     Geolocation,
     HttpCredentials,
@@ -240,6 +241,19 @@ async def close(self, reason: str = None) -> None:
             if not is_target_closed_error(e):
                 raise e
 
+    async def bind(
+        self,
+        title: str,
+        workspaceDir: str = None,
+        host: str = None,
+        port: int = None,
+    ) -> BindResult:
+        params = locals_to_params(locals())
+        return await self._channel.send("startServer", None, params)
+
+    async def unbind(self) -> None:
+        await self._channel.send("stopServer", None)
+
     @property
     def version(self) -> str:
         return self._initializer["version"]
diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
index e27a9437a..eb5d6e245 100644
--- a/playwright/_impl/_browser_context.py
+++ b/playwright/_impl/_browser_context.py
@@ -46,7 +46,9 @@
     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
@@ -122,6 +124,7 @@ def __init__(
         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 = from_channel(initializer["debugger"])
         self._har_recorders: Dict[str, HarRecordingMetadata] = {}
         self._request: APIRequestContext = from_channel(initializer["requestContext"])
         self._request._timeout_settings = self._timeout_settings
@@ -392,16 +395,18 @@ async def set_offline(self, offline: bool) -> None:
 
     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", None, 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(
@@ -410,16 +415,18 @@ 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", None, 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(
@@ -431,6 +438,7 @@ async def route(
             ),
         )
         await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler))
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
@@ -564,6 +572,9 @@ def expect_event(
         waiter.wait_for_event(self, event, predicate)
         return EventContextManagerImpl(waiter.result())
 
+    def is_closed(self) -> bool:
+        return self._closing_or_closed
+
     def _on_close(self) -> None:
         self._closing_or_closed = True
         if self._browser:
@@ -627,6 +638,16 @@ async def storage_state(
             await async_writefile(path, json.dumps(result))
         return result
 
+    async def set_storage_state(
+        self, storageState: Union[StorageState, str, Path]
+    ) -> None:
+        state: StorageState
+        if isinstance(storageState, (str, Path)):
+            state = json.loads(await async_readfile(storageState))
+        elif storageState:
+            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
@@ -753,6 +774,10 @@ async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
     def tracing(self) -> Tracing:
         return self._tracing
 
+    @property
+    def debugger(self) -> Debugger:
+        return self._debugger
+
     @property
     def request(self) -> "APIRequestContext":
         return self._request
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
index 3aef7dd6d..f160ea106 100644
--- a/playwright/_impl/_browser_type.py
+++ b/playwright/_impl/_browser_type.py
@@ -88,6 +88,7 @@ async def launch(
         tracesDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
+        artifactsDir: Union[Path, str] = None,
     ) -> Browser:
         params = locals_to_params(locals())
         normalize_launch_params(params)
@@ -156,6 +157,7 @@ async def launch_persistent_context(
         recordHarMode: HarMode = None,
         recordHarContent: HarContentPolicy = None,
         clientCertificates: List[ClientCertificate] = None,
+        artifactsDir: Union[Path, str] = None,
     ) -> BrowserContext:
         userDataDir = self._user_data_dir(userDataDir)
         params = locals_to_params(locals())
@@ -213,7 +215,7 @@ async def connect_over_cdp(
 
     async def connect(
         self,
-        wsEndpoint: str,
+        endpoint: str,
         timeout: float = None,
         slowMo: float = None,
         headers: Dict[str, str] = None,
@@ -229,7 +231,7 @@ async def connect(
                 "connect",
                 None,
                 {
-                    "wsEndpoint": wsEndpoint,
+                    "endpoint": endpoint,
                     "headers": headers,
                     "slowMo": slowMo,
                     "timeout": timeout if timeout is not None else 0,
diff --git a/playwright/_impl/_cdp_session.py b/playwright/_impl/_cdp_session.py
index 95e65c57a..845bbe711 100644
--- a/playwright/_impl/_cdp_session.py
+++ b/playwright/_impl/_cdp_session.py
@@ -24,6 +24,7 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._channel.on("event", lambda params: self._on_event(params))
+        self._channel.on("close", lambda _: self.emit("close"))
 
     def _on_event(self, params: Any) -> None:
         self.emit(params["method"], params.get("params"))
diff --git a/playwright/_impl/_console_message.py b/playwright/_impl/_console_message.py
index f37e3dd4d..d98901d34 100644
--- a/playwright/_impl/_console_message.py
+++ b/playwright/_impl/_console_message.py
@@ -76,6 +76,10 @@ 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
diff --git a/playwright/_impl/_debugger.py b/playwright/_impl/_debugger.py
new file mode 100644
index 000000000..12de04f81
--- /dev/null
+++ b/playwright/_impl/_debugger.py
@@ -0,0 +1,52 @@
+# 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._api_structures import PausedDetails, PausedDetailsLocation
+from playwright._impl._connection import ChannelOwner
+
+
+class Debugger(ChannelOwner):
+    Events = {"PausedStateChanged": "pausedStateChanged"}
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._paused_details: Optional[PausedDetails] = None
+        self._channel.on(
+            "pausedStateChanged",
+            lambda params: self._on_paused_state_changed(params.get("pausedDetails")),
+        )
+
+    def _on_paused_state_changed(self, paused_details: Optional[PausedDetails]) -> None:
+        self._paused_details = paused_details
+        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: PausedDetailsLocation) -> None:
+        await self._channel.send("runTo", None, {"location": location})
+
+    @property
+    def paused_details(self) -> Optional[PausedDetails]:
+        return self._paused_details
diff --git a/playwright/_impl/_dialog.py b/playwright/_impl/_dialog.py
index 226e703b9..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
@@ -51,7 +52,12 @@ async def accept(self, promptText: str = None) -> None:
         await self._channel.send("accept", None, locals_to_params(locals()))
 
     async def dismiss(self) -> None:
-        await self._channel.send(
-            "dismiss",
-            None,
-        )
+        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..6d4ab9e0b
--- /dev/null
+++ b/playwright/_impl/_disposable.py
@@ -0,0 +1,55 @@
+# 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 Awaitable, Callable, Dict
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import 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]]) -> None:
+        self._dispose_fn = dispose_fn
+
+    async def dispose(self) -> None:
+        await self._dispose_fn()
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
diff --git a/playwright/_impl/_local_utils.py b/playwright/_impl/_local_utils.py
index c2d2d3fca..d5cd8d617 100644
--- a/playwright/_impl/_local_utils.py
+++ b/playwright/_impl/_local_utils.py
@@ -62,7 +62,9 @@ async def har_unzip(self, zipFile: str, harFile: str) -> None:
         params = locals_to_params(locals())
         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
+    ) -> str:
         params = locals_to_params(locals())
         return await self._channel.send("tracingStarted", None, params)
 
diff --git a/playwright/_impl/_locator.py b/playwright/_impl/_locator.py
index 2e6a7abed..e7cd62eb3 100644
--- a/playwright/_impl/_locator.py
+++ b/playwright/_impl/_locator.py
@@ -564,7 +564,12 @@ async def screenshot(
             ),
         )
 
-    async def aria_snapshot(self, timeout: float = None) -> str:
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        mode: Literal["ai", "default"] = None,
+        depth: int = None,
+    ) -> str:
         return await self._frame._channel.send(
             "ariaSnapshot",
             self._frame._timeout,
@@ -574,6 +579,14 @@ async def aria_snapshot(self, timeout: float = None) -> str:
             },
         )
 
+    async def normalize(self) -> "Locator":
+        resolved_selector = await self._frame._channel.send(
+            "resolveSelector",
+            self._frame._timeout,
+            {"selector": self._selector},
+        )
+        return Locator(self._frame, resolved_selector)
+
     async def scroll_into_view_if_needed(
         self,
         timeout: float = None,
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
index 9f2c29f6e..6cc1c2d35 100644
--- a/playwright/_impl/_network.py
+++ b/playwright/_impl/_network.py
@@ -138,6 +138,7 @@ def __init__(
         if self._redirected_from:
             self._redirected_from._redirected_to = self
         self._failure_text: Optional[str] = None
+        self._response: Optional["Response"] = None
         self._timing: ResourceTiming = {
             "startTime": 0,
             "domainLookupStart": -1,
@@ -243,6 +244,10 @@ async def response(self) -> Optional["Response"]:
             )
         )
 
+    @property
+    def existing_response(self) -> Optional["Response"]:
+        return self._response
+
     @property
     def frame(self) -> "Frame":
         if not self._initializer.get("frame"):
@@ -799,6 +804,7 @@ def __init__(
     ) -> 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"]
@@ -911,6 +917,9 @@ async def text(self) -> str:
     async def json(self) -> Any:
         return json.loads(await self.text())
 
+    async def http_version(self) -> str:
+        return await self._channel.send("httpVersion", None)
+
     @property
     def request(self) -> Request:
         return self._request
diff --git a/playwright/_impl/_object_factory.py b/playwright/_impl/_object_factory.py
index b44009bc3..7911ddb30 100644
--- a/playwright/_impl/_object_factory.py
+++ b/playwright/_impl/_object_factory.py
@@ -20,7 +20,9 @@
 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
@@ -64,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":
diff --git a/playwright/_impl/_page.py b/playwright/_impl/_page.py
index 1f05a9048..9b89634ad 100644
--- a/playwright/_impl/_page.py
+++ b/playwright/_impl/_page.py
@@ -49,6 +49,7 @@
     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, determine_screenshot_type
 from playwright._impl._errors import Error, TargetClosedError, is_target_closed_error
@@ -90,6 +91,7 @@
     parse_result,
     serialize_argument,
 )
+from playwright._impl._locator import Locator
 from playwright._impl._network import (
     Request,
     Response,
@@ -98,13 +100,14 @@
     WebSocketRouteHandler,
     serialize_headers,
 )
+from playwright._impl._screencast import Screencast
 from playwright._impl._video import Video
 from playwright._impl._waiter import Waiter
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._browser_context import BrowserContext
     from playwright._impl._fetch import APIRequestContext
-    from playwright._impl._locator import FrameLocator, Locator
+    from playwright._impl._locator import FrameLocator
     from playwright._impl._network import WebSocket
 
 
@@ -176,7 +179,11 @@ def __init__(
             self._browser_context._timeout_settings
         )
         self._video: Optional[Video] = None
+        self._screencast: Screencast = Screencast(self)
         self._opener = cast("Page", from_nullable_channel(initializer.get("opener")))
+        self._video = Video(
+            self, self._connection, from_nullable_channel(initializer.get("video"))
+        )
         self._close_reason: Optional[str] = None
         self._close_was_called = False
         self._har_routers: List[HarRouter] = []
@@ -224,7 +231,6 @@ def __init__(
                 self._on_web_socket_route(from_channel(params["webSocketRoute"]))
             ),
         )
-        self._channel.on("video", lambda params: self._on_video(params))
         self._channel.on("viewportSizeChanged", self._on_viewport_size_changed)
         self._channel.on(
             "webSocket",
@@ -356,10 +362,6 @@ 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"])
-        self._force_video()._artifact_ready(artifact)
-
     def _on_viewport_size_changed(self, params: Any) -> None:
         self._viewport_size = params["viewportSize"]
 
@@ -501,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:
@@ -514,10 +516,12 @@ async def expose_binding(
                 f'Function "{name}" has been already registered in the browser context'
             )
         self._bindings[name] = callback
-        await self._channel.send(
-            "exposeBinding",
-            None,
-            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:
@@ -661,18 +665,20 @@ async def bring_to_front(self) -> 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", None, 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(
@@ -684,6 +690,7 @@ async def route(
             ),
         )
         await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler))
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
@@ -820,6 +827,25 @@ async def screenshot(
             await async_writefile(path, decoded_binary)
         return decoded_binary
 
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        mode: Literal["ai", "default"] = None,
+        depth: int = None,
+    ) -> str:
+        return await self._main_frame._channel.send(
+            "ariaSnapshot",
+            self._timeout_settings.timeout,
+            locals_to_params(locals()),
+        )
+
+    async def pick_locator(self) -> "Locator":
+        result = await self._channel.send("pickLocator", None, {})
+        return Locator(self._main_frame, result["selector"])
+
+    async def cancel_pick_locator(self) -> None:
+        await self._channel.send("cancelPickLocator", None, {})
+
     async def title(self) -> str:
         return await self._main_frame.title()
 
@@ -1168,11 +1194,6 @@ async def pdf(
             await async_writefile(path, decoded_binary)
         return decoded_binary
 
-    def _force_video(self) -> Video:
-        if not self._video:
-            self._video = Video(self)
-        return self._video
-
     @property
     def video(
         self,
@@ -1182,7 +1203,11 @@ def video(
         # too late during launchPersistentContext.
         if not self._browser_context._videos_dir:
             return None
-        return self._force_video()
+        return self._video
+
+    @property
+    def screencast(self) -> Screencast:
+        return self._screencast
 
     def _close_error_with_reason(self) -> TargetClosedError:
         return TargetClosedError(
@@ -1435,8 +1460,12 @@ async def requests(self) -> List[Request]:
         request_objects = await self._channel.send("requests", None)
         return [from_channel(r) for r in request_objects]
 
-    async def console_messages(self) -> List[ConsoleMessage]:
-        message_dicts = await self._channel.send("consoleMessages", None)
+    async def console_messages(
+        self, filter: Literal["all", "since-navigation"] = None
+    ) -> List[ConsoleMessage]:
+        message_dicts = await self._channel.send(
+            "consoleMessages", None, {"filter": filter}
+        )
         return [
             ConsoleMessage(
                 {**event, "page": self._channel}, self._loop, self._dispatcher_fiber
@@ -1444,10 +1473,18 @@ async def console_messages(self) -> List[ConsoleMessage]:
             for event in message_dicts
         ]
 
-    async def page_errors(self) -> List[Error]:
-        error_objects = await self._channel.send("pageErrors", None)
+    async def clear_console_messages(self) -> None:
+        await self._channel.send("clearConsoleMessages", None)
+
+    async def page_errors(
+        self, filter: Literal["all", "since-navigation"] = None
+    ) -> List[Error]:
+        error_objects = await self._channel.send("pageErrors", None, {"filter": filter})
         return [parse_error(error["error"]) for error in error_objects]
 
+    async def clear_page_errors(self) -> None:
+        await self._channel.send("clearPageErrors", None)
+
 
 class Worker(ChannelOwner):
     Events = SimpleNamespace(Close="close", Console="console")
diff --git a/playwright/_impl/_screencast.py b/playwright/_impl/_screencast.py
new file mode 100644
index 000000000..94554e069
--- /dev/null
+++ b/playwright/_impl/_screencast.py
@@ -0,0 +1,141 @@
+# 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 (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Literal,
+    Optional,
+    Union,
+)
+
+from playwright._impl._api_structures import OnFrame
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import from_channel
+from playwright._impl._disposable import DisposableStub
+
+if TYPE_CHECKING:
+    from playwright._impl._page import Page
+
+
+class Screencast:
+    def __init__(self, page: "Page") -> None:
+        self._page = page
+        self._started = False
+        self._save_path: Optional[Union[str, Path]] = None
+        self._on_frame: Optional[Callable[[OnFrame], Awaitable[Any]]] = None
+        self._artifact: Optional[Artifact] = None
+        self._page._channel.on("screencastFrame", self._handle_frame)
+
+    def _handle_frame(self, params: Dict) -> None:
+        if self._on_frame:
+            self._on_frame({"data": params["data"]})
+
+    async def start(
+        self,
+        path: Union[str, Path] = None,
+        quality: int = None,
+        onFrame: Callable[[OnFrame], Awaitable[Any]] = None,
+    ) -> DisposableStub:
+        if self._started:
+            raise Exception("Screencast is already started")
+        self._started = True
+        if onFrame:
+            self._on_frame = onFrame
+        result = await self._page._channel.send(
+            "screencastStart",
+            None,
+            {
+                "quality": quality,
+                "sendFrames": onFrame is not None,
+                "record": path is not None,
+            },
+        )
+        if result.get("artifact"):
+            self._artifact = from_channel(result["artifact"])
+            self._save_path = path
+
+        return DisposableStub(lambda: self.stop())
+
+    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: Literal[
+            "bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right"
+        ] = None,
+        fontSize: int = None,
+    ) -> DisposableStub:
+        await self._page._channel.send(
+            "screencastShowActions",
+            None,
+            {"duration": duration, "position": position, "fontSize": fontSize},
+        )
+        return DisposableStub(lambda: self.hide_actions())
+
+    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(
+            "screencastShowOverlay",
+            None,
+            {"html": html, "duration": duration},
+        )
+
+        return DisposableStub(
+            lambda: self._page._channel.send(
+                "screencastRemoveOverlay",
+                None,
+                {"id": result["id"]},
+            )
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        description: str = None,
+        duration: float = None,
+    ) -> None:
+        await self._page._channel.send(
+            "screencastChapter",
+            None,
+            {"title": title, "description": description, "duration": duration},
+        )
+
+    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/_tracing.py b/playwright/_impl/_tracing.py
index bbc6ec35e..4d7cc6dd6 100644
--- a/playwright/_impl/_tracing.py
+++ b/playwright/_impl/_tracing.py
@@ -18,6 +18,7 @@
 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
 
 
@@ -29,6 +30,7 @@ def __init__(
         self._include_sources: bool = False
         self._stacks_id: Optional[str] = None
         self._is_tracing: bool = False
+        self._is_live: bool = False
         self._traces_dir: Optional[str] = None
 
     async def start(
@@ -38,27 +40,29 @@ 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)
 
         await self._channel.send("tracingStart", None, params)
         trace_name = await self._channel.send(
             "tracingStartChunk", None, {"title": title, "name": name}
         )
-        await self._start_collecting_stacks(trace_name)
+        await self._start_collecting_stacks(trace_name, self._is_live)
 
     async def start_chunk(self, title: str = None, name: str = None) -> None:
         params = locals_to_params(locals())
         trace_name = await self._channel.send("tracingStartChunk", None, params)
-        await self._start_collecting_stacks(trace_name)
+        await self._start_collecting_stacks(trace_name, self._is_live)
 
-    async def _start_collecting_stacks(self, trace_name: str) -> None:
+    async def _start_collecting_stacks(self, trace_name: str, live: bool) -> None:
         if not self._is_tracing:
             self._is_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, live
         )
 
     async def stop_chunk(self, path: Union[pathlib.Path, str] = None) -> None:
@@ -136,8 +140,11 @@ def _reset_stack_counter(self) -> None:
             self._is_tracing = False
             self._connection.set_is_tracing(False)
 
-    async def group(self, name: str, location: TracingGroupLocation = None) -> None:
+    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())
 
     async def group_end(self) -> None:
         await self._channel.send(
diff --git a/playwright/_impl/_video.py b/playwright/_impl/_video.py
index 68dedf6f8..c9084b820 100644
--- a/playwright/_impl/_video.py
+++ b/playwright/_impl/_video.py
@@ -19,53 +19,37 @@
 from playwright._impl._helper import Error
 
 if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._connection import Connection
     from playwright._impl._page import Page
 
 
 class Video:
-    def __init__(self, page: "Page") -> None:
+    def __init__(
+        self, page: "Page", connection: "Connection", artifact: Artifact = None
+    ) -> 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._artifact = artifact
+        self._is_remote = connection.is_remote
 
     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 pathlib.Path(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/async_api/_generated.py b/playwright/async_api/_generated.py
index bd694886d..c830a5e99 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -19,6 +19,7 @@
 from typing import Literal
 
 from playwright._impl._api_structures import (
+    BindResult,
     ClientCertificate,
     Cookie,
     FilePayload,
@@ -26,6 +27,9 @@
     Geolocation,
     HttpCredentials,
     NameValue,
+    OnFrame,
+    PausedDetails,
+    PausedDetailsLocation,
     PdfMargins,
     Position,
     ProxySettings,
@@ -56,7 +60,9 @@
 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
@@ -79,6 +85,7 @@
 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
@@ -182,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
@@ -637,6 +659,18 @@ async def json(self) -> typing.Any:
 
         return mapping.from_maybe_impl(await self._impl_obj.json())
 
+    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())
+
 
 mapping.register(ResponseImpl, Response)
 
@@ -1020,10 +1054,17 @@ def on(
         """
         Fired when the websocket has an error."""
 
+    @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]],
+        f: typing.Callable[..., "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         return super().on(event=event, f=f)
 
@@ -1067,10 +1108,17 @@ def once(
         """
         Fired when the websocket has an error."""
 
+    @typing.overload
     def once(
         self,
         event: str,
-        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+        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)
 
@@ -3361,7 +3409,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]
@@ -3412,7 +3460,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]
@@ -4817,7 +4865,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()
@@ -4917,7 +4965,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()
@@ -6304,7 +6352,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()
@@ -6404,7 +6452,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()
@@ -6592,10 +6640,17 @@ def on(
         Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
         """
 
+    @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]],
+        f: typing.Callable[..., "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         return super().on(event=event, f=f)
 
@@ -6621,10 +6676,17 @@ def once(
         Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
         """
 
+    @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]],
+        f: typing.Callable[..., "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         return super().once(event=event, f=f)
 
@@ -7089,6 +7151,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
@@ -7611,10 +7685,17 @@ def on(
         Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
         by the page."""
 
+    @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]],
+        f: typing.Callable[..., "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         return super().on(event=event, f=f)
 
@@ -7881,10 +7962,17 @@ def once(
         Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
         by the page."""
 
+    @typing.overload
     def once(
         self,
         event: str,
-        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+        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)
 
@@ -8019,7 +8107,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
         -------
@@ -8027,6 +8116,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
 
@@ -8780,7 +8883,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
@@ -8834,9 +8939,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)
             )
@@ -8848,7 +8957,7 @@ async def expose_binding(
         callback: typing.Callable,
         *,
         handle: typing.Optional[bool] = None,
-    ) -> 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
@@ -8903,9 +9012,13 @@ async def main():
             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
             )
@@ -9164,7 +9277,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]
@@ -9440,7 +9553,7 @@ async def add_init_script(
         script: typing.Optional[str] = None,
         *,
         path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
-    ) -> None:
+    ) -> "AsyncContextManager":
         """Page.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -9470,9 +9583,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)
         )
 
@@ -9485,7 +9602,7 @@ async def route(
         ],
         *,
         times: typing.Optional[int] = None,
-    ) -> None:
+    ) -> "AsyncContextManager":
         """Page.route
 
         Routing provides the capability to modify network requests that are made by a page.
@@ -9534,6 +9651,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.
 
@@ -9551,9 +9670,13 @@ async def handle_route(route: Route):
             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),
@@ -9579,7 +9702,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.
         """
@@ -9806,6 +9929,66 @@ async def screenshot(
             )
         )
 
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        depth: typing.Optional[int] = 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.
+        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"`.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(timeout=timeout, mode=mode, depth=depth)
+        )
+
+    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())
+
     async def title(self) -> str:
         """Page.title
 
@@ -10441,7 +10624,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()
@@ -10541,7 +10724,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()
@@ -11860,7 +12043,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]
@@ -12331,29 +12514,63 @@ async def requests(self) -> typing.List["Request"]:
 
         return mapping.from_impl_list(await self._impl_obj.requests())
 
-    async def console_messages(self) -> typing.List["ConsoleMessage"]:
+    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
         -------
         List[ConsoleMessage]
         """
 
-        return mapping.from_impl_list(await self._impl_obj.console_messages())
+        return mapping.from_impl_list(
+            await self._impl_obj.console_messages(filter=filter)
+        )
+
+    async def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
+
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
+        """
 
-    async def page_errors(self) -> typing.List["Error"]:
+        return mapping.from_maybe_impl(await self._impl_obj.clear_console_messages())
+
+    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.
 
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
         Returns
         -------
         List[Error]
         """
 
-        return mapping.from_impl_list(await self._impl_obj.page_errors())
+        return mapping.from_impl_list(await self._impl_obj.page_errors(filter=filter))
+
+    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())
 
 
 mapping.register(PageImpl, Page)
@@ -12558,10 +12775,17 @@ def on(
 
         Emitted when new service worker is created in the context."""
 
+    @typing.overload
     def on(
         self,
         event: str,
-        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+        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)
 
@@ -12732,10 +12956,17 @@ def once(
 
         Emitted when new service worker is created in the context."""
 
+    @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]],
+        f: typing.Callable[..., "typing.Union[typing.Awaitable[None], None]"],
     ) -> None:
         return super().once(event=event, f=f)
 
@@ -12800,6 +13031,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
@@ -12991,6 +13234,7 @@ async def grant_permissions(
             - `'notifications'`
             - `'payment-handler'`
             - `'storage-access'`
+            - `'screen-wake-lock'`
         origin : Union[str, None]
             The [origin] to grant permissions to, e.g. "https://example.com".
         """
@@ -13083,7 +13327,7 @@ async def add_init_script(
         script: typing.Optional[str] = None,
         *,
         path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
-    ) -> None:
+    ) -> "AsyncContextManager":
         """BrowserContext.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -13113,9 +13357,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)
         )
 
@@ -13125,7 +13373,7 @@ async def expose_binding(
         callback: typing.Callable,
         *,
         handle: typing.Optional[bool] = None,
-    ) -> 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
@@ -13178,15 +13426,21 @@ async def main():
             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
@@ -13239,9 +13493,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)
             )
@@ -13256,7 +13514,7 @@ async def route(
         ],
         *,
         times: typing.Optional[int] = None,
-    ) -> None:
+    ) -> "AsyncContextManager":
         """BrowserContext.route
 
         Routing provides the capability to modify network requests that are made by any page in the browser context. Once
@@ -13318,9 +13576,13 @@ async def handle_route(route: Route):
             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),
@@ -13346,7 +13608,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()`.
@@ -13523,6 +13785,18 @@ def expect_event(
             ).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
 
@@ -13568,6 +13842,33 @@ async def storage_state(
             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)
+        )
+
     async def wait_for_event(
         self,
         event: str,
@@ -13695,6 +13996,58 @@ 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:
@@ -13731,6 +14084,7 @@ async def detach(self) -> None:
 
 class Browser(AsyncContextManager):
 
+    @typing.overload
     def on(
         self,
         event: Literal["disconnected"],
@@ -13741,8 +14095,22 @@ 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[..., "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"],
@@ -13753,6 +14121,19 @@ 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[..., "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
@@ -14321,6 +14702,49 @@ async def close(self, *, reason: typing.Optional[str] = None) -> None:
 
         return mapping.from_maybe_impl(await self._impl_obj.close(reason=reason))
 
+    async def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BindResult:
+        """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 new_browser_cdp_session(self) -> "CDPSession":
         """Browser.new_browser_cdp_session
 
@@ -14452,6 +14876,7 @@ async def launch(
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
         ] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> "Browser":
         """BrowserType.launch
 
@@ -14537,6 +14962,10 @@ async def launch(
 
             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.
+        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.
 
         Returns
         -------
@@ -14561,6 +14990,7 @@ async def launch(
                 tracesDir=traces_dir,
                 chromiumSandbox=chromium_sandbox,
                 firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                artifactsDir=artifacts_dir,
             )
         )
 
@@ -14627,6 +15057,7 @@ async def launch_persistent_context(
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
         client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -14830,6 +15261,10 @@ async def launch_persistent_context(
             **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`.
 
+        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.
 
         Returns
         -------
@@ -14888,6 +15323,7 @@ async def launch_persistent_context(
                 recordHarMode=record_har_mode,
                 recordHarContent=record_har_content,
                 clientCertificates=client_certificates,
+                artifactsDir=artifacts_dir,
             )
         )
 
@@ -14954,7 +15390,7 @@ async def connect_over_cdp(
 
     async def connect(
         self,
-        ws_endpoint: str,
+        endpoint: str,
         *,
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
@@ -14970,7 +15406,7 @@ async def connect(
 
         Parameters
         ----------
-        ws_endpoint : str
+        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).
@@ -15001,7 +15437,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),
@@ -15149,6 +15585,7 @@ async def start(
         snapshots: typing.Optional[bool] = None,
         screenshots: typing.Optional[bool] = None,
         sources: typing.Optional[bool] = None,
+        live: typing.Optional[bool] = None,
     ) -> None:
         """Tracing.start
 
@@ -15188,6 +15625,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(
@@ -15197,6 +15638,7 @@ async def start(
                 snapshots=snapshots,
                 screenshots=screenshots,
                 sources=sources,
+                live=live,
             )
         )
 
@@ -15273,7 +15715,7 @@ async def stop(
 
     async def group(
         self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
-    ) -> None:
+    ) -> "AsyncContextManager":
         """Tracing.group
 
         **NOTE** Use `test.step` instead when available.
@@ -15299,9 +15741,13 @@ async def group(
         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_maybe_impl(
+        return mapping.from_impl(
             await self._impl_obj.group(name=name, location=location)
         )
 
@@ -16283,7 +16729,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()
@@ -16383,7 +16829,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()
@@ -17406,7 +17852,13 @@ async def screenshot(
             )
         )
 
-    async def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        depth: typing.Optional[int] = 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
@@ -17446,11 +17898,20 @@ async def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
             - 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.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
 
         Returns
         -------
@@ -17458,9 +17919,23 @@ async def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
         """
 
         return mapping.from_maybe_impl(
-            await self._impl_obj.aria_snapshot(timeout=timeout)
+            await self._impl_obj.aria_snapshot(timeout=timeout, mode=mode, depth=depth)
         )
 
+    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:
@@ -18221,7 +18696,7 @@ async def delete(
             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]]
@@ -18302,7 +18777,7 @@ async def head(
             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]]
@@ -18383,7 +18858,7 @@ async def get(
             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]]
@@ -18476,7 +18951,7 @@ async def patch(
             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]]
@@ -18557,7 +19032,7 @@ async def put(
             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]]
@@ -18638,7 +19113,7 @@ async def post(
             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]]
@@ -18751,7 +19226,7 @@ async def fetch(
         ] = 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]]
@@ -21005,3 +21480,294 @@ async def not_to_be_ok(self) -> None:
 
 
 mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
+
+
+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[PausedDetails]:
+        """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: PausedDetailsLocation) -> 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 Screencast(AsyncBase):
+
+    async def start(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        on_frame: typing.Optional[
+            typing.Callable[[OnFrame], typing.Awaitable[typing.Any]]
+        ] = 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
+        ----------
+        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.
+        on_frame : Union[Callable[[{data: bytes}], typing.Awaitable[typing.Any]], None]
+            Callback that receives JPEG-encoded frame data.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.start(
+                path=path, quality=quality, onFrame=self._wrap_handler(on_frame)
+            )
+        )
+
+    async def stop(self) -> None:
+        """Screencast.stop
+
+        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
+        ----------
+        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_impl(
+            await self._impl_obj.show_actions(
+                duration=duration, position=position, fontSize=font_size
+            )
+        )
+
+    async def hide_actions(self) -> None:
+        """Screencast.hide_actions
+
+        Removes action decorations.
+        """
+
+        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
+
+        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.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        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 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/_generated.py b/playwright/sync_api/_generated.py
index 0df2087df..f174d2e85 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -19,6 +19,7 @@
 from typing import Literal
 
 from playwright._impl._api_structures import (
+    BindResult,
     ClientCertificate,
     Cookie,
     FilePayload,
@@ -26,6 +27,9 @@
     Geolocation,
     HttpCredentials,
     NameValue,
+    OnFrame,
+    PausedDetails,
+    PausedDetailsLocation,
     PdfMargins,
     Position,
     ProxySettings,
@@ -50,7 +54,9 @@
 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
@@ -73,6 +79,7 @@
 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,
@@ -182,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
@@ -643,6 +665,18 @@ def json(self) -> typing.Any:
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
 
+    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()))
+
 
 mapping.register(ResponseImpl, Response)
 
@@ -1028,7 +1062,10 @@ def on(
         """
         Fired when the websocket has an error."""
 
-    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -1063,7 +1100,10 @@ def once(
         """
         Fired when the websocket has an error."""
 
-    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -3411,7 +3451,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]
@@ -3462,7 +3502,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]
@@ -4896,7 +4936,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()
@@ -4996,7 +5036,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()
@@ -6410,7 +6450,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()
@@ -6510,7 +6550,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()
@@ -6692,7 +6732,10 @@ def on(
         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:
+    @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
@@ -6711,7 +6754,10 @@ def once(
         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:
+    @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
@@ -7179,6 +7225,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
@@ -7649,7 +7707,10 @@ def on(
         Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
         by the page."""
 
-    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -7871,7 +7932,10 @@ def once(
         Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
         by the page."""
 
-    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -8005,7 +8069,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
         -------
@@ -8013,6 +8078,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
 
@@ -8789,7 +8868,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
@@ -8840,9 +8921,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)
@@ -8856,7 +8941,7 @@ def expose_binding(
         callback: typing.Callable,
         *,
         handle: typing.Optional[bool] = None,
-    ) -> 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
@@ -8908,9 +8993,13 @@ def run(playwright: Playwright):
             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
@@ -9175,7 +9264,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]
@@ -9459,7 +9548,7 @@ def add_init_script(
         script: typing.Optional[str] = None,
         *,
         path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
-    ) -> None:
+    ) -> "SyncContextManager":
         """Page.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -9489,9 +9578,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))
         )
 
@@ -9504,7 +9597,7 @@ def route(
         ],
         *,
         times: typing.Optional[int] = None,
-    ) -> None:
+    ) -> "SyncContextManager":
         """Page.route
 
         Routing provides the capability to modify network requests that are made by a page.
@@ -9553,6 +9646,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.
 
@@ -9570,9 +9665,13 @@ def handle_route(route: Route):
             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),
@@ -9600,7 +9699,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.
         """
@@ -9835,6 +9934,68 @@ def screenshot(
             )
         )
 
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        depth: typing.Optional[int] = 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.
+        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"`.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.aria_snapshot(timeout=timeout, mode=mode, depth=depth)
+            )
+        )
+
+    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()))
+
     def title(self) -> str:
         """Page.title
 
@@ -10480,7 +10641,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()
@@ -10580,7 +10741,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()
@@ -11926,7 +12087,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]
@@ -12401,29 +12562,67 @@ def requests(self) -> typing.List["Request"]:
 
         return mapping.from_impl_list(self._sync(self._impl_obj.requests()))
 
-    def console_messages(self) -> typing.List["ConsoleMessage"]:
+    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
         -------
         List[ConsoleMessage]
         """
 
-        return mapping.from_impl_list(self._sync(self._impl_obj.console_messages()))
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.console_messages(filter=filter))
+        )
+
+    def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
+
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.clear_console_messages())
+        )
 
-    def page_errors(self) -> typing.List["Error"]:
+    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.
 
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
         Returns
         -------
         List[Error]
         """
 
-        return mapping.from_impl_list(self._sync(self._impl_obj.page_errors()))
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.page_errors(filter=filter))
+        )
+
+    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(self._sync(self._impl_obj.clear_page_errors()))
 
 
 mapping.register(PageImpl, Page)
@@ -12598,7 +12797,10 @@ def on(
 
         Emitted when new service worker is created in the context."""
 
-    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -12740,7 +12942,10 @@ def once(
 
         Emitted when new service worker is created in the context."""
 
-    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+    @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
@@ -12804,6 +13009,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
@@ -12997,6 +13214,7 @@ def grant_permissions(
             - `'notifications'`
             - `'payment-handler'`
             - `'storage-access'`
+            - `'screen-wake-lock'`
         origin : Union[str, None]
             The [origin] to grant permissions to, e.g. "https://example.com".
         """
@@ -13089,7 +13307,7 @@ def add_init_script(
         script: typing.Optional[str] = None,
         *,
         path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
-    ) -> None:
+    ) -> "SyncContextManager":
         """BrowserContext.add_init_script
 
         Adds a script which would be evaluated in one of the following scenarios:
@@ -13119,9 +13337,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))
         )
 
@@ -13131,7 +13353,7 @@ def expose_binding(
         callback: typing.Callable,
         *,
         handle: typing.Optional[bool] = None,
-    ) -> 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
@@ -13181,9 +13403,13 @@ def run(playwright: Playwright):
             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
@@ -13191,7 +13417,9 @@ def run(playwright: Playwright):
             )
         )
 
-    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
@@ -13241,9 +13469,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)
@@ -13260,7 +13492,7 @@ def route(
         ],
         *,
         times: typing.Optional[int] = None,
-    ) -> None:
+    ) -> "SyncContextManager":
         """BrowserContext.route
 
         Routing provides the capability to modify network requests that are made by any page in the browser context. Once
@@ -13323,9 +13555,13 @@ def handle_route(route: Route):
             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),
@@ -13353,7 +13589,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()`.
@@ -13536,6 +13772,18 @@ def expect_event(
             ).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())
+
     def close(self, *, reason: typing.Optional[str] = None) -> None:
         """BrowserContext.close
 
@@ -13581,6 +13829,33 @@ def storage_state(
             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))
+        )
+
     def wait_for_event(
         self,
         event: str,
@@ -13710,6 +13985,34 @@ 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:
@@ -13748,6 +14051,7 @@ def detach(self) -> None:
 
 class Browser(SyncContextManager):
 
+    @typing.overload
     def on(
         self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
     ) -> None:
@@ -13756,8 +14060,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:
@@ -13766,6 +14076,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
@@ -14338,6 +14653,51 @@ def close(self, *, reason: typing.Optional[str] = None) -> None:
 
         return mapping.from_maybe_impl(self._sync(self._impl_obj.close(reason=reason)))
 
+    def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BindResult:
+        """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 new_browser_cdp_session(self) -> "CDPSession":
         """Browser.new_browser_cdp_session
 
@@ -14471,6 +14831,7 @@ def launch(
         firefox_user_prefs: typing.Optional[
             typing.Dict[str, typing.Union[str, float, bool]]
         ] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> "Browser":
         """BrowserType.launch
 
@@ -14556,6 +14917,10 @@ def launch(
 
             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.
+        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.
 
         Returns
         -------
@@ -14581,6 +14946,7 @@ def launch(
                     tracesDir=traces_dir,
                     chromiumSandbox=chromium_sandbox,
                     firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                    artifactsDir=artifacts_dir,
                 )
             )
         )
@@ -14648,6 +15014,7 @@ def launch_persistent_context(
         record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
         record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
         client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
     ) -> "BrowserContext":
         """BrowserType.launch_persistent_context
 
@@ -14851,6 +15218,10 @@ def launch_persistent_context(
             **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`.
 
+        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.
 
         Returns
         -------
@@ -14910,6 +15281,7 @@ def launch_persistent_context(
                     recordHarMode=record_har_mode,
                     recordHarContent=record_har_content,
                     clientCertificates=client_certificates,
+                    artifactsDir=artifacts_dir,
                 )
             )
         )
@@ -14979,7 +15351,7 @@ def connect_over_cdp(
 
     def connect(
         self,
-        ws_endpoint: str,
+        endpoint: str,
         *,
         timeout: typing.Optional[float] = None,
         slow_mo: typing.Optional[float] = None,
@@ -14995,7 +15367,7 @@ def connect(
 
         Parameters
         ----------
-        ws_endpoint : str
+        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).
@@ -15027,7 +15399,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),
@@ -15173,6 +15545,7 @@ def start(
         snapshots: typing.Optional[bool] = None,
         screenshots: typing.Optional[bool] = None,
         sources: typing.Optional[bool] = None,
+        live: typing.Optional[bool] = None,
     ) -> None:
         """Tracing.start
 
@@ -15212,6 +15585,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(
@@ -15222,6 +15599,7 @@ def start(
                     snapshots=snapshots,
                     screenshots=screenshots,
                     sources=sources,
+                    live=live,
                 )
             )
         )
@@ -15299,7 +15677,7 @@ def stop(
 
     def group(
         self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
-    ) -> None:
+    ) -> "SyncContextManager":
         """Tracing.group
 
         **NOTE** Use `test.step` instead when available.
@@ -15325,9 +15703,13 @@ def group(
         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_maybe_impl(
+        return mapping.from_impl(
             self._sync(self._impl_obj.group(name=name, location=location))
         )
 
@@ -16327,7 +16709,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()
@@ -16427,7 +16809,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()
@@ -17473,7 +17855,13 @@ def screenshot(
             )
         )
 
-    def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[float] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        depth: typing.Optional[int] = 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
@@ -17513,11 +17901,20 @@ def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
             - 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.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
 
         Returns
         -------
@@ -17525,9 +17922,25 @@ def aria_snapshot(self, *, timeout: typing.Optional[float] = None) -> str:
         """
 
         return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.aria_snapshot(timeout=timeout))
+            self._sync(
+                self._impl_obj.aria_snapshot(timeout=timeout, mode=mode, depth=depth)
+            )
         )
 
+    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:
@@ -18306,7 +18719,7 @@ def delete(
             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]]
@@ -18389,7 +18802,7 @@ def head(
             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]]
@@ -18472,7 +18885,7 @@ def get(
             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]]
@@ -18567,7 +18980,7 @@ def patch(
             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]]
@@ -18650,7 +19063,7 @@ def put(
             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]]
@@ -18733,7 +19146,7 @@ def post(
             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]]
@@ -18848,7 +19261,7 @@ def fetch(
         ] = 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]]
@@ -21175,3 +21588,282 @@ def not_to_be_ok(self) -> None:
 
 
 mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
+
+
+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[PausedDetails]:
+        """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: PausedDetailsLocation) -> 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 Screencast(SyncBase):
+
+    def start(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        on_frame: typing.Optional[
+            typing.Callable[[OnFrame], typing.Awaitable[typing.Any]]
+        ] = 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
+        ----------
+        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.
+        on_frame : Union[Callable[[{data: bytes}], typing.Awaitable[typing.Any]], None]
+            Callback that receives JPEG-encoded frame data.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.start(
+                    path=path, quality=quality, onFrame=self._wrap_handler(on_frame)
+                )
+            )
+        )
+
+    def stop(self) -> None:
+        """Screencast.stop
+
+        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
+        ----------
+        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_impl(
+            self._sync(
+                self._impl_obj.show_actions(
+                    duration=duration, position=position, fontSize=font_size
+                )
+            )
+        )
+
+    def hide_actions(self) -> None:
+        """Screencast.hide_actions
+
+        Removes action decorations.
+        """
+
+        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
+
+        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.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        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:
+        """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(
+            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 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/scripts/documentation_provider.py b/scripts/documentation_provider.py
index a842a1aad..9cc429682 100644
--- a/scripts/documentation_provider.py
+++ b/scripts/documentation_provider.py
@@ -39,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
@@ -218,11 +224,8 @@ def print_events(self, class_name: str) -> None:
                         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")
+                    doc.append("    @typing.overload")
                     impl = ""
-                    if len(events) == 1:
-                        impl = f"        return super().{event_type}(event=event,f=f)"
                     doc.append(
                         f"    def {event_type}(self, event: Literal['{event['name'].lower()}'], f: typing.Callable[['{func_arg}'], '{return_type}']) -> None:"
                     )
@@ -230,11 +233,17 @@ def print_events(self, class_name: str) -> None:
                         f'        """{self.beautify_method_comment(event["comment"], " " * 8)}"""'
                     )
                     doc.append(impl)
-                if len(events) > 1:
-                    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)")
+                doc.append("")
+                doc.append("    @typing.overload")
+                doc.append(
+                    f"    def {event_type}(self, event: str, f: typing.Callable[..., '{return_type}']) -> None:"
+                )
+                doc.append("        ...")
+                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 indent_paragraph(self, p: str, indent: str) -> str:
@@ -343,6 +352,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}"
             )
@@ -372,7 +386,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:
@@ -437,6 +454,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 "typing.Awaitable[typing.Any]"
             type = type["templates"][0]
 
         if "union" in type:
@@ -492,6 +511,8 @@ def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
             return "int"
         if type_name.lower() == "string":
             return "str"
+        if type_name == "void":
+            return "None"
         if type_name == "any" or type_name == "unknown" or type_name == "Serializable":
             return "Any"
         if type_name == "Object":
@@ -510,6 +531,8 @@ def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
             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/expected_api_mismatch.txt b/scripts/expected_api_mismatch.txt
index f47493440..cddb87f15 100644
--- a/scripts/expected_api_mismatch.txt
+++ b/scripts/expected_api_mismatch.txt
@@ -4,6 +4,9 @@
 Parameter not documented: Browser.new_context(default_browser_type=)
 Parameter not documented: Browser.new_page(default_browser_type=)
 
+# 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]
diff --git a/scripts/generate_api.py b/scripts/generate_api.py
index 3d2f45156..272a86100 100644
--- a/scripts/generate_api.py
+++ b/scripts/generate_api.py
@@ -29,7 +29,9 @@
 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
@@ -48,6 +50,7 @@
 )
 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
@@ -224,7 +227,7 @@ def return_value(value: Any) -> List[str]:
 from typing import Literal
 
 
-from playwright._impl._api_structures import Cookie, SetCookieParam, FloatRect, FilePayload, Geolocation, HttpCredentials, PdfMargins, Position, ProxySettings, ResourceTiming, SourceLocation, StorageState, ClientCertificate, ViewportSize, RemoteAddr, SecurityDetails, RequestSizes, NameValue, TracingGroupLocation
+from playwright._impl._api_structures import Cookie, SetCookieParam, FloatRect, FilePayload, Geolocation, HttpCredentials, PdfMargins, Position, ProxySettings, ResourceTiming, SourceLocation, StorageState, ClientCertificate, ViewportSize, RemoteAddr, SecurityDetails, RequestSizes, NameValue, TracingGroupLocation, PausedDetails, PausedDetailsLocation, OnFrame, BindResult
 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
@@ -232,6 +235,7 @@ def return_value(value: Any) -> List[str]:
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
 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
@@ -249,6 +253,8 @@ def return_value(value: Any) -> List[str]:
 from playwright._impl._errors import Error
 from playwright._impl._fetch import APIRequest as APIRequestImpl, APIResponse as APIResponseImpl, APIRequestContext as APIRequestContextImpl
 from playwright._impl._assertions import PageAssertions as PageAssertionsImpl, LocatorAssertions as LocatorAssertionsImpl, APIResponseAssertions as APIResponseAssertionsImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
+from playwright._impl._screencast import Screencast as ScreencastImpl
 """
 
 
@@ -288,6 +294,9 @@ def return_value(value: Any) -> List[str]:
     PageAssertions,
     LocatorAssertions,
     APIResponseAssertions,
+    Debugger,
+    Screencast,
+    Disposable,
 ]
 
 all_types = generated_types + [
diff --git a/scripts/generate_async_api.py b/scripts/generate_async_api.py
index ca52ef1a3..4c0b4b655 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,6 +88,9 @@ 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("")
             async_prefix = "async " if is_async else ""
             print(
diff --git a/scripts/generate_sync_api.py b/scripts/generate_sync_api.py
index 01d6cb02b..5ccf3b672 100755
--- a/scripts/generate_sync_api.py
+++ b/scripts/generate_sync_api.py
@@ -40,7 +40,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,6 +86,9 @@ 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("")
             print(
                 f"    def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:"
diff --git a/setup.py b/setup.py
index 5a8229db1..3bfa8d6f2 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
 import zipfile
 from typing import Dict
 
-driver_version = "1.58.0"
+driver_version = "1.59.1"
 
 base_wheel_bundles = [
     {