helixwright 0.1.0__tar.gz

helixwright-0.1.0/PKG-INFO

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: helixwright
+Version: 0.1.0
+Summary: Python automation SDK for Helix Browser Local API and the private Helix RPC page-control plane.
+Author: Helix Browser
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://pypi.org/project/helixwright/
+Project-URL: Documentation, https://pypi.org/project/helixwright/
+Keywords: automation,browser,fingerprint,chromium,local-api,helix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Helixwright
+
+Helixwright is the Python automation SDK for Helix Browser.
+
+It does not create fingerprints locally, manage browser profile folders, or
+start `chrome.exe` directly. Profile creation, fingerprint generation, proxy
+configuration, browser launch, and profile sync are delegated to Helix Browser
+Desktop through its Local API. Page actions then use the private Helix RPC
+control plane built into the Helix Chromium fork, not CDP, DevTools, WebDriver,
+Playwright, or Selenium.
+
+## Install
+
+```bash
+pip install helixwright
+```
+
+Requirements:
+
+1. Helix Browser Desktop is installed and running.
+2. The desktop app is logged in.
+3. The desktop Local API is available, usually at `http://127.0.0.1:59777`.
+4. The desktop build supports `/api/v1/automation/sessions`.
+
+Helixwright discovers the Local API from:
+
+```text
+%APPDATA%\Helix Browser\local_api.json
+```
+
+You can override it explicitly:
+
+```powershell
+$env:HELIX_LOCAL_API = "http://127.0.0.1:59777"
+```
+
+## Quick Start
+
+Reuse an existing Helix profile:
+
+```python
+import helixwright as hw
+
+with hw.launch(profile_id="profile_123", url="https://example.com") as page:
+    page.ele("#email").input("user@example.com")
+    page.ele("#submit").click()
+```
+
+Create or reuse a profile by `account_id`:
+
+```python
+import helixwright as hw
+
+with hw.launch(
+    "https://example.com",
+    account_id="shop-001",
+    name="Shop 001",
+    proxy="http://user:pass@127.0.0.1:7890",
+    fingerprint=hw.Fingerprint(locale="en-US", region="US", group="octo"),
+    update_existing=True,
+) as page:
+    page.wait_for("body", timeout=10_000)
+    print(page.title())
+```
+
+Use a reusable launch config:
+
+```python
+import helixwright as hw
+
+cfg = hw.LaunchConfig(
+    account_id="shop-002",
+    name="Shop 002",
+    url="https://example.com",
+    start_pages=["https://example.com", "https://example.com/login"],
+    proxy="http://127.0.0.1:7890",
+    fingerprint=hw.Fingerprint(locale="en-US", region="US"),
+    update_existing=True,
+)
+
+with hw.launch(config=cfg) as page:
+    page.ele("text=Login").click()
+```
+
+## Client API
+
+Use `Client` when you want to manage profiles, fingerprints, proxies, cores, or
+automation sessions explicitly:
+
+```python
+import helixwright as hw
+
+client = hw.Client()
+print(client.health())
+print(client.session())
+
+profile = client.profiles.ensure(
+    account_id="shop-003",
+    name="Shop 003",
+    proxy=hw.Proxy("http", "127.0.0.1", 7890),
+    fingerprint=hw.Fingerprint(locale="en-US", region="US"),
+    update_existing=True,
+)
+
+with profile.launch(url="https://example.com") as page:
+    print(page.url)
+```
+
+Common managers:
+
+```python
+client.profiles.list(page=1, size=20)
+client.profiles.get("profile_123")
+client.profiles.create(name="A", account_id="acct_A")
+client.profiles.ensure(account_id="acct_A")
+client.profiles.clone("profile_123", count=2)
+client.profiles.sync_up("profile_123")
+client.profiles.sync_down("profile_123")
+
+client.fingerprint.options()
+client.fingerprint.draw(account_id="acct_A", group="octo")
+client.fingerprint.serialize({"ua": "..."}, seed=123)
+client.fingerprint.redraw({"ua": "..."}, "ua")
+
+client.proxy.check("http://127.0.0.1:7890")
+client.cores.list()
+client.cores.ensure("chromium", "150")
+client.browser.active()
+client.browser.start("profile_123")
+client.browser.stop("profile_123")
+client.browser.stop_all()
+client.automation.list()
+client.automation.start("profile_123", url="https://example.com")
+client.automation.stop("auto_123")
+```
+
+## Launch Rules
+
+`hw.launch()` requires either `profile_id` or `account_id`/`account`.
+
+Important behavior:
+
+- `profile_id` means reuse that exact Helix profile.
+- `account_id` means find an existing profile by account ID, or create one
+  when `create=True`.
+- `fingerprint=hw.Fingerprint(...)` only sends creation hints to Helix Local
+  API. The SDK does not generate fingerprints itself.
+- `proxy` can be a string, dict, or `hw.Proxy`.
+- `start_pages` is passed to the Local API automation session.
+- `config=hw.LaunchConfig(...)` should not be mixed with explicit
+  `profile_id`, `account_id`, `name`, `proxy`, or `fingerprint` arguments.
+
+Unsupported legacy direct-launch arguments are rejected, including `chrome`,
+`user_data_dir`, `persona`, `seed`, `geoip`, and `extra_args`.
+
+## Errors
+
+Common error types:
+
+| Error | Meaning |
+| --- | --- |
+| `LocalApiUnavailable` | Helix Desktop is not running, the Local API address is wrong, or the port is unreachable. |
+| `DesktopNotLoggedIn` | Desktop is reachable but not logged in. |
+| `LocalApiError` | Local API returned a business error. |
+| `ProfileNotFound` | The requested profile does not exist. |
+| `AutomationEndpointUnavailable` | The desktop build did not return a usable automation RPC endpoint. |
+| `AutomationSessionNotFound` | The requested automation session does not exist. |
+| `TransportError` | The private page RPC connection failed, usually because the browser exited. |
+| `WaitTimeoutError` | A page wait condition timed out. |
+
+## Examples
+
+From the source repository:
+
+```powershell
+cd "E:\Helix Browser\repos\helixwright"
+python examples\99_offline_mock_demo.py
+```
+
+The offline demo does not need Helix Browser. It starts a mock Local API and
+mock RPC endpoint, then exercises the public SDK surface.
+
+Real desktop examples require Helix Browser Desktop to be running and logged in:
+
+```powershell
+python examples\00_helixwright_quickstart.py
+python examples\01_client_managers.py
+python examples\02_launch_config_and_actions.py
+```
+
+Useful environment variables:
+
+```powershell
+$env:HELIX_LOCAL_API = "http://127.0.0.1:59777"
+$env:HELIX_EXAMPLE_ACCOUNT = "demo-account"
+$env:HELIX_EXAMPLE_URL = "https://example.com"
+$env:HELIX_EXAMPLE_PROXY = "http://127.0.0.1:7890"
+$env:HELIX_EXAMPLE_TIMEOUT_MS = "30000"
+```
+
+## Development
+
+```powershell
+cd "E:\Helix Browser\repos\helixwright"
+pip install -e .
+python tests\ci.py
+```
+
+Build and validate a distribution:
+
+```powershell
+python -m build
+python -m twine check dist/*
+```
+
+## Boundary
+
+Helixwright is only the automation SDK. The authoritative source for profiles,
+fingerprints, proxies, browser core downloads, cloud sync, and launch lifecycle
+is Helix Browser Desktop plus its Local API.
+

helixwright-0.1.0/README.md

@@ -0,0 +1,221 @@
+# Helixwright
+
+Helixwright is the Python automation SDK for Helix Browser.
+
+It does not create fingerprints locally, manage browser profile folders, or
+start `chrome.exe` directly. Profile creation, fingerprint generation, proxy
+configuration, browser launch, and profile sync are delegated to Helix Browser
+Desktop through its Local API. Page actions then use the private Helix RPC
+control plane built into the Helix Chromium fork, not CDP, DevTools, WebDriver,
+Playwright, or Selenium.
+
+## Install
+
+```bash
+pip install helixwright
+```
+
+Requirements:
+
+1. Helix Browser Desktop is installed and running.
+2. The desktop app is logged in.
+3. The desktop Local API is available, usually at `http://127.0.0.1:59777`.
+4. The desktop build supports `/api/v1/automation/sessions`.
+
+Helixwright discovers the Local API from:
+
+```text
+%APPDATA%\Helix Browser\local_api.json
+```
+
+You can override it explicitly:
+
+```powershell
+$env:HELIX_LOCAL_API = "http://127.0.0.1:59777"
+```
+
+## Quick Start
+
+Reuse an existing Helix profile:
+
+```python
+import helixwright as hw
+
+with hw.launch(profile_id="profile_123", url="https://example.com") as page:
+    page.ele("#email").input("user@example.com")
+    page.ele("#submit").click()
+```
+
+Create or reuse a profile by `account_id`:
+
+```python
+import helixwright as hw
+
+with hw.launch(
+    "https://example.com",
+    account_id="shop-001",
+    name="Shop 001",
+    proxy="http://user:pass@127.0.0.1:7890",
+    fingerprint=hw.Fingerprint(locale="en-US", region="US", group="octo"),
+    update_existing=True,
+) as page:
+    page.wait_for("body", timeout=10_000)
+    print(page.title())
+```
+
+Use a reusable launch config:
+
+```python
+import helixwright as hw
+
+cfg = hw.LaunchConfig(
+    account_id="shop-002",
+    name="Shop 002",
+    url="https://example.com",
+    start_pages=["https://example.com", "https://example.com/login"],
+    proxy="http://127.0.0.1:7890",
+    fingerprint=hw.Fingerprint(locale="en-US", region="US"),
+    update_existing=True,
+)
+
+with hw.launch(config=cfg) as page:
+    page.ele("text=Login").click()
+```
+
+## Client API
+
+Use `Client` when you want to manage profiles, fingerprints, proxies, cores, or
+automation sessions explicitly:
+
+```python
+import helixwright as hw
+
+client = hw.Client()
+print(client.health())
+print(client.session())
+
+profile = client.profiles.ensure(
+    account_id="shop-003",
+    name="Shop 003",
+    proxy=hw.Proxy("http", "127.0.0.1", 7890),
+    fingerprint=hw.Fingerprint(locale="en-US", region="US"),
+    update_existing=True,
+)
+
+with profile.launch(url="https://example.com") as page:
+    print(page.url)
+```
+
+Common managers:
+
+```python
+client.profiles.list(page=1, size=20)
+client.profiles.get("profile_123")
+client.profiles.create(name="A", account_id="acct_A")
+client.profiles.ensure(account_id="acct_A")
+client.profiles.clone("profile_123", count=2)
+client.profiles.sync_up("profile_123")
+client.profiles.sync_down("profile_123")
+
+client.fingerprint.options()
+client.fingerprint.draw(account_id="acct_A", group="octo")
+client.fingerprint.serialize({"ua": "..."}, seed=123)
+client.fingerprint.redraw({"ua": "..."}, "ua")
+
+client.proxy.check("http://127.0.0.1:7890")
+client.cores.list()
+client.cores.ensure("chromium", "150")
+client.browser.active()
+client.browser.start("profile_123")
+client.browser.stop("profile_123")
+client.browser.stop_all()
+client.automation.list()
+client.automation.start("profile_123", url="https://example.com")
+client.automation.stop("auto_123")
+```
+
+## Launch Rules
+
+`hw.launch()` requires either `profile_id` or `account_id`/`account`.
+
+Important behavior:
+
+- `profile_id` means reuse that exact Helix profile.
+- `account_id` means find an existing profile by account ID, or create one
+  when `create=True`.
+- `fingerprint=hw.Fingerprint(...)` only sends creation hints to Helix Local
+  API. The SDK does not generate fingerprints itself.
+- `proxy` can be a string, dict, or `hw.Proxy`.
+- `start_pages` is passed to the Local API automation session.
+- `config=hw.LaunchConfig(...)` should not be mixed with explicit
+  `profile_id`, `account_id`, `name`, `proxy`, or `fingerprint` arguments.
+
+Unsupported legacy direct-launch arguments are rejected, including `chrome`,
+`user_data_dir`, `persona`, `seed`, `geoip`, and `extra_args`.
+
+## Errors
+
+Common error types:
+
+| Error | Meaning |
+| --- | --- |
+| `LocalApiUnavailable` | Helix Desktop is not running, the Local API address is wrong, or the port is unreachable. |
+| `DesktopNotLoggedIn` | Desktop is reachable but not logged in. |
+| `LocalApiError` | Local API returned a business error. |
+| `ProfileNotFound` | The requested profile does not exist. |
+| `AutomationEndpointUnavailable` | The desktop build did not return a usable automation RPC endpoint. |
+| `AutomationSessionNotFound` | The requested automation session does not exist. |
+| `TransportError` | The private page RPC connection failed, usually because the browser exited. |
+| `WaitTimeoutError` | A page wait condition timed out. |
+
+## Examples
+
+From the source repository:
+
+```powershell
+cd "E:\Helix Browser\repos\helixwright"
+python examples\99_offline_mock_demo.py
+```
+
+The offline demo does not need Helix Browser. It starts a mock Local API and
+mock RPC endpoint, then exercises the public SDK surface.
+
+Real desktop examples require Helix Browser Desktop to be running and logged in:
+
+```powershell
+python examples\00_helixwright_quickstart.py
+python examples\01_client_managers.py
+python examples\02_launch_config_and_actions.py
+```
+
+Useful environment variables:
+
+```powershell
+$env:HELIX_LOCAL_API = "http://127.0.0.1:59777"
+$env:HELIX_EXAMPLE_ACCOUNT = "demo-account"
+$env:HELIX_EXAMPLE_URL = "https://example.com"
+$env:HELIX_EXAMPLE_PROXY = "http://127.0.0.1:7890"
+$env:HELIX_EXAMPLE_TIMEOUT_MS = "30000"
+```
+
+## Development
+
+```powershell
+cd "E:\Helix Browser\repos\helixwright"
+pip install -e .
+python tests\ci.py
+```
+
+Build and validate a distribution:
+
+```powershell
+python -m build
+python -m twine check dist/*
+```
+
+## Boundary
+
+Helixwright is only the automation SDK. The authoritative source for profiles,
+fingerprints, proxies, browser core downloads, cloud sync, and launch lifecycle
+is Helix Browser Desktop plus its Local API.
+

helixwright-0.1.0/helixwright/__init__.py

@@ -0,0 +1,58 @@
+"""Helixwright automation SDK.
+
+The SDK talks to Helix Browser through the desktop Local API. It does not spawn
+Chrome, generate fingerprints, or manage browser profile directories by itself.
+"""
+
+from .client import Client, Profile, discover_base_url
+from .errors import (
+    AutomationEndpointUnavailable,
+    AutomationSessionNotFound,
+    DesktopNotLoggedIn,
+    ElementNotFoundError,
+    HelixwrightError,
+    LocalApiError,
+    LocalApiUnavailable,
+    LoginRejected,
+    ProfileNotFound,
+    ReachabilityError,
+    TransportError,
+    WaitTimeoutError,
+)
+from ._impl._network import Response, Route
+from ._impl._operator import El, NoneEl, Op
+from .launcher import HelixBrowser, attach, launch
+from .models import AutomationRpc, AutomationSession, Fingerprint, LaunchConfig, Proxy
+
+__all__ = [
+    "launch",
+    "attach",
+    "Client",
+    "Profile",
+    "Fingerprint",
+    "Proxy",
+    "LaunchConfig",
+    "AutomationRpc",
+    "AutomationSession",
+    "HelixBrowser",
+    "Op",
+    "El",
+    "NoneEl",
+    "Response",
+    "Route",
+    "discover_base_url",
+    "HelixwrightError",
+    "LocalApiError",
+    "LocalApiUnavailable",
+    "DesktopNotLoggedIn",
+    "ProfileNotFound",
+    "AutomationSessionNotFound",
+    "AutomationEndpointUnavailable",
+    "TransportError",
+    "ReachabilityError",
+    "ElementNotFoundError",
+    "WaitTimeoutError",
+    "LoginRejected",
+]
+
+__version__ = "0.1.0"

helixwright-0.1.0/helixwright/_impl/__init__.py

@@ -0,0 +1 @@
+"""Private implementation package (unstable internals). Import the public API from `helixwright`, not from here."""

helixwright-0.1.0/helixwright/_impl/_assertions.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+import json
+import time
+from ._errors import HelixwrightError
+
+# The accessibility matchers now read via NATIVE RPC helpers on the Locator (_aria_role /
+# _accessible_name / _accessible_description over get_attribute + element_property('tagName')),
+# so NO JS runs. They remain APPROXIMATE (heuristic, not Chromium's computed accessibility tree).
+
+
+class _AssertionsBase:
+    """Polling assertion base: shared timeout, negation (not_/is_not), and the poll loop."""
+
+    def __init__(self, target, timeout_ms=5000, is_not=False):
+        self._t = target
+        self._to = timeout_ms
+        self._not = is_not
+
+    @property
+    def not_(self):
+        return type(self)(self._t, self._to, not self._not)
+
+    is_not = not_
+
+    def _poll(self, pred, desc):
+        deadline = time.time() + self._to / 1000.0
+        last = None
+        while True:
+            try:
+                last = bool(pred())
+            except (HelixwrightError, TypeError, AttributeError):
+                # transient (element gone / null evaluate) -> failed-but-retryable, never crash
+                last = False
+            if last != self._not:
+                return
+            if time.time() >= deadline:
+                raise AssertionError("expect %s%s failed (last=%r)"
+                                     % ("not_." if self._not else "", desc, last))
+            time.sleep(0.08)
+
+
+class LocatorAssertions(_AssertionsBase):
+    """Assertions about a Locator — visibility, text, value, count, state."""
+
+    def to_be_visible(self):
+        self._poll(self._t.is_visible, "to_be_visible")
+
+    def to_be_hidden(self):
+        self._poll(lambda: not self._t.is_visible(), "to_be_hidden")
+
+    def to_be_enabled(self):
+        self._poll(self._t.is_enabled, "to_be_enabled")
+
+    def to_be_disabled(self):
+        self._poll(lambda: not self._t.is_enabled(), "to_be_disabled")
+
+    def to_have_text(self, txt):
+        self._poll(lambda: self._t.text().strip() == txt, "to_have_text(%r)" % txt)
+
+    def to_contain_text(self, txt):
+        self._poll(lambda: txt in self._t.text(), "to_contain_text(%r)" % txt)
+
+    def to_have_value(self, v):
+        self._poll(lambda: self._t.input_value() == v, "to_have_value(%r)" % v)
+
+    def to_have_count(self, n):
+        self._poll(lambda: self._t.count() == n, "to_have_count(%d)" % n)
+
+    def to_be_checked(self):
+        self._poll(self._t.is_checked, "to_be_checked")
+
+    def to_be_editable(self):
+        self._poll(self._t.is_editable, "to_be_editable")
+
+    def to_be_focused(self):
+        self._poll(self._t.is_focused, "to_be_focused")
+
+    def to_have_attribute(self, name, value=None):
+        def _p():
+            v = self._t.get_attribute(name)
+            return (v is not None) if value is None else (v == value)
+        self._poll(_p, "to_have_attribute(%r,%r)" % (name, value))
+
+    # --- Playwright-parity matchers (pure-Python over Locator.evaluate/get_attribute/count) ----
+    def to_have_class(self, value):
+        """The full class attribute equals |value| (Playwright string form)."""
+        self._poll(lambda: (self._t.get_attribute("class") or "") == value, "to_have_class(%r)" % value)
+
+    def to_contain_class(self, value):
+        """The class token list contains |value|."""
+        self._poll(lambda: value in (self._t.get_attribute("class") or "").split(),
+                   "to_contain_class(%r)" % value)
+
+    def to_have_id(self, id_):
+        self._poll(lambda: (self._t.get_attribute("id") or "") == id_, "to_have_id(%r)" % id_)
+
+    def to_have_css(self, name, value):
+        # [no-JS] native WebElement::GetComputedValue via Locator.computed_style.
+        self._poll(lambda: self._t.computed_style(name) == value, "to_have_css(%r,%r)" % (name, value))
+
+    def to_have_js_property(self, name, value):
+        self._poll(lambda: self._t.evaluate("el[%s]" % json.dumps(name)) == value,
+                   "to_have_js_property(%r,%r)" % (name, value))
+
+    def to_have_values(self, values):
+        """The selected <option> values of a multi-select equal |values| (list)."""
+        want = list(values)
+        self._poll(lambda: self._t.evaluate(
+            "Array.prototype.map.call(el.selectedOptions||[],function(o){return o.value;})") == want,
+            "to_have_values(%r)" % (want,))
+
+    def to_be_empty(self):
+        """No child elements and no text (Playwright to_be_empty). [no-JS] native InnerHTML()=="" check."""
+        self._poll(lambda: (self._t.inner_html() or "").strip() == "", "to_be_empty")
+
+    def to_be_attached(self):
+        self._poll(lambda: self._t.count() > 0, "to_be_attached")
+
+    def to_be_in_viewport(self):
+        # [no-JS] VisibleBoundsInWidget() is viewport-clipped, so IsVisible() == visible-in-viewport.
+        self._poll(self._t.is_visible, "to_be_in_viewport")
+
+    def to_have_role(self, role):
+        """APPROXIMATE computed ARIA role (explicit role attr or a tag heuristic — not the engine AOM).
+        [no-JS] via Locator._aria_role (get_attribute + element_property('tagName'))."""
+        self._poll(lambda: self._t._aria_role() == role, "to_have_role(%r)" % role)
+
+    def to_have_accessible_name(self, name):
+        """APPROXIMATE accessible name (aria-label/text/alt/title heuristic). [no-JS] via native RPCs."""
+        self._poll(lambda: (self._t._accessible_name() or "").strip() == name,
+                   "to_have_accessible_name(%r)" % name)
+
+    def to_have_accessible_description(self, desc):
+        """APPROXIMATE accessible description (title heuristic). [no-JS] via native RPC."""
+        self._poll(lambda: (self._t._accessible_description() or "").strip() == desc,
+                   "to_have_accessible_description(%r)" % desc)
+
+
+class PageAssertions(_AssertionsBase):
+    """Assertions about a Page — url, title."""
+
+    def _page(self):
+        # target is normally the Page; tolerate a Locator (resolve its page) for the
+        # combined Expect's back-compat.
+        t = self._t
+        return t if hasattr(t, "goto") else getattr(t, "_page", t)
+
+    def to_have_url(self, url):
+        self._poll(lambda: url in self._page().evaluate("location.href"),
+                   "to_have_url(%r)" % url)
+
+    def to_have_title(self, title):
+        self._poll(lambda: title in self._page().evaluate("document.title"),
+                   "to_have_title(%r)" % title)
+
+
+class Expect(LocatorAssertions, PageAssertions):
+    """Back-compat combined assertions (the public ``Expect`` export). Prefer ``expect()``,
+    which returns the precise LocatorAssertions / PageAssertions for the target."""
+
+
+def expect(target, timeout_ms=5000):
+    """Polling assertion proxy for |target|: a Page -> PageAssertions (url/title), a
+    Locator -> LocatorAssertions (visibility/text/value/state). Async facade objects
+    (AsyncPage/AsyncLocator) are unwrapped to their sync object (assertions are
+    synchronous). For a bare Element use page.locator(css) instead."""
+    inner = getattr(target, "_p", None)      # AsyncPage wraps the sync Page as _p
+    if inner is None:
+        inner = getattr(target, "_l", None)  # AsyncLocator wraps the sync Locator as _l
+    if inner is not None:
+        target = inner
+    if hasattr(target, "goto"):              # a Page
+        return PageAssertions(target, timeout_ms)
+    # Locator OR Element -> BOTH expose _as_locator() (Locator returns self; Element re-resolves to a
+    # Locator from its originating selector, or raises clearly for a selector-less Element). Resolve to
+    # a Locator so assertions POLL across re-render/detach (a fixed node_id snapshot can't survive one).
+    # We no longer inspect the .text descriptor to tell Element from Locator: that property-vs-method
+    # hack breaks once the two unify, and an instance .text read would fire a get_text RPC on a
+    # navigating page. _as_locator() is a plain method (no RPC) present on both.
+    loc_fn = getattr(target, "_as_locator", None)
+    if callable(loc_fn):
+        return LocatorAssertions(loc_fn(), timeout_ms)
+    raise HelixwrightError(
+        "expect() needs a Page, Locator, or selector-based Element; got %r" % type(target).__name__)