@widgex/wgx 0.0.0-stage → 0.4.2

package/python/cdp_page.py

@@ -0,0 +1,363 @@
+"""
+cdp_page.py — Minimal CDP page wrapper over a raw WebSocket connection.
+
+Connects directly to a Chrome DevTools Protocol target via its
+webSocketDebuggerUrl. No Playwright dependency needed.
+"""
+
+import asyncio
+import base64
+import json
+import re
+from typing import Any, Callable, Awaitable
+
+import websockets
+
+# Product tokens a stock desktop Chrome sends. Anything else shaped like
+# `Name/Version` is an embedder stamp — `Electron/39.3.0`, `WidgeX/1.109.0-oss`.
+# Kept as an allow-list so the next fork that brands the UA is caught too.
+_STOCK_TOKENS = re.compile(r"^(Mozilla|AppleWebKit|Chrome|Safari)/")
+_PRODUCT_TOKEN = re.compile(r"^[A-Za-z][\w.+-]*/[\w.+-]+$")
+_CHROME_VERSION = re.compile(r"\bChrome/(\d+(?:\.\d+)*)")
+
+
+def sanitize_user_agent(ua: str) -> str:
+    """Strip non-Chrome product tokens from a User-Agent string.
+
+    `Electron/` is a default-deny token at the CDN edge, matched on the first
+    request before any JavaScript runs. The TLS and HTTP/2 fingerprints beneath
+    are already stock Chrome, so the header is the whole problem.
+
+    Non-Chromium strings are returned unchanged — there is nothing to normalise
+    them towards.
+    """
+    if not ua or not _CHROME_VERSION.search(ua):
+        return ua
+    kept = [
+        tok for tok in ua.split(" ")
+        if not _PRODUCT_TOKEN.match(tok) or _STOCK_TOKENS.match(tok)
+    ]
+    return re.sub(r"\s{2,}", " ", " ".join(kept)).strip()
+
+
+def _is_grease(brand: str) -> bool:
+    return "not" in brand.lower() and "brand" in brand.lower()
+
+
+def build_user_agent_metadata(ua: str, hints: dict | None) -> dict:
+    """Client hints consistent with a sanitised UA string.
+
+    A UA claiming Chrome/142 beside a ``Sec-CH-UA`` list carrying no "Google
+    Chrome" entry — which is all Electron reports — is a louder signal than the
+    token just removed, so the two have to move together. Real high-entropy
+    values are passed through untouched; only the brands are rewritten.
+    """
+    match = _CHROME_VERSION.search(ua)
+    full_version = match.group(1) if match else ""
+    major = full_version.split(".")[0] if full_version else ""
+    hints = hints or {}
+
+    # Preserve the browser's own GREASE brand: its purpose is to vary per build,
+    # and a value of ours would be a constant across every install.
+    pool = list(hints.get("brands") or []) + list(hints.get("fullVersionList") or [])
+    grease = next((b for b in pool if _is_grease(str(b.get("brand", "")))), None)
+
+    brands = []
+    full_list = []
+    if grease:
+        name = grease["brand"]
+        version = str(grease.get("version", ""))
+        brands.append({"brand": name, "version": version.split(".")[0] or version})
+        full = next(
+            (b for b in (hints.get("fullVersionList") or []) if b.get("brand") == name),
+            None,
+        )
+        full_list.append({"brand": name, "version": (full or grease).get("version", version)})
+    for name in ("Chromium", "Google Chrome"):
+        brands.append({"brand": name, "version": major})
+        full_list.append({"brand": name, "version": full_version})
+
+    if re.search(r"aarch64|arm64|ARM64", ua):
+        architecture, bitness = "arm", "64"
+    elif re.search(r"Win64|x86_64|x64|WOW64", ua):
+        architecture, bitness = "x86", "64"
+    else:
+        architecture, bitness = "x86", "32"
+
+    if "Windows" in ua:
+        platform = "Windows"
+    elif "Mac OS X" in ua or "Macintosh" in ua:
+        platform = "macOS"
+    elif "Android" in ua:
+        platform = "Android"
+    elif "CrOS" in ua:
+        platform = "Chrome OS"
+    else:
+        platform = "Linux"
+
+    return {
+        "brands": brands,
+        "fullVersionList": full_list,
+        "fullVersion": full_version,
+        "platform": hints.get("platform") or platform,
+        "platformVersion": hints.get("platformVersion") or "",
+        "architecture": hints.get("architecture") or architecture,
+        "model": hints.get("model") or "",
+        "mobile": bool(hints.get("mobile", False)),
+        "bitness": hints.get("bitness") or bitness,
+        "wow64": bool(hints.get("wow64", False)),
+    }
+
+
+_HIGH_ENTROPY_EXPRESSION = """(navigator.userAgentData
+  ? navigator.userAgentData.getHighEntropyValues(
+      ['platform','platformVersion','architecture','bitness','model','fullVersionList'])
+      .then(v => ({ ...v, brands: navigator.userAgentData.brands }))
+      .catch(() => null)
+  : null)"""
+
+
+class CdpPage:
+    """Raw CDP client for a single page target."""
+
+    def __init__(self, ws_url: str):
+        self._ws_url = ws_url
+        self._ws = None  # WebSocket connection
+        self._next_id = 1
+        self._pending: dict[int, asyncio.Future] = {}
+        self._event_handlers: dict[str, list[Callable]] = {}
+        self._url = ""
+        self._reader_task: asyncio.Task | None = None
+
+    # ── Properties ────────────────────────────────────────────────
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    # ── Lifecycle ─────────────────────────────────────────────────
+
+    async def connect(self) -> None:
+        """Open WebSocket, enable domains, start reader loop."""
+        self._ws = await asyncio.wait_for(
+            websockets.connect(
+                self._ws_url,
+                max_size=50 * 1024 * 1024,  # 50 MB for screenshots
+            ),
+            timeout=10,
+        )
+        self._reader_task = asyncio.create_task(self._reader_loop())
+
+        # Enable core domains
+        await self.send("Page.enable")
+        await self.send("Runtime.enable")
+        await self.send("Network.enable")
+
+        await self._apply_user_agent_override()
+
+        # Track URL from frame navigations
+        self.on("Page.frameNavigated", self._on_frame_navigated)
+
+        # Get initial URL
+        try:
+            tree = await self.send("Page.getFrameTree")
+            frame = tree.get("frameTree", {}).get("frame", {})
+            self._url = frame.get("url", "")
+        except Exception:
+            pass
+
+    async def _apply_user_agent_override(self) -> None:
+        """Present as the Chromium we are, rather than as Electron.
+
+        Best effort: a failure here costs stealth, not function, so it must never
+        break the connection.
+        """
+        try:
+            # Browser-process command, so it answers before any page is loaded.
+            version = await self.send("Browser.getVersion", timeout=5)
+            real_ua = str(version.get("userAgent") or "")
+        except Exception:
+            return
+        if not real_ua:
+            return
+
+        user_agent = sanitize_user_agent(real_ua)
+        if user_agent == real_ua:
+            return
+
+        try:
+            hints = await self.evaluate(_HIGH_ENTROPY_EXPRESSION)
+        except Exception:
+            hints = None
+
+        params = {
+            "userAgent": user_agent,
+            "userAgentMetadata": build_user_agent_metadata(user_agent, hints),
+        }
+        try:
+            await self.send("Emulation.setUserAgentOverride", params, timeout=5)
+        except Exception:
+            # Target rejects the metadata argument; the string alone still fixes
+            # the header the edge rules match on.
+            try:
+                await self.send(
+                    "Emulation.setUserAgentOverride", {"userAgent": user_agent}, timeout=5
+                )
+            except Exception:
+                pass
+
+    async def close(self) -> None:
+        """Close WebSocket and cancel reader."""
+        if self._reader_task:
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except (asyncio.CancelledError, Exception):
+                pass
+            self._reader_task = None
+
+        if self._ws:
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+        # Reject pending requests
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(ConnectionError("CDP connection closed"))
+        self._pending.clear()
+
+    # ── High-level API ────────────────────────────────────────────
+
+    async def title(self) -> str:
+        """Get the page title via Runtime.evaluate."""
+        result = await self.evaluate("document.title")
+        return str(result) if result is not None else ""
+
+    async def goto(self, url: str, timeout: float = 30) -> None:
+        """Navigate to a URL and wait for DOMContentLoaded."""
+        dom_loaded = asyncio.get_event_loop().create_future()
+
+        def on_dom_loaded(params: dict) -> None:
+            if not dom_loaded.done():
+                dom_loaded.set_result(True)
+
+        self.on("Page.domContentEventFired", on_dom_loaded)
+        try:
+            await self.send("Page.navigate", {"url": url})
+            await asyncio.wait_for(dom_loaded, timeout=timeout)
+        finally:
+            self.off("Page.domContentEventFired", on_dom_loaded)
+
+    async def screenshot(self) -> bytes:
+        """Capture a PNG screenshot, returned as raw bytes."""
+        result = await self.send("Page.captureScreenshot", {"format": "png"})
+        return base64.b64decode(result["data"])
+
+    async def evaluate(self, expression: str) -> Any:
+        """Evaluate a JS expression and return the result value."""
+        result = await self.send("Runtime.evaluate", {
+            "expression": expression,
+            "returnByValue": True,
+            "awaitPromise": True,
+        })
+        exception = result.get("exceptionDetails")
+        if exception:
+            text = exception.get("text", "")
+            desc = exception.get("exception", {}).get("description", "")
+            raise RuntimeError(f"JS error: {desc or text}")
+        return result.get("result", {}).get("value")
+
+    # ── Low-level CDP ─────────────────────────────────────────────
+
+    async def send(self, method: str, params: dict | None = None, timeout: float = 30) -> dict:
+        """Send a CDP command and wait for its response."""
+        if not self._ws:
+            raise ConnectionError("Not connected")
+
+        msg_id = self._next_id
+        self._next_id += 1
+
+        future: asyncio.Future = asyncio.get_event_loop().create_future()
+        self._pending[msg_id] = future
+
+        message = {"id": msg_id, "method": method}
+        if params:
+            message["params"] = params
+
+        await self._ws.send(json.dumps(message))
+
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError:
+            self._pending.pop(msg_id, None)
+            raise TimeoutError(f"CDP command {method} timed out after {timeout}s")
+
+    def on(self, event: str, handler: Callable) -> None:
+        """Register a CDP event handler."""
+        self._event_handlers.setdefault(event, []).append(handler)
+
+    def off(self, event: str, handler: Callable) -> None:
+        """Remove a CDP event handler."""
+        handlers = self._event_handlers.get(event, [])
+        try:
+            handlers.remove(handler)
+        except ValueError:
+            pass
+
+    # ── Internal ──────────────────────────────────────────────────
+
+    def _on_frame_navigated(self, params: dict) -> None:
+        """Track URL from top-level frame navigations."""
+        frame = params.get("frame", {})
+        # Only track top-level frame (no parentId)
+        if not frame.get("parentId"):
+            self._url = frame.get("url", self._url)
+
+    async def _reader_loop(self) -> None:
+        """Read messages from WebSocket and dispatch to pending/handlers."""
+        try:
+            async for raw in self._ws:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+
+                # Response to a command
+                if "id" in msg:
+                    msg_id = msg["id"]
+                    future = self._pending.pop(msg_id, None)
+                    if future and not future.done():
+                        if "error" in msg:
+                            future.set_exception(
+                                RuntimeError(f"CDP error: {msg['error'].get('message', str(msg['error']))}")
+                            )
+                        else:
+                            future.set_result(msg.get("result", {}))
+
+                # CDP event
+                elif "method" in msg:
+                    method = msg["method"]
+                    params = msg.get("params", {})
+                    for handler in self._event_handlers.get(method, []):
+                        try:
+                            result = handler(params)
+                            if asyncio.iscoroutine(result):
+                                await result
+                        except Exception:
+                            pass
+
+        except websockets.exceptions.ConnectionClosed:
+            pass
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            pass
+        finally:
+            # Reject all pending on disconnect
+            for fut in self._pending.values():
+                if not fut.done():
+                    fut.set_exception(ConnectionError("CDP WebSocket closed"))
+            self._pending.clear()

package/python/harness_check.py

@@ -0,0 +1,77 @@
+"""Run one hard-transition check for a WidgeX daemon state machine.
+
+Usage:
+    python daemon_check.py <check_file> <function_name> <context_json>
+
+Loads <check_file> as a module, calls <function_name>, and prints a single
+result line to stdout:
+
+    WIDGEX_CHECK:{"ok": true, "value": true}
+    WIDGEX_CHECK:{"ok": false, "error": "..."}
+
+The function is called with the context dict if it declares a parameter, and
+with no arguments otherwise. Its return value is coerced with bool().
+
+This runs OUTSIDE the xactor sandbox, in its own short-lived process: the
+sandbox blanket-denies imports from agent-supplied code, and a check script is
+user-authored configuration rather than agent output. The caller is responsible
+for confining <check_file> to the machine directory.
+"""
+import inspect
+import json
+import sys
+
+
+def _emit(payload):
+    sys.stdout.write("WIDGEX_CHECK:" + json.dumps(payload) + "\n")
+    sys.stdout.flush()
+
+
+def main(argv):
+    if len(argv) != 4:
+        _emit({"ok": False, "error": "expected <check_file> <function> <context_json>"})
+        return 2
+
+    check_file, function_name, context_json = argv[1], argv[2], argv[3]
+
+    try:
+        context = json.loads(context_json)
+    except ValueError as exc:
+        _emit({"ok": False, "error": "bad context json: %s" % exc})
+        return 2
+
+    try:
+        import importlib.util
+
+        spec = importlib.util.spec_from_file_location("widgex_daemon_check", check_file)
+        if spec is None or spec.loader is None:
+            _emit({"ok": False, "error": "cannot load %s" % check_file})
+            return 1
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    except Exception as exc:  # noqa: BLE001 - any import-time failure is a failed check
+        _emit({"ok": False, "error": "%s: %s" % (type(exc).__name__, exc)})
+        return 1
+
+    fn = getattr(module, function_name, None)
+    if fn is None or not callable(fn):
+        _emit({"ok": False, "error": "%s has no callable %s" % (check_file, function_name)})
+        return 1
+
+    try:
+        takes_arg = len(inspect.signature(fn).parameters) >= 1
+    except (TypeError, ValueError):
+        takes_arg = False
+
+    try:
+        value = fn(context) if takes_arg else fn()
+    except Exception as exc:  # noqa: BLE001 - a raising check is a false check
+        _emit({"ok": False, "error": "%s: %s" % (type(exc).__name__, exc)})
+        return 1
+
+    _emit({"ok": True, "value": bool(value)})
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/python/requirements.txt

@@ -0,0 +1 @@
+websockets>=12.0

package/python/test_line_endings.py

@@ -0,0 +1,185 @@
+"""Line-ending preservation in StdlibAPI's file tools.
+
+There is no Python test harness in this tree — no pytest, no conftest, no
+test_*.py, and requirements.txt lists only `websockets`. So this is deliberately
+self-contained: stdlib `unittest`, no third-party imports, runnable directly.
+
+    cd widgex-ide/extension/python && python test_line_endings.py
+
+What it pins down is that edit_file no longer rewrites a CRLF file's every line
+ending as a side effect of a three-character edit, and — just as important —
+that fixing that did not cost us any matching. Every assertion here is at the
+byte level, because the whole bug was invisible at the string level.
+"""
+
+import asyncio
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from xactor.stdlib_api import StdlibAPI, _dominant_eol  # noqa: E402
+
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+class LineEndingCase(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.mkdtemp(prefix="widgex-eol-")
+        # bridge=None: the journal calls are fail-open and no-op without one.
+        self.api = StdlibAPI(cwd=self.dir, bridge=None)
+
+    def write_bytes(self, name, data: bytes) -> str:
+        path = os.path.join(self.dir, name)
+        with open(path, "wb") as f:
+            f.write(data)
+        return path
+
+    def read_bytes(self, path) -> bytes:
+        with open(path, "rb") as f:
+            return f.read()
+
+    # -- the bug itself ----------------------------------------------
+
+    def test_crlf_file_stays_crlf_and_only_intended_bytes_change(self):
+        """The headline case: a small edit to a big CRLF file."""
+        lines = [f"line {i} of the file" for i in range(500)]
+        lines[240] = "const target = FOO;"
+        original = ("\r\n".join(lines) + "\r\n").encode("utf-8")
+        path = self.write_bytes("big.ts", original)
+
+        msg = run(self.api.edit_file(path, "FOO", "BAR"))
+        self.assertIn("Replaced 1", msg)
+
+        after = self.read_bytes(path)
+        # Not "roughly the same" — exactly the original with three bytes swapped.
+        self.assertEqual(after, original.replace(b"FOO", b"BAR", 1))
+        self.assertEqual(after.count(b"\r\n"), 500)
+        self.assertEqual(after.count(b"\n"), 500)  # i.e. zero bare LF
+
+    def test_lf_file_stays_lf(self):
+        original = b"alpha\nbeta\ngamma\n"
+        path = self.write_bytes("plain.py", original)
+
+        run(self.api.edit_file(path, "beta", "delta"))
+
+        after = self.read_bytes(path)
+        self.assertEqual(after, b"alpha\ndelta\ngamma\n")
+        self.assertNotIn(b"\r", after)
+
+    def test_multiline_edit_in_crlf_file_writes_crlf_for_new_lines(self):
+        """A replacement that adds lines gets the file's endings, not LF."""
+        original = b"one\r\ntwo\r\nthree\r\n"
+        path = self.write_bytes("multi.txt", original)
+
+        # An LF anchor and an LF replacement — what an agent actually sends.
+        run(self.api.edit_file(path, "one\ntwo", "one\nONE-AND-A-HALF\ntwo"))
+
+        self.assertEqual(
+            self.read_bytes(path),
+            b"one\r\nONE-AND-A-HALF\r\ntwo\r\nthree\r\n",
+        )
+
+    # -- no matching regression --------------------------------------
+
+    def test_lf_anchor_matches_crlf_file(self):
+        """The anchors agents actually compute are LF. They must keep matching.
+
+        read_file joins lines with LF whatever is on disk, so this is the normal
+        path on any Windows checkout, not an edge case.
+        """
+        path = self.write_bytes("anchor.ts", b"function f() {\r\n  return 1;\r\n}\r\n")
+        msg = run(self.api.edit_file(path, "function f() {\n  return 1;\n}", "function f() {\n  return 2;\n}"))
+        self.assertIn("Replaced 1", msg)
+        self.assertEqual(self.read_bytes(path), b"function f() {\r\n  return 2;\r\n}\r\n")
+
+    def test_crlf_anchor_also_matches_crlf_file(self):
+        """A caller who quotes the raw bytes is not punished for it either."""
+        path = self.write_bytes("anchor2.ts", b"a\r\nb\r\nc\r\n")
+        msg = run(self.api.edit_file(path, "a\r\nb", "a\r\nB"))
+        self.assertIn("Replaced 1", msg)
+        self.assertEqual(self.read_bytes(path), b"a\r\nB\r\nc\r\n")
+
+    def test_anchor_taken_from_read_file_output_matches_once_stripped(self):
+        path = self.write_bytes("numbered.py", b"import os\nimport sys\nprint(1)\n")
+        numbered = run(self.api.read_file(path))
+        # Strip the '%6d\t' prefix, as read_file's docstring now tells you to.
+        anchor = "\n".join(ln.split("\t", 1)[1] for ln in numbered.split("\n")[:2])
+        msg = run(self.api.edit_file(path, anchor, "import sys"))
+        self.assertIn("Replaced 1", msg)
+
+    def test_unstripped_read_file_output_is_diagnosed(self):
+        path = self.write_bytes("numbered2.py", b"import os\nimport sys\n")
+        numbered = run(self.api.read_file(path))
+        msg = run(self.api.edit_file(path, numbered, "x"))
+        self.assertIn("not found", msg)
+        self.assertIn("line numbers", msg)
+
+    def test_replace_all_and_not_unique_still_behave(self):
+        path = self.write_bytes("dup.txt", b"x\r\nx\r\nx\r\n")
+        msg = run(self.api.edit_file(path, "x", "y"))
+        self.assertIn("found 3 times", msg)
+        self.assertEqual(self.read_bytes(path), b"x\r\nx\r\nx\r\n")  # untouched
+
+        msg = run(self.api.edit_file(path, "x", "y", replace_all=True))
+        self.assertIn("Replaced 3", msg)
+        self.assertEqual(self.read_bytes(path), b"y\r\ny\r\ny\r\n")
+
+    # -- mixed, and the degenerate shapes ----------------------------
+
+    def test_mixed_file_normalises_to_its_dominant_ending(self):
+        """One sentence: a mixed file is rewritten to whichever ending it has
+        more of (ties to LF), so the stray minority lines change and the
+        majority do not."""
+        original = b"a\r\nb\r\nc\r\nd\ne\r\n"  # 4 CRLF, 1 bare LF -> CRLF wins
+        path = self.write_bytes("mixed.txt", original)
+        run(self.api.edit_file(path, "a", "A"))
+        self.assertEqual(self.read_bytes(path), b"A\r\nb\r\nc\r\nd\r\ne\r\n")
+
+        original = b"a\nb\nc\nd\r\n"  # 3 LF, 1 CRLF -> LF wins
+        path = self.write_bytes("mixed2.txt", original)
+        run(self.api.edit_file(path, "a", "A"))
+        self.assertEqual(self.read_bytes(path), b"A\nb\nc\nd\n")
+
+    def test_dominant_eol_ties_and_degenerates(self):
+        self.assertEqual(_dominant_eol(""), "\n")
+        self.assertEqual(_dominant_eol("no terminator at all"), "\n")
+        self.assertEqual(_dominant_eol("a\r\nb\n"), "\n")  # 1-1 tie -> LF
+        self.assertEqual(_dominant_eol("a\r\nb\r\nc\n"), "\r\n")
+        self.assertEqual(_dominant_eol("classic\rmac\r"), "\n")
+
+    def test_single_line_no_terminator_crlf_file_untouched(self):
+        path = self.write_bytes("oneline.txt", b"just one line")
+        run(self.api.edit_file(path, "one", "1"))
+        self.assertEqual(self.read_bytes(path), b"just 1 line")
+
+    def test_lone_cr_passes_through(self):
+        """Classic-Mac \\r is not a convention we write, and not one we destroy."""
+        path = self.write_bytes("oldmac.txt", b"a\rb\rc\n")
+        run(self.api.edit_file(path, "b", "B"))
+        self.assertEqual(self.read_bytes(path), b"a\rB\rc\n")
+
+    # -- write_file's deliberately unchanged contract -----------------
+
+    def test_write_file_creates_lf(self):
+        path = os.path.join(self.dir, "new.txt")
+        run(self.api.write_file(path, "one\ntwo\n"))
+        self.assertEqual(self.read_bytes(path), b"one\ntwo\n")
+
+    def test_write_file_writes_exactly_what_it_is_given(self):
+        path = os.path.join(self.dir, "verbatim.txt")
+        run(self.api.write_file(path, "one\r\ntwo\r\n"))
+        self.assertEqual(self.read_bytes(path), b"one\r\ntwo\r\n")
+
+        # And overwriting a CRLF file with LF content honours the caller.
+        path = self.write_bytes("was_crlf.txt", b"a\r\nb\r\n")
+        run(self.api.write_file(path, "a\nb\n"))
+        self.assertEqual(self.read_bytes(path), b"a\nb\n")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/python/xactor/__init__.py

@@ -0,0 +1,18 @@
+"""XactorShell — Python Elementary API for humanized browser automation (Layers 1 & 2)."""
+
+from .dom import DOMSnapshot, HybridNode, HybridDiff
+from .api import ElementaryAPI
+from .states import PageState, LoadingState, Observation, Transition, Step, StateRegistry
+
+__all__ = [
+    "DOMSnapshot",
+    "HybridNode",
+    "HybridDiff",
+    "ElementaryAPI",
+    "PageState",
+    "LoadingState",
+    "Observation",
+    "Transition",
+    "Step",
+    "StateRegistry",
+]