diff --git a/README.md b/README.md
index 1efcead54..9a5529b13 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 -->131.0.6778.33<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->133.0.6943.16<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->18.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->132.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->134.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 
diff --git a/playwright/_impl/_assertions.py b/playwright/_impl/_assertions.py
index b226e241f..8ec657531 100644
--- a/playwright/_impl/_assertions.py
+++ b/playwright/_impl/_assertions.py
@@ -525,14 +525,22 @@ async def to_be_checked(
         self,
         timeout: float = None,
         checked: bool = None,
+        indeterminate: bool = None,
     ) -> None:
         __tracebackhide__ = True
-        if checked is None:
-            checked = True
-        checked_string = "checked" if checked else "unchecked"
+        expected_value = {}
+        if indeterminate is not None:
+            expected_value["indeterminate"] = indeterminate
+        if checked is not None:
+            expected_value["checked"] = checked
+        checked_string: str
+        if indeterminate:
+            checked_string = "indeterminate"
+        else:
+            checked_string = "unchecked" if checked is False else "checked"
         await self._expect_impl(
-            ("to.be.checked" if checked else "to.be.unchecked"),
-            FrameExpectOptions(timeout=timeout),
+            "to.be.checked",
+            FrameExpectOptions(timeout=timeout, expectedValue=expected_value),
             None,
             f"Locator expected to be {checked_string}",
         )
@@ -726,7 +734,9 @@ async def to_have_accessible_description(
         timeout: float = None,
     ) -> None:
         __tracebackhide__ = True
-        expected_values = to_expected_text_values([description], ignoreCase=ignoreCase)
+        expected_values = to_expected_text_values(
+            [description], ignoreCase=ignoreCase, normalize_white_space=True
+        )
         await self._expect_impl(
             "to.have.accessible.description",
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
@@ -750,7 +760,9 @@ async def to_have_accessible_name(
         timeout: float = None,
     ) -> None:
         __tracebackhide__ = True
-        expected_values = to_expected_text_values([name], ignoreCase=ignoreCase)
+        expected_values = to_expected_text_values(
+            [name], ignoreCase=ignoreCase, normalize_white_space=True
+        )
         await self._expect_impl(
             "to.have.accessible.name",
             FrameExpectOptions(expectedText=expected_values, timeout=timeout),
@@ -779,6 +791,34 @@ async def to_have_role(self, role: AriaRole, timeout: float = None) -> None:
             "Locator expected to have accessible role",
         )
 
+    async def to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [errorMessage], ignoreCase=ignoreCase, normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.accessible.error.message",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible error message",
+        )
+
+    async def not_to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_error_message(
+            errorMessage=errorMessage, ignoreCase=ignoreCase, timeout=timeout
+        )
+
     async def not_to_have_role(self, role: AriaRole, timeout: float = None) -> None:
         __tracebackhide__ = True
         await self._not.to_have_role(role, timeout)
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
index 97bb049e3..4b15531af 100644
--- a/playwright/_impl/_network.py
+++ b/playwright/_impl/_network.py
@@ -131,6 +131,7 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._channel.mark_as_internal_type()
         self._redirected_from: Optional["Request"] = from_nullable_channel(
             initializer.get("redirectedFrom")
         )
@@ -767,6 +768,7 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._channel.mark_as_internal_type()
         self._request: Request = from_channel(self._initializer["request"])
         timing = self._initializer["timing"]
         self._request._timing["startTime"] = timing["startTime"]
diff --git a/playwright/async_api/_generated.py b/playwright/async_api/_generated.py
index e1480f5bf..7b92fbafb 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -6879,6 +6879,18 @@ async def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> N
         await page.clock.pause_at(\"2020-02-02\")
         ```
 
+        For best results, install the clock before navigating the page and set it to a time slightly before the intended
+        test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck.
+        Once the page has fully loaded, you can safely use `clock.pause_at()` to pause the clock.
+
+        ```py
+        # Initialize clock with some time before the test time and let the page load
+        # naturally. `Date.now` will progress as the timers fire.
+        await page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        await page.goto(\"http://localhost:3333\")
+        await page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
         Parameters
         ----------
         time : Union[datetime.datetime, float, str]
@@ -8036,7 +8048,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -11497,8 +11509,6 @@ async def pdf(
 
         Returns the PDF buffer.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
-
         `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
         `page.emulate_media()` before calling `page.pdf()`:
 
@@ -12750,7 +12760,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -12858,9 +12868,13 @@ async def grant_permissions(
         Parameters
         ----------
         permissions : Sequence[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
+            A list of permissions to grant.
+
+            **NOTE** Supported permissions differ between browsers, and even between different versions of the same browser.
+            Any permission may stop working after an update.
+
+            Here are some permissions that may be supported by some browsers:
             - `'accelerometer'`
-            - `'accessibility-events'`
             - `'ambient-light-sensor'`
             - `'background-sync'`
             - `'camera'`
@@ -14161,9 +14175,9 @@ async def close(self, *, reason: typing.Optional[str] = None) -> None:
         In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from
         the browser server.
 
-        **NOTE** This is similar to force quitting the browser. Therefore, you should call `browser_context.close()`
-        on any `BrowserContext`'s you explicitly created earlier with `browser.new_context()` **before** calling
-        `browser.close()`.
+        **NOTE** This is similar to force-quitting the browser. To close pages gracefully and ensure you receive page close
+        events, call `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
 
         The `Browser` object itself is considered to be disposed and cannot be used anymore.
 
@@ -14346,7 +14360,7 @@ async def launch(
         channel : Union[str, None]
             Browser distribution channel.
 
-            Use "chromium" to [opt in to new headless mode](../browsers.md#opt-in-to-new-headless-mode).
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
 
             Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
             "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
@@ -14504,7 +14518,7 @@ async def launch_persistent_context(
         channel : Union[str, None]
             Browser distribution channel.
 
-            Use "chromium" to [opt in to new headless mode](../browsers.md#opt-in-to-new-headless-mode).
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
 
             Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
             "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
@@ -15522,7 +15536,6 @@ async def dispatch_event(
         You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
 
         ```py
-        # note you can only create data_transfer in chromium and firefox
         data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
         await locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
         ```
@@ -16445,18 +16458,22 @@ def or_(self, locator: "Locator") -> "Locator":
 
         Creates a locator matching all elements that match one or both of the two locators.
 
-        Note that when both locators match something, the resulting locator will have multiple matches and violate
-        [locator strictness](https://playwright.dev/python/docs/locators#strictness) guidelines.
+        Note that when both locators match something, the resulting locator will have multiple matches, potentially causing
+        a [locator strictness](https://playwright.dev/python/docs/locators#strictness) violation.
 
         **Usage**
 
         Consider a scenario where you'd like to click on a \"New email\" button, but sometimes a security settings dialog
         shows up instead. In this case, you can wait for either a \"New email\" button, or a dialog and act accordingly.
 
+        **NOTE** If both \"New email\" button and security dialog appear on screen, the \"or\" locator will match both of them,
+        possibly throwing the [\"strict mode violation\" error](https://playwright.dev/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
         ```py
         new_email = page.get_by_role(\"button\", name=\"New\")
         dialog = page.get_by_text(\"Confirm security settings\")
-        await expect(new_email.or_(dialog)).to_be_visible()
+        await expect(new_email.or_(dialog).first).to_be_visible()
         if (await dialog.is_visible()):
           await page.get_by_role(\"button\", name=\"Dismiss\").click()
         await new_email.click()
@@ -16877,7 +16894,9 @@ async def is_disabled(self, *, timeout: typing.Optional[float] = None) -> bool:
     async def is_editable(self, *, timeout: typing.Optional[float] = None) -> bool:
         """Locator.is_editable
 
-        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable). If the target element is not an `<input>`,
+        `<textarea>`, `<select>`, `[contenteditable]` and does not have a role allowing `[aria-readonly]`, this method
+        throws an error.
 
         **NOTE** If you need to assert that an element is editable, prefer `locator_assertions.to_be_editable()` to
         avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
@@ -19056,24 +19075,26 @@ async def to_have_class(
     ) -> None:
         """LocatorAssertions.to_have_class
 
-        Ensures the `Locator` points to an element with given CSS classes. This needs to be a full match or using a relaxed
-        regular expression.
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes or perform partial matches, use a regular expression:
 
         **Usage**
 
         ```html
-        <div class='selected row' id='component'></div>
+        <div class='middle selected row' id='component'></div>
         ```
 
         ```py
         from playwright.async_api import expect
 
         locator = page.locator(\"#component\")
-        await expect(locator).to_have_class(re.compile(r\"selected\"))
-        await expect(locator).to_have_class(\"selected row\")
+        await expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
+        await expect(locator).to_have_class(\"middle selected row\")
         ```
 
-        Note that if array is passed as an expected value, entire lists of elements can be asserted:
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
 
         ```py
         from playwright.async_api import expect
@@ -19656,6 +19677,7 @@ async def to_be_checked(
         *,
         timeout: typing.Optional[float] = None,
         checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_be_checked
 
@@ -19675,11 +19697,18 @@ async def to_be_checked(
         timeout : Union[float, None]
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
-            await self._impl_obj.to_be_checked(timeout=timeout, checked=checked)
+            await self._impl_obj.to_be_checked(
+                timeout=timeout, checked=checked, indeterminate=indeterminate
+            )
         )
 
     async def not_to_be_attached(
@@ -20373,6 +20402,72 @@ async def to_have_role(
             await self._impl_obj.to_have_role(role=role, timeout=timeout)
         )
 
+    async def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
+
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        await expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_error_message(
+                errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
+
+    async def not_to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
+
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_error_message(
+                errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+            )
+        )
+
     async def not_to_have_role(
         self,
         role: Literal[
diff --git a/playwright/sync_api/_generated.py b/playwright/sync_api/_generated.py
index 42401bc64..04a0f10fc 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -6991,6 +6991,18 @@ def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
         page.clock.pause_at(\"2020-02-02\")
         ```
 
+        For best results, install the clock before navigating the page and set it to a time slightly before the intended
+        test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck.
+        Once the page has fully loaded, you can safely use `clock.pause_at()` to pause the clock.
+
+        ```py
+        # Initialize clock with some time before the test time and let the page load
+        # naturally. `Date.now` will progress as the timers fire.
+        page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        page.goto(\"http://localhost:3333\")
+        page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
         Parameters
         ----------
         time : Union[datetime.datetime, float, str]
@@ -8046,7 +8058,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -11585,8 +11597,6 @@ def pdf(
 
         Returns the PDF buffer.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
-
         `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
         `page.emulate_media()` before calling `page.pdf()`:
 
@@ -12778,7 +12788,7 @@ def set_default_timeout(self, timeout: float) -> None:
         Parameters
         ----------
         timeout : float
-            Maximum time in milliseconds
+            Maximum time in milliseconds. Pass `0` to disable timeout.
         """
 
         return mapping.from_maybe_impl(
@@ -12888,9 +12898,13 @@ def grant_permissions(
         Parameters
         ----------
         permissions : Sequence[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
+            A list of permissions to grant.
+
+            **NOTE** Supported permissions differ between browsers, and even between different versions of the same browser.
+            Any permission may stop working after an update.
+
+            Here are some permissions that may be supported by some browsers:
             - `'accelerometer'`
-            - `'accessibility-events'`
             - `'ambient-light-sensor'`
             - `'background-sync'`
             - `'camera'`
@@ -14202,9 +14216,9 @@ def close(self, *, reason: typing.Optional[str] = None) -> None:
         In case this browser is connected to, clears all created contexts belonging to this browser and disconnects from
         the browser server.
 
-        **NOTE** This is similar to force quitting the browser. Therefore, you should call `browser_context.close()`
-        on any `BrowserContext`'s you explicitly created earlier with `browser.new_context()` **before** calling
-        `browser.close()`.
+        **NOTE** This is similar to force-quitting the browser. To close pages gracefully and ensure you receive page close
+        events, call `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
 
         The `Browser` object itself is considered to be disposed and cannot be used anymore.
 
@@ -14389,7 +14403,7 @@ def launch(
         channel : Union[str, None]
             Browser distribution channel.
 
-            Use "chromium" to [opt in to new headless mode](../browsers.md#opt-in-to-new-headless-mode).
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
 
             Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
             "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
@@ -14549,7 +14563,7 @@ def launch_persistent_context(
         channel : Union[str, None]
             Browser distribution channel.
 
-            Use "chromium" to [opt in to new headless mode](../browsers.md#opt-in-to-new-headless-mode).
+            Use "chromium" to [opt in to new headless mode](../browsers.md#chromium-new-headless-mode).
 
             Use "chrome", "chrome-beta", "chrome-dev", "chrome-canary", "msedge", "msedge-beta", "msedge-dev", or
             "msedge-canary" to use branded [Google Chrome and Microsoft Edge](../browsers.md#google-chrome--microsoft-edge).
@@ -15578,7 +15592,6 @@ def dispatch_event(
         You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
 
         ```py
-        # note you can only create data_transfer in chromium and firefox
         data_transfer = page.evaluate_handle(\"new DataTransfer()\")
         locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
         ```
@@ -16514,18 +16527,22 @@ def or_(self, locator: "Locator") -> "Locator":
 
         Creates a locator matching all elements that match one or both of the two locators.
 
-        Note that when both locators match something, the resulting locator will have multiple matches and violate
-        [locator strictness](https://playwright.dev/python/docs/locators#strictness) guidelines.
+        Note that when both locators match something, the resulting locator will have multiple matches, potentially causing
+        a [locator strictness](https://playwright.dev/python/docs/locators#strictness) violation.
 
         **Usage**
 
         Consider a scenario where you'd like to click on a \"New email\" button, but sometimes a security settings dialog
         shows up instead. In this case, you can wait for either a \"New email\" button, or a dialog and act accordingly.
 
+        **NOTE** If both \"New email\" button and security dialog appear on screen, the \"or\" locator will match both of them,
+        possibly throwing the [\"strict mode violation\" error](https://playwright.dev/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
         ```py
         new_email = page.get_by_role(\"button\", name=\"New\")
         dialog = page.get_by_text(\"Confirm security settings\")
-        expect(new_email.or_(dialog)).to_be_visible()
+        expect(new_email.or_(dialog).first).to_be_visible()
         if (dialog.is_visible()):
           page.get_by_role(\"button\", name=\"Dismiss\").click()
         new_email.click()
@@ -16958,7 +16975,9 @@ def is_disabled(self, *, timeout: typing.Optional[float] = None) -> bool:
     def is_editable(self, *, timeout: typing.Optional[float] = None) -> bool:
         """Locator.is_editable
 
-        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable). If the target element is not an `<input>`,
+        `<textarea>`, `<select>`, `[contenteditable]` and does not have a role allowing `[aria-readonly]`, this method
+        throws an error.
 
         **NOTE** If you need to assert that an element is editable, prefer `locator_assertions.to_be_editable()` to
         avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
@@ -19201,24 +19220,26 @@ def to_have_class(
     ) -> None:
         """LocatorAssertions.to_have_class
 
-        Ensures the `Locator` points to an element with given CSS classes. This needs to be a full match or using a relaxed
-        regular expression.
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes or perform partial matches, use a regular expression:
 
         **Usage**
 
         ```html
-        <div class='selected row' id='component'></div>
+        <div class='middle selected row' id='component'></div>
         ```
 
         ```py
         from playwright.sync_api import expect
 
         locator = page.locator(\"#component\")
-        expect(locator).to_have_class(re.compile(r\"selected\"))
-        expect(locator).to_have_class(\"selected row\")
+        expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
+        expect(locator).to_have_class(\"middle selected row\")
         ```
 
-        Note that if array is passed as an expected value, entire lists of elements can be asserted:
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
 
         ```py
         from playwright.sync_api import expect
@@ -19821,6 +19842,7 @@ def to_be_checked(
         *,
         timeout: typing.Optional[float] = None,
         checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
     ) -> None:
         """LocatorAssertions.to_be_checked
 
@@ -19840,11 +19862,20 @@ def to_be_checked(
         timeout : Union[float, None]
             Time to retry the assertion for in milliseconds. Defaults to `5000`.
         checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
         """
         __tracebackhide__ = True
 
         return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.to_be_checked(timeout=timeout, checked=checked))
+            self._sync(
+                self._impl_obj.to_be_checked(
+                    timeout=timeout, checked=checked, indeterminate=indeterminate
+                )
+            )
         )
 
     def not_to_be_attached(
@@ -20552,6 +20583,76 @@ def to_have_role(
             self._sync(self._impl_obj.to_have_role(role=role, timeout=timeout))
         )
 
+    def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
+
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
+
+        **Usage**
+
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_accessible_error_message(
+                    errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
+    def not_to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
+
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
+
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_accessible_error_message(
+                    errorMessage=error_message, ignoreCase=ignore_case, timeout=timeout
+                )
+            )
+        )
+
     def not_to_have_role(
         self,
         role: Literal[
diff --git a/setup.py b/setup.py
index f4c93dc3c..fc3933d79 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
 import zipfile
 from typing import Dict
 
-driver_version = "1.49.1"
+driver_version = "1.50.0-beta-1738235262000"
 
 base_wheel_bundles = [
     {
diff --git a/tests/async/test_assertions.py b/tests/async/test_assertions.py
index dc0a1e615..06292aa9b 100644
--- a/tests/async/test_assertions.py
+++ b/tests/async/test_assertions.py
@@ -593,11 +593,20 @@ async def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page)
 
 async def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    await page.set_content("<input></input><button disabled>Text</button>")
-    await expect(page.locator("button")).not_to_be_editable()
+    await page.set_content("<input></input>")
     await expect(page.locator("input")).to_be_editable()
-    with pytest.raises(AssertionError, match="Locator expected to be editable"):
-        await expect(page.locator("button")).to_be_editable(timeout=100)
+
+
+async def test_assertions_locator_to_be_editable_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        await expect(page.locator("button")).not_to_be_editable()
 
 
 async def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
@@ -983,6 +992,64 @@ async def test_to_have_accessible_name(page: Page) -> None:
         re.compile(r"hello"), ignore_case=True
     )
 
+    await page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    await expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+async def test_to_have_accessible_error_message(page: Page) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    await expect(locator).to_have_accessible_error_message("Hello")
+    await expect(locator).not_to_have_accessible_error_message("hello")
+    await expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+async def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    await expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
 
 async def test_to_have_accessible_description(page: Page) -> None:
     await page.set_content('<div role="button" aria-description="Hello"></div>')
@@ -996,6 +1063,14 @@ async def test_to_have_accessible_description(page: Page) -> None:
         re.compile(r"hello"), ignore_case=True
     )
 
+    await page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    await expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
 
 async def test_to_have_role(page: Page) -> None:
     await page.set_content('<div role="button">Button!</div>')
diff --git a/tests/async/test_locators.py b/tests/async/test_locators.py
index b12a25a56..385538461 100644
--- a/tests/async/test_locators.py
+++ b/tests/async/test_locators.py
@@ -128,15 +128,27 @@ async def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> No
     )
 
     div = page.locator("div")
-    assert await div.is_enabled() is True
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        assert await div.is_enabled()
     assert await div.is_disabled() is False
 
     button1 = page.locator(':text("button1")')
-    assert await button1.is_enabled() is False
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        assert await button1.is_enabled()
     assert await button1.is_disabled() is True
 
     button1 = page.locator(':text("button2")')
-    assert await button1.is_enabled() is True
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        assert await button1.is_enabled()
     assert await button1.is_disabled() is False
 
 
diff --git a/tests/async/test_tracing.py b/tests/async/test_tracing.py
index 88db1577e..bb39f96f4 100644
--- a/tests/async/test_tracing.py
+++ b/tests/async/test_tracing.py
@@ -169,8 +169,6 @@ async def _handle_response(response: Response) -> None:
     assert events[0]["type"] == "context-options"
     assert get_trace_actions(events) == [
         "Page.goto",
-        "Request.all_headers",
-        "Response.text",
         "Page.close",
     ]
 
diff --git a/tests/sync/test_assertions.py b/tests/sync/test_assertions.py
index 6f27e0a25..6aaffd49b 100644
--- a/tests/sync/test_assertions.py
+++ b/tests/sync/test_assertions.py
@@ -502,6 +502,31 @@ def test_assertions_locator_to_be_checked(page: Page, server: Server) -> None:
     expect(my_checkbox).to_be_checked()
 
 
+def test_assertions_boolean_checked_with_intermediate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    expect(page.locator("input")).to_be_checked(indeterminate=True)
+
+
+def test_assertions_boolean_checked_with_intermediate_true_and_checked(
+    page: Page,
+) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    with pytest.raises(
+        Error, match="Can't assert indeterminate and checked at the same time"
+    ):
+        expect(page.locator("input")).to_be_checked(checked=False, indeterminate=True)
+
+
+def test_assertions_boolean_fail_with_indeterminate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    with pytest.raises(
+        AssertionError, match="LocatorAssertions.to_be_checked with timeout 1000ms"
+    ):
+        expect(page.locator("input")).to_be_checked(indeterminate=True, timeout=1000)
+
+
 def test_assertions_locator_to_be_disabled_enabled(page: Page, server: Server) -> None:
     page.goto(server.EMPTY_PAGE)
     page.set_content("<input type=checkbox>")
@@ -567,11 +592,18 @@ def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page) -> Non
 
 def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
     page.goto(server.EMPTY_PAGE)
-    page.set_content("<input></input><button disabled>Text</button>")
-    expect(page.locator("button")).not_to_be_editable()
+    page.set_content("<input></input>")
     expect(page.locator("input")).to_be_editable()
-    with pytest.raises(AssertionError, match="Locator expected to be editable"):
-        expect(page.locator("button")).to_be_editable(timeout=100)
+
+
+def test_assertions_locator_to_be_editable_throws(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        expect(page.locator("button")).not_to_be_editable()
 
 
 def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
@@ -912,3 +944,102 @@ def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
         )
     finally:
         expect.set_options(timeout=5_000)
+
+
+def test_to_have_accessible_name(page: Page) -> None:
+    page.set_content('<div role="button" aria-label="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_name("Hello")
+    expect(locator).not_to_have_accessible_name("hello")
+    expect(locator).to_have_accessible_name("hello", ignore_case=True)
+    expect(locator).to_have_accessible_name(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_name(re.compile(r"hello"))
+    expect(locator).to_have_accessible_name(re.compile(r"hello"), ignore_case=True)
+
+    page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+def test_to_have_accessible_error_message(page: Page) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    expect(locator).to_have_accessible_error_message("Hello")
+    expect(locator).not_to_have_accessible_error_message("hello")
+    expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
+
+def test_to_have_accessible_description(page: Page) -> None:
+    page.set_content('<div role="button" aria-description="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_description("Hello")
+    expect(locator).not_to_have_accessible_description("hello")
+    expect(locator).to_have_accessible_description("hello", ignore_case=True)
+    expect(locator).to_have_accessible_description(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_description(re.compile(r"hello"))
+    expect(locator).to_have_accessible_description(
+        re.compile(r"hello"), ignore_case=True
+    )
+
+    page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
+
+def test_to_have_role(page: Page) -> None:
+    page.set_content('<div role="button">Button!</div>')
+    expect(page.locator("div")).to_have_role("button")
+    expect(page.locator("div")).not_to_have_role("checkbox")
+    with pytest.raises(Error) as excinfo:
+        expect(page.locator("div")).to_have_role(re.compile(r"button|checkbox"))  # type: ignore
+    assert '"role" argument in to_have_role must be a string' in str(excinfo.value)
diff --git a/tests/sync/test_locators.py b/tests/sync/test_locators.py
index 4ed1b578a..f3a1e7496 100644
--- a/tests/sync/test_locators.py
+++ b/tests/sync/test_locators.py
@@ -126,15 +126,27 @@ def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> None:
     )
 
     div = page.locator("div")
-    assert div.is_enabled() is True
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        div.is_enabled()
     assert div.is_disabled() is False
 
     button1 = page.locator(':text("button1")')
-    assert button1.is_enabled() is False
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        assert button1.is_enabled()
     assert button1.is_disabled() is True
 
     button1 = page.locator(':text("button2")')
-    assert button1.is_enabled() is True
+    with pytest.raises(
+        Error,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        assert button1.is_enabled()
     assert button1.is_disabled() is False
 
 
diff --git a/tests/sync/test_tracing.py b/tests/sync/test_tracing.py
index 882521b3f..9308d5d0a 100644
--- a/tests/sync/test_tracing.py
+++ b/tests/sync/test_tracing.py
@@ -162,8 +162,6 @@ def _handle_response(response: Response) -> None:
     assert events[0]["type"] == "context-options"
     assert get_trace_actions(events) == [
         "Page.goto",
-        "Request.all_headers",
-        "Response.text",
         "Page.close",
     ]