diff --git a/README.md b/README.md
index 6c234cb..c6563b8 100644
--- a/README.md
+++ b/README.md
@@ -290,88 +290,100 @@ from browser_cli import BrowserCLI
 b = BrowserCLI()
 ```
 
-Every CLI command has a corresponding SDK method. The call blocks until the browser responds and returns the data directly as a Python object.
+Commands are grouped into namespaces on the client (`b.tabs`, `b.dom`, `b.session`, ...). Each call blocks until the browser responds and returns the data directly as a Python object.
 
 ```python
-# Navigation
-b.open("https://example.com")
-tab = b.open_tab("https://example.com")      # returns a bound Tab object
-tab = b.open_tab("https://example.com", wait=True, timeout=10)
-b.open("https://example.com", background=True)
-b.open("https://example.com", window="work")
-b.reload()
-b.hard_reload()
-b.back()
-b.forward(tab_id=1234)
-b.focus_url("github")
+# Navigation  ── b.nav
+b.nav.open("https://example.com")
+b.nav.open("https://example.com", background=True)
+b.nav.open("https://example.com", window="work")
+b.nav.reload()
+b.nav.hard_reload()
+b.nav.back()
+b.nav.forward(tab_id=1234)
+b.nav.focus("github")
+b.nav.to(1234, "https://example.com")   # navigate a specific tab in place
+b.nav.search("google", "python asyncio")
 
-# Tabs
-tabs = b.tabs_list()          # list[Tab]; in multi-browser mode each tab.browser is set
-tabs = b.tabs()               # short alias for tabs_list()
-active = b.active_tab()       # active Tab object
-tab = b.tab(1234)             # tab by ID
-tab = b.find_tab("github")    # first matching tab or None
-tabs = b.find_tabs("github")  # alias for tabs_query()
-b.tabs_active(1234)
-b.tabs_close(1234)
-b.close_tab(tab)              # accepts Tab or tab ID
-b.tabs_close_inactive()
-b.tabs_close_duplicates()
-b.tabs_filter("youtube")      # list of matching tabs
-b.tabs_query("pull request")
-counts = b.tabs_count("github")  # int, or BrowserCounts(total=..., by_browser=...) in multi-browser mode
-html = b.tabs_html()          # full HTML string of active tab
-b.tabs_sort(by="domain")
-b.tabs_merge_windows()
-b.tabs_dedupe()
+# Tabs  ── b.tabs
+tabs = b.tabs.list()          # list[Tab]; in multi-browser mode each tab.browser is set
+tab = b.tabs.open("https://example.com")              # returns a bound Tab object
+tab = b.tabs.open("https://example.com", wait=True, timeout=10)
+active = b.tabs.active()      # active Tab object
+tab = b.tabs.get(1234)        # tab by ID
+tab = b.tabs.first("github")  # first matching tab or None
+b.tabs.activate(1234)
+b.tabs.close(1234)
+b.tabs.close(tab_ids=[1, 2, 3])  # close many in one round-trip (IDs or Tab objects)
+b.tabs.close_inactive()
+b.tabs.close_duplicates()
+b.tabs.filter("youtube")      # list of matching tabs
+b.tabs.query("pull request")
+counts = b.tabs.count("github")  # int, or BrowserCounts(total=..., by_browser=...) in multi-browser mode
+html = b.tabs.html()          # full HTML string of active tab
+b.tabs.sort(by="domain")
+b.tabs.merge_windows()
+b.tabs.dedupe()
 
 # Bound Tab helpers
-tab = b.active_tab()
+tab = b.tabs.active()
 tab.pin()
 tab.screenshot()
 tab.refresh()
 tab.wait_for_load(timeout=10)
 tab.watch_url(r"/done$")
 
-# Tab groups
-groups = b.group_list()       # list[Group]; in multi-browser mode each group.browser is set
-groups = b.groups()           # short alias for group_list()
-b.groups_create("research")  # plural alias for group_create()
-b.group_create("research")    # creates group, returns Group
-b.group_close(42)
-b.group_tabs(42)              # tabs inside a group
-b.group_count()               # int, or BrowserCounts(...) in multi-browser mode
+# Tab groups  ── b.groups
+groups = b.groups.list()      # list[Group]; in multi-browser mode each group.browser is set
+b.groups.create("research")   # creates group, returns Group
+b.groups.close(42)
+b.groups.tabs(42)             # tabs inside a group
+b.groups.add_tab(42, "https://example.com")
+b.groups.count()              # int, or BrowserCounts(...) in multi-browser mode
 
-# Windows
-windows = b.windows_list()    # in multi-browser mode each dict has a "browser" key
-b.windows_rename(1, "work")
-b.windows_open()
-b.windows_open("https://example.com")
-b.windows_close(1)
+# Windows  ── b.windows
+windows = b.windows.list()    # in multi-browser mode each dict has a "browser" key
+b.windows.rename(1, "work")
+b.windows.open()
+b.windows.open("https://example.com")
+b.windows.close(1)
 
-# DOM  (active tab must be http/https)
-elements = b.dom_query("h2")           # list of { tag, text, attrs }
-texts = b.dom_text(".article p")       # list of strings
-attrs = b.dom_attr("a", "href")        # list of strings
-exists = b.dom_exists(".cookie-banner")# bool
-b.dom_click(".accept-button")
-b.dom_type("#search", "hello world")
-b.wait_for_selector("#results", visible=True, timeout=10)
+# DOM  ── b.dom  (active tab must be http/https)
+elements = b.dom.query("h2")           # list of { tag, text, attrs }
+texts = b.dom.text(".article p")       # list of strings
+attrs = b.dom.attr("a", "href")        # list of strings
+exists = b.dom.exists(".cookie-banner")# bool
+b.dom.click(".accept-button")
+b.dom.type("#search", "hello world")
+b.dom.wait_for("#results", visible=True, timeout=10)
+b.dom.eval("document.title")
 
-# Extract
-links = b.extract_links()     # list of { text, href }
-images = b.extract_images()   # list of { alt, src }
-text = b.extract_text()       # string
-data = b.extract_json("#app-data")  # parsed Python object
+# Extract  ── b.extract
+links = b.extract.links()     # list of { text, href }
+images = b.extract.images()   # list of { alt, src }
+text = b.extract.text()       # string
+data = b.extract.json("#app-data")  # parsed Python object
+md = b.extract.markdown("article")
 
-# Sessions
-b.session_save("before-meeting")
-b.session_load("before-meeting")
-sessions = b.session_list()   # [{ name, tabs, savedAt }, ...]
-b.session_remove("before-meeting")
-diff = b.session_diff("session-a", "session-b")
+# Page / storage / cookies
+info = b.page.info()
+b.storage.set("token", "abc")
+val = b.storage.get("token")
+cookies = b.cookies.list(domain="example.com")
+
+# Sessions  ── b.session
+b.session.save("before-meeting")
+b.session.load("before-meeting")
+sessions = b.session.list()   # [{ name, tabs, savedAt }, ...]
+b.session.remove("before-meeting")
+diff = b.session.diff("session-a", "session-b")
 # diff = { "added": [...urls], "removed": [...urls] }
-b.session_auto_save(True)
+b.session.auto_save(True)
+
+# Performance + extension
+b.perf.status()
+b.perf.set_profile("gentle")
+b.extension.reload()
 
 # Misc
 clients = b.clients()
@@ -385,7 +397,7 @@ from browser_cli import BrowserCLI, BrowserNotConnected
 
 b = BrowserCLI()
 try:
-    tabs = b.tabs_list()
+    tabs = b.tabs.list()
 except BrowserNotConnected:
     print("Browser is not running or extension is not loaded")
 except RuntimeError as e:
@@ -397,11 +409,11 @@ from browser_cli import BrowserCLI, BrowserCounts
 
 b = BrowserCLI()
 
-tabs = b.tabs_list()
+tabs = b.tabs.list()
 for tab in tabs:
     print(tab.browser, tab.title)
 
-counts = b.tabs_count()
+counts = b.tabs.count()
 if isinstance(counts, BrowserCounts):
     print(counts.total)
     print(counts.by_browser)
diff --git a/browser_cli/__init__.py b/browser_cli/__init__.py
index 230587a..d79847c 100644
--- a/browser_cli/__init__.py
+++ b/browser_cli/__init__.py
@@ -5,34 +5,66 @@ Usage:
     from browser_cli import BrowserCLI
     b = BrowserCLI()
 
-    tabs = b.tabs_list()        # list[Tab]
+    tabs = b.tabs.list()            # list[Tab]
     tabs[0].close()
     tabs[0].move(forward=True)
 
-    groups = b.group_list()     # list[Group]
+    groups = b.groups.list()        # list[Group]
     groups[0].tabs()
     groups[0].add_tab("https://example.com")
 
+    b.nav.open("https://example.com")
+    b.dom.click("#submit")
+    b.session.save("work")
+
     # When multiple browser instances are active, pass the alias:
     b = BrowserCLI(browser="brave")
-"""
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
 
+Commands are grouped into namespaces on the client:
+    b.nav        navigation (open, reload, back, forward, focus, search)
+    b.tabs       tabs (list, open, close, move, status, mute, sort, ...)
+    b.groups     tab groups (list, create, add_tab, move, close)
+    b.windows    browser windows (list, open, close, rename)
+    b.dom        page elements (query, click, type, wait_for, eval, ...)
+    b.extract    content extraction (links, images, text, json, markdown)
+    b.page       page info
+    b.storage    localStorage / sessionStorage
+    b.cookies    cookies (list, get, set)
+    b.session    sessions (save, load, list, diff, ...)
+    b.perf       performance profile + background jobs
+    b.extension  control the extension itself
+"""
 from browser_cli.client import BrowserNotConnected, active_browser_targets, remote_browser_targets, send_command
-from browser_cli.models import Group, Tab
+from browser_cli.models import BrowserCounts, Group, Tab
+from browser_cli.sdk import (
+    CookiesNS,
+    DomNS,
+    ExtensionNS,
+    ExtractNS,
+    GroupsNS,
+    NavigationNS,
+    PageNS,
+    PerfNS,
+    SessionNS,
+    StorageNS,
+    TabsNS,
+    WindowsNS,
+)
+from browser_cli.sdk.factories import FactoryMixin
+from browser_cli.sdk.routing import RoutingMixin
 
 __all__ = ["BrowserCLI", "BrowserCounts", "BrowserNotConnected", "Tab", "Group"]
 
+class BrowserCLI(FactoryMixin, RoutingMixin):
+    """Client for a running browser, with commands grouped into namespaces.
 
-@dataclass(frozen=True)
-class BrowserCounts:
-    """Aggregated per-browser counts returned in implicit multi-browser mode."""
-    total: int
-    by_browser: dict[str, int]
+    The client itself holds the connection target (browser/remote/key) and the
+    shared machinery; the actual commands live on namespace accessors such as
+    :attr:`tabs`, :attr:`dom`, and :attr:`session`. Object construction
+    (``Tab``/``Group``) comes from :class:`~browser_cli.sdk.factories.FactoryMixin`
+    and multi-browser fan-out from :class:`~browser_cli.sdk.routing.RoutingMixin`.
+    """
 
-
-class BrowserCLI:
     def __init__(self, browser: str | None = None, remote: str | None = None, key: str | None = None):
         """
         Args:
@@ -50,6 +82,20 @@ class BrowserCLI:
         self._remote = remote
         self._key = key if key else None
 
+        # Command namespaces.
+        self.nav = NavigationNS(self)
+        self.tabs = TabsNS(self)
+        self.groups = GroupsNS(self)
+        self.windows = WindowsNS(self)
+        self.dom = DomNS(self)
+        self.extract = ExtractNS(self)
+        self.page = PageNS(self)
+        self.storage = StorageNS(self)
+        self.cookies = CookiesNS(self)
+        self.session = SessionNS(self)
+        self.perf = PerfNS(self)
+        self.extension = ExtensionNS(self)
+
     @property
     def browser(self) -> str | None:
         """Target browser/profile alias, equivalent to ``--browser``."""
@@ -72,816 +118,10 @@ class BrowserCLI:
         """Send a raw browser-cli command and return its response.
 
         This is the SDK escape hatch for commands that do not have a dedicated
-        convenience method yet.
+        namespace method yet.
         """
         return self._cmd(command, args or {})
 
-    def _multi_browser_targets(self):
-        if self._browser is not None:
-            return []
-        if self._remote:
-            targets = remote_browser_targets(self._remote, key=self._key)
-        else:
-            targets = active_browser_targets()
-        if len(targets) <= 1 and not any(target.remote for target in targets):
-            return []
-        return targets
-
-    def _collect_multi_browser(self, command: str, args: dict | None = None):
-        results = []
-        targets = self._multi_browser_targets()
-        for target in targets:
-            try:
-                if target.remote:
-                    data = send_command(command, args, profile=target.profile, remote=target.remote, key=self._key)
-                else:
-                    data = send_command(command, args, profile=target.profile)
-            except (BrowserNotConnected, RuntimeError):
-                continue
-            results.append((target, data))
-        if results:
-            return results
-        if targets:
-            raise BrowserNotConnected(
-                "Cannot resolve a browser socket automatically.\n"
-                "Make sure the browser is running with the browser-cli extension enabled,\n"
-                "or pass --browser <alias> / set BROWSER_CLI_PROFILE to a known alias."
-            )
-        return []
-
-    # ── Internal factories ────────────────────────────────────────────────
-
-    def _make_tab(
-        self,
-        data: dict,
-        *,
-        browser_profile: str | None = None,
-        browser_name: str | None = None,
-        browser_remote: str | None = None,
-    ) -> Tab:
-        tab = Tab(
-            id=data["id"],
-            window_id=data.get("windowId", 0),
-            active=data.get("active", False),
-            muted=data.get("muted", False),
-            title=data.get("title") or "",
-            url=data.get("url") or "",
-            group_id=data.get("groupId") or None,
-            browser=browser_name,
-        )
-        tab._browser = self if browser_profile is None else BrowserCLI(
-            browser=browser_profile,
-            remote=browser_remote,
-            key=self._key,
-        )
-        return tab
-
-    def _make_group(
-        self,
-        data: dict,
-        *,
-        browser_profile: str | None = None,
-        browser_name: str | None = None,
-        browser_remote: str | None = None,
-    ) -> Group:
-        group = Group(
-            id=data["id"],
-            title=data.get("title") or "",
-            color=data.get("color") or "",
-            collapsed=data.get("collapsed", False),
-            tab_count=data.get("tabCount", 0),
-            browser=browser_name,
-        )
-        group._browser = self if browser_profile is None else BrowserCLI(
-            browser=browser_profile,
-            remote=browser_remote,
-            key=self._key,
-        )
-        return group
-
-    # ── Navigation ────────────────────────────────────────────────────────
-
-    def open(self, url: str, *, background: bool = False, window: str | None = None, group: str | None = None) -> None:
-        self._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group})
-
-    def open_tab(
-        self,
-        url: str,
-        *,
-        wait: bool = False,
-        timeout: float = 30.0,
-        background: bool = False,
-        window: str | None = None,
-        group: str | None = None,
-    ) -> "Tab":
-        """Open URL in a new tab and return a bound :class:`Tab` object.
-
-        Set ``wait=True`` to block until the page reaches ``readyState=complete``.
-        """
-        if wait:
-            return self.open_wait(url, timeout=timeout, background=background, window=window, group=group)
-        data = self._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group})
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError("navigate.open returned unexpected data")
-        return self._make_tab(data)
-
-    def reload(self, tab_id: int | None = None) -> None:
-        self._cmd("navigate.reload", {"tabId": tab_id})
-
-    def hard_reload(self, tab_id: int | None = None) -> None:
-        self._cmd("navigate.hard_reload", {"tabId": tab_id})
-
-    def back(self, tab_id: int | None = None) -> None:
-        self._cmd("navigate.back", {"tabId": tab_id})
-
-    def forward(self, tab_id: int | None = None) -> None:
-        self._cmd("navigate.forward", {"tabId": tab_id})
-
-    def focus_url(self, pattern: str) -> None:
-        self._cmd("navigate.focus", {"pattern": pattern})
-
-    def navigate_tab(self, tab_id: int, url: str) -> None:
-        """Navigate a specific tab to *url*."""
-        self._cmd("navigate.to", {"tabId": tab_id, "url": url})
-
-    def open_wait(
-        self,
-        url: str,
-        *,
-        timeout: float = 30.0,
-        background: bool = False,
-        window: str | None = None,
-        group: str | None = None,
-    ) -> "Tab":
-        """Open URL in a new tab and block until fully loaded. Returns the Tab."""
-        data = self._cmd("navigate.open_wait", {
-            "url": url, "timeout": int(timeout * 1000),
-            "background": background, "window": window, "group": group,
-        })
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError("navigate.open_wait returned unexpected data")
-        return self._make_tab(data)
-
-    def wait_for_load(
-        self,
-        tab_id: int | None = None,
-        *,
-        timeout: float = 30.0,
-        ready_state: str = "complete",
-    ) -> Tab:
-        """Block until the tab finishes loading. Returns the Tab when ready.
-
-        Args:
-            tab_id: Tab to watch. Defaults to the active tab.
-            timeout: Max seconds to wait before raising ``RuntimeError``.
-            ready_state: ``"complete"`` (default) or ``"interactive"``.
-        """
-        data = self._cmd("navigate.wait", {
-            "tabId": tab_id,
-            "timeout": int(timeout * 1000),
-            "readyState": ready_state,
-        })
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError("navigate.wait returned unexpected data")
-        return self._make_tab(data)
-
-    # ── Search ────────────────────────────────────────────────────────────
-
-    def search(
-        self, engine: str, query: str, *,
-        background: bool = False, window: str | None = None, group: str | None = None,
-    ) -> None:
-        """Open a search query in the given engine (e.g. 'google', 'youtube', 'ddg')."""
-        from urllib.parse import quote_plus
-        from browser_cli.commands.search import ENGINES
-        template = ENGINES.get(engine)
-        if template is None:
-            raise ValueError(f"Unknown search engine '{engine}'. Available: {', '.join(ENGINES)}")
-        url = template.format(query=quote_plus(query))
-        self._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group})
-
-    # ── Tabs ──────────────────────────────────────────────────────────────
-
-    def tabs(self) -> list[Tab]:
-        """Alias for :meth:`tabs_list`."""
-        return self.tabs_list()
-
-    def tab(self, tab_id: int) -> Tab:
-        """Return a specific tab by ID."""
-        return self.tabs_status(tab_id)
-
-    def active_tab(self) -> Tab:
-        """Return the active tab."""
-        return self.tabs_status()
-
-    def find_tabs(self, search: str) -> list[Tab]:
-        """Alias for :meth:`tabs_query`."""
-        return self.tabs_query(search)
-
-    def find_tab(self, search: str) -> Tab | None:
-        """Return the first tab matching *search*, or ``None``."""
-        matches = self.tabs_query(search)
-        return matches[0] if matches else None
-
-    def close_tab(self, tab: int | Tab) -> int:
-        """Close a tab by ID or :class:`Tab` object. Returns count closed."""
-        tab_id = tab.id if isinstance(tab, Tab) else tab
-        return self.tabs_close(tab_id)
-
-    def tabs_list(self) -> list[Tab]:
-        """Return all open tabs across all windows.
-
-        When multiple browsers are active and no browser was specified, each Tab
-        includes ``tab.browser`` naming its source browser.
-        """
-        multi_results = self._collect_multi_browser("tabs.list", {})
-        if multi_results:
-            return [
-                self._make_tab(
-                    tab,
-                    browser_profile=target.profile,
-                    browser_name=target.display_name,
-                    browser_remote=target.remote,
-                )
-                for target, tabs in multi_results
-                for tab in (tabs or [])
-            ]
-        return [self._make_tab(t) for t in (self._cmd("tabs.list", {}) or [])]
-
-    def tabs_close(
-        self,
-        tab_id: int | None = None,
-        *,
-        tab_ids: Iterable[int | Tab] | None = None,
-        inactive: bool = False,
-        duplicates: bool = False,
-    ) -> int:
-        """Close tab(s). Returns the number of tabs closed.
-
-        Pass ``tab_ids`` to close many tabs in a single round-trip instead of
-        calling :meth:`close_tab` per tab. Accepts tab IDs or :class:`Tab`
-        objects. The extension throttles large batches automatically.
-        """
-        ids = None
-        if tab_ids is not None:
-            ids = [t.id if isinstance(t, Tab) else t for t in tab_ids]
-        result = self._cmd("tabs.close", {
-            "tabId": tab_id,
-            "tabIds": ids,
-            "inactive": inactive,
-            "duplicates": duplicates,
-        })
-        return result.get("closed", 1) if isinstance(result, dict) else 1
-
-    def tabs_move(
-        self, tab_id: int, *,
-        forward: bool = False, backward: bool = False,
-        group_id: int | None = None, window_id: int | None = None, index: int | None = None,
-    ) -> None:
-        self._cmd("tabs.move", {
-            "tabId": tab_id, "forward": forward, "backward": backward,
-            "groupId": group_id, "windowId": window_id, "index": index,
-        })
-
-    def tabs_active(self, tab_id: int) -> None:
-        """Switch browser focus to a tab by ID."""
-        self._cmd("tabs.active", {"tabId": tab_id})
-
-    def tabs_status(self, tab_id: int | None = None) -> Tab:
-        """Return status for the active tab or a specific tab."""
-        data = self._cmd("tabs.status", {"tabId": tab_id})
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError("No tab status returned")
-        return self._make_tab(data)
-
-    def tabs_mute(self, tab_id: int | None = None) -> int:
-        """Mute the active tab or a specific tab. Returns the target tab ID."""
-        result = self._cmd("tabs.mute", {"tabId": tab_id})
-        return result.get("tabId", tab_id) if isinstance(result, dict) else int(tab_id or 0)
-
-    def tabs_unmute(self, tab_id: int | None = None) -> int:
-        """Unmute the active tab or a specific tab. Returns the target tab ID."""
-        result = self._cmd("tabs.unmute", {"tabId": tab_id})
-        return result.get("tabId", tab_id) if isinstance(result, dict) else int(tab_id or 0)
-
-    def tabs_pin(self, tab_id: int | None = None) -> int:
-        """Pin the active tab or a specific tab. Returns the target tab ID."""
-        result = self._cmd("tabs.pin", {"tabId": tab_id})
-        return result.get("tabId", tab_id) if isinstance(result, dict) else int(tab_id or 0)
-
-    def tabs_unpin(self, tab_id: int | None = None) -> int:
-        """Unpin the active tab or a specific tab. Returns the target tab ID."""
-        result = self._cmd("tabs.unpin", {"tabId": tab_id})
-        return result.get("tabId", tab_id) if isinstance(result, dict) else int(tab_id or 0)
-
-    def tabs_watch_url(
-        self,
-        pattern: str,
-        *,
-        tab_id: int | None = None,
-        timeout: float = 30.0,
-    ) -> "Tab":
-        """Block until the tab URL matches regex pattern. Returns the Tab."""
-        data = self._cmd("tabs.watch_url", {"pattern": pattern, "tabId": tab_id, "timeout": int(timeout * 1000)})
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError("tabs.watch_url returned unexpected data")
-        return self._make_tab(data)
-
-    def tabs_screenshot(
-        self,
-        tab_id: int | None = None,
-        *,
-        format: str = "png",
-        quality: int | None = None,
-    ) -> str:
-        """Capture the visible area of a tab. Returns a base64 data URL.
-
-        Args:
-            tab_id: Tab to capture. Defaults to the active tab.
-            format: ``"png"`` (default) or ``"jpeg"``.
-            quality: JPEG quality 0-100 (ignored for PNG).
-        """
-        result = self._cmd("tabs.screenshot", {"tabId": tab_id, "format": format, "quality": quality})
-        return result.get("dataUrl", "") if isinstance(result, dict) else str(result)
-
-    def window_active_tab(self, window_id: int) -> Tab:
-        """Return active tab for a specific browser window."""
-        data = self._cmd("tabs.active_in_window", {"windowId": window_id})
-        if not isinstance(data, dict) or "id" not in data:
-            raise RuntimeError(f"No active tab found for window {window_id}")
-        return self._make_tab(data)
-
-    def tabs_filter(self, pattern_or_filter: str | Callable[[Tab], bool] | Callable[[list[Tab]], Iterable[Tab]]) -> list[Tab]:
-        """Return tabs filtered by pattern or a Python callable."""
-        if isinstance(pattern_or_filter, str):
-            return [self._make_tab(t) for t in (self._cmd("tabs.filter", {"pattern": pattern_or_filter}) or [])]
-        return self._apply_tab_filter(pattern_or_filter)
-
-    def tabs_count(self, pattern: str | None = None) -> int | BrowserCounts:
-        """Count open tabs, optionally filtered by URL pattern.
-
-        Returns ``BrowserCounts`` in implicit multi-browser mode.
-        """
-        multi_results = self._collect_multi_browser("tabs.count", {"pattern": pattern})
-        if multi_results:
-            by_browser = {target.display_name: int(count or 0) for target, count in multi_results}
-            return BrowserCounts(total=sum(by_browser.values()), by_browser=by_browser)
-        return self._cmd("tabs.count", {"pattern": pattern})
-
-    def tabs_query(self, search: str) -> list[Tab]:
-        """Search tabs by URL or title."""
-        return [self._make_tab(t) for t in (self._cmd("tabs.query", {"search": search}) or [])]
-
-    def tabs_html(self, tab_id: int | None = None) -> str:
-        """Return the full HTML source of the active (or specified) tab."""
-        return self._cmd("tabs.html", {"tabId": tab_id}) or ""
-
-    def tabs_dedupe(self) -> int:
-        """Close duplicate tabs (keep the first occurrence of each URL). Returns count closed."""
-        result = self._cmd("tabs.dedupe", {})
-        return result.get("closed", 0) if isinstance(result, dict) else 0
-
-    def tabs_sort(self, by: str = "domain") -> None:
-        """Sort tabs within each window. *by* is one of 'domain', 'title', 'time'."""
-        self._cmd("tabs.sort", {"by": by})
-
-    def tabs_merge_windows(self) -> int:
-        """Move all tabs into the focused window. Returns count moved."""
-        result = self._cmd("tabs.merge_windows", {})
-        return result.get("moved", 0) if isinstance(result, dict) else 0
-
-    def tabs_close_inactive(self) -> int:
-        """Close all inactive tabs. Returns count closed."""
-        result = self._cmd("tabs.close", {"inactive": True})
-        return result.get("closed", 0) if isinstance(result, dict) else 0
-
-    def tabs_close_duplicates(self) -> int:
-        """Close duplicate tabs. Returns count closed."""
-        result = self._cmd("tabs.close", {"duplicates": True})
-        return result.get("closed", 0) if isinstance(result, dict) else 0
-
-    # ── Tab Groups ────────────────────────────────────────────────────────
-
-    def groups(self) -> list[Group]:
-        """Alias for :meth:`group_list`."""
-        return self.group_list()
-
-    def groups_list(self) -> list[Group]:
-        """Alias for :meth:`group_list`."""
-        return self.group_list()
-
-    def group_list(self) -> list[Group]:
-        """Return all tab groups.
-
-        When multiple browsers are active and no browser was specified, each Group
-        includes ``group.browser`` naming its source browser.
-        """
-        multi_results = self._collect_multi_browser("group.list", {})
-        if multi_results:
-            return [
-                self._make_group(
-                    group,
-                    browser_profile=target.profile,
-                    browser_name=target.display_name,
-                    browser_remote=target.remote,
-                )
-                for target, groups in multi_results
-                for group in (groups or [])
-            ]
-        return [self._make_group(g) for g in (self._cmd("group.list", {}) or [])]
-
-    def group_tabs(self, group_id: int) -> list[Tab]:
-        """Return all tabs inside a group."""
-        return [self._make_tab(t) for t in (self._cmd("group.tabs", {"groupId": group_id}) or [])]
-
-    def groups_count(self) -> int | BrowserCounts:
-        """Alias for :meth:`group_count`."""
-        return self.group_count()
-
-    def group_count(self) -> int | BrowserCounts:
-        """Return the number of tab groups.
-
-        Returns ``BrowserCounts`` in implicit multi-browser mode.
-        """
-        multi_results = self._collect_multi_browser("group.count", {})
-        if multi_results:
-            by_browser = {target.display_name: int(count or 0) for target, count in multi_results}
-            return BrowserCounts(total=sum(by_browser.values()), by_browser=by_browser)
-        return self._cmd("group.count", {})
-
-    def groups_query(self, search: str) -> list[Group]:
-        """Alias for :meth:`group_query`."""
-        return self.group_query(search)
-
-    def group_query(self, search: str) -> list[Group]:
-        """Search groups by name."""
-        return [self._make_group(g) for g in (self._cmd("group.query", {"search": search}) or [])]
-
-    def group_close(self, group_id: int) -> None:
-        """Ungroup (and close) a tab group by ID."""
-        self._cmd("group.close", {"groupId": group_id})
-
-    def groups_create(self, name: str) -> Group:
-        """Alias for :meth:`group_create`."""
-        return self.group_create(name)
-
-    def group_open(self, name: str) -> Group:
-        """Alias for :meth:`group_create`."""
-        return self.group_create(name)
-
-    def group_create(self, name: str) -> Group:
-        """Create a new tab group with *name*. Returns the created Group."""
-        data = self._cmd("group.open", {"name": name})
-        return self._make_group(data) if isinstance(data, dict) else Group(id=data, title=name, color="", collapsed=False, tab_count=0)
-
-    def group_add_tab(self, group: str | int, url: str | None = None) -> int | None:
-        """Open a new tab (optionally at URL) inside a group. Returns the new tab ID."""
-        result = self._cmd("group.add_tab", {"group": str(group), "url": url})
-        return result.get("tabId") if isinstance(result, dict) else result
-
-    def group_move(self, group: str | int, *, forward: bool = False, backward: bool = False) -> None:
-        """Move a tab group forward or backward."""
-        self._cmd("group.move", {"group": str(group), "forward": forward, "backward": backward})
-
-    # ── Windows ───────────────────────────────────────────────────────────
-
-    def windows_list(self) -> list[dict]:
-        """Return browser windows.
-
-        In implicit multi-browser mode each window dict includes a ``browser`` key.
-        """
-        multi_results = self._collect_multi_browser("windows.list", {})
-        if multi_results:
-            return [
-                {**window, "browser": target.display_name}
-                for target, windows in multi_results
-                for window in (windows or [])
-            ]
-        return self._cmd("windows.list", {}) or []
-
-    def windows_rename(self, window_id: int, name: str) -> None:
-        self._cmd("windows.rename", {"windowId": window_id, "name": name})
-
-    def windows_close(self, window_id: int) -> None:
-        self._cmd("windows.close", {"windowId": window_id})
-
-    def windows_open(self, url: str | None = None) -> dict:
-        """Open a new browser window, optionally on a URL."""
-        return self._cmd("windows.open", {"url": url}) or {}
-
-    # ── DOM ───────────────────────────────────────────────────────────────
-
-    def dom_query(self, selector: str) -> list[dict]:
-        return self._cmd("dom.query", {"selector": selector}) or []
-
-    def dom_click(self, selector: str) -> None:
-        self._cmd("dom.click", {"selector": selector})
-
-    def dom_type(self, selector: str, text: str) -> None:
-        self._cmd("dom.type", {"selector": selector, "text": text})
-
-    def dom_attr(self, selector: str, attr: str) -> list[str]:
-        return self._cmd("dom.attr", {"selector": selector, "attr": attr}) or []
-
-    def dom_text(self, selector: str) -> list[str]:
-        return self._cmd("dom.text", {"selector": selector}) or []
-
-    def dom_exists(self, selector: str) -> bool:
-        return self._cmd("dom.exists", {"selector": selector}) or False
-
-    def dom_scroll(self, selector: str | None = None, *, x: int | None = None, y: int | None = None) -> None:
-        """Scroll to a CSS selector or to pixel coordinates."""
-        self._cmd("dom.scroll", {"selector": selector, "x": x, "y": y})
-
-    def dom_select(self, selector: str, value: str) -> None:
-        """Set the value of a <select> element."""
-        self._cmd("dom.select", {"selector": selector, "value": value})
-
-    def dom_eval(self, code: str, tab_id: int | None = None):
-        """Evaluate JavaScript in the page's main world and return the result."""
-        return self._cmd("dom.eval", {"code": code, "tabId": tab_id})
-
-    def dom_key(self, key: str, selector: str | None = None) -> None:
-        """Dispatch a keyboard event. key examples: 'Enter', 'Tab', 'Escape', 'ArrowDown'."""
-        self._cmd("dom.key", {"key": key, "selector": selector})
-
-    def dom_hover(self, selector: str) -> None:
-        """Dispatch mouseover/mouseenter on an element."""
-        self._cmd("dom.hover", {"selector": selector})
-
-    def dom_check(self, selector: str) -> None:
-        """Check a checkbox."""
-        self._cmd("dom.check", {"selector": selector})
-
-    def dom_uncheck(self, selector: str) -> None:
-        """Uncheck a checkbox."""
-        self._cmd("dom.uncheck", {"selector": selector})
-
-    def dom_clear(self, selector: str) -> None:
-        """Clear the value of an input element."""
-        self._cmd("dom.clear", {"selector": selector})
-
-    def dom_focus(self, selector: str) -> None:
-        """Focus an element."""
-        self._cmd("dom.focus", {"selector": selector})
-
-    def dom_submit(self, selector: str) -> None:
-        """Submit the form containing the matched element."""
-        self._cmd("dom.submit", {"selector": selector})
-
-    def dom_poll(
-        self,
-        selector: str,
-        pattern: str,
-        *,
-        attr: str | None = None,
-        timeout: float = 30.0,
-        interval: float = 0.5,
-        tab_id: int | None = None,
-    ) -> dict:
-        """Poll selector's text/value until it matches regex pattern.
-
-        Returns ``{"selector": ..., "value": ..., "pattern": ...}`` when matched.
-        """
-        return self._cmd("dom.poll", {
-            "selector": selector,
-            "pattern": pattern,
-            "attr": attr,
-            "timeout": int(timeout * 1000),
-            "interval": int(interval * 1000),
-            "tabId": tab_id,
-        })
-
-    def wait_for_selector(
-        self,
-        selector: str,
-        *,
-        timeout: float = 10.0,
-        visible: bool = False,
-        hidden: bool = False,
-        tab_id: int | None = None,
-    ) -> dict:
-        """Alias for :meth:`dom_wait_for`."""
-        return self.dom_wait_for(selector, timeout=timeout, visible=visible, hidden=hidden, tab_id=tab_id)
-
-    def dom_wait_for(
-        self,
-        selector: str,
-        *,
-        timeout: float = 10.0,
-        visible: bool = False,
-        hidden: bool = False,
-        tab_id: int | None = None,
-    ) -> dict:
-        """Wait until a CSS selector appears (or disappears) in the DOM.
-
-        Args:
-            selector: CSS selector to watch.
-            timeout: Max seconds to wait before raising ``RuntimeError``.
-            visible: Wait until the element has non-zero dimensions.
-            hidden: Wait until the element is absent or has ``offsetParent == null``.
-            tab_id: Tab to watch. Defaults to the active tab.
-        """
-        return self._cmd("dom.wait_for", {
-            "selector": selector,
-            "timeout": int(timeout * 1000),
-            "visible": visible,
-            "hidden": hidden,
-            "tabId": tab_id,
-        })
-
-    # ── Page ─────────────────────────────────────────────────────────────
-
-    def page_info(self) -> dict:
-        """Return title, URL, readyState, lang, and meta tags of the active tab."""
-        return self._cmd("page.info", {}) or {}
-
-    # ── Storage ───────────────────────────────────────────────────────────
-
-    def storage_get(
-        self,
-        key: str | None = None,
-        *,
-        type: str = "local",
-        tab_id: int | None = None,
-    ) -> str | dict | None:
-        """Get a localStorage/sessionStorage entry (or all entries if key omitted)."""
-        return self._cmd("storage.get", {"key": key, "type": type, "tabId": tab_id})
-
-    def storage_set(
-        self,
-        key: str,
-        value: str,
-        *,
-        type: str = "local",
-        tab_id: int | None = None,
-    ) -> None:
-        """Set a localStorage/sessionStorage entry."""
-        self._cmd("storage.set", {"key": key, "value": value, "type": type, "tabId": tab_id})
-
-    # ── Cookies ───────────────────────────────────────────────────────────
-
-    def cookies_list(
-        self,
-        *,
-        url: str | None = None,
-        domain: str | None = None,
-        name: str | None = None,
-    ) -> list[dict]:
-        """List cookies, optionally filtered by url, domain, or name."""
-        return self._cmd("cookies.list", {"url": url, "domain": domain, "name": name}) or []
-
-    def cookies_get(self, url: str, name: str) -> dict | None:
-        """Get a single cookie by url and name."""
-        return self._cmd("cookies.get", {"url": url, "name": name})
-
-    def cookies_set(
-        self,
-        url: str,
-        name: str,
-        value: str,
-        *,
-        domain: str | None = None,
-        path: str | None = None,
-        secure: bool | None = None,
-        http_only: bool | None = None,
-        expiration_date: float | None = None,
-        same_site: str | None = None,
-    ) -> dict:
-        """Set a cookie. Returns the created cookie dict."""
-        return self._cmd("cookies.set", {
-            "url": url, "name": name, "value": value,
-            "domain": domain, "path": path,
-            "secure": secure, "httpOnly": http_only,
-            "expirationDate": expiration_date, "sameSite": same_site,
-        })
-
-    # ── Extract ───────────────────────────────────────────────────────────
-
-    def extract_links(self) -> list[dict]:
-        return self._cmd("extract.links", {}) or []
-
-    def extract_images(self) -> list[dict]:
-        return self._cmd("extract.images", {}) or []
-
-    def extract_text(self) -> str:
-        return self._cmd("extract.text", {}) or ""
-
-    def extract_json(self, selector: str):
-        return self._cmd("extract.json", {"selector": selector})
-
-    def extract_markdown(self, selector: str | None = None) -> str:
-        return self._cmd("extract.markdown", {"selector": selector}) or ""
-
-    # ── Session ───────────────────────────────────────────────────────────
-
-    def session_save(self, name: str) -> None:
-        self._cmd("session.save", {"name": name})
-
-    def session_load(
-        self,
-        name: str,
-        *,
-        gentle_mode: str = "auto",
-        discard_background_tabs: bool = False,
-        lazy: bool = False,
-        eager_tabs: int = 10,
-    ) -> None:
-        self._cmd("session.load", {
-            "name": name,
-            "gentleMode": gentle_mode,
-            "discardBackgroundTabs": discard_background_tabs,
-            "lazy": lazy,
-            "eagerTabs": eager_tabs,
-        })
-
-    def session_load_background(
-        self,
-        name: str,
-        *,
-        gentle_mode: str = "auto",
-        discard_background_tabs: bool = False,
-        lazy: bool = False,
-        eager_tabs: int = 10,
-    ) -> dict:
-        return self._cmd("session.load", {
-            "name": name,
-            "gentleMode": gentle_mode,
-            "discardBackgroundTabs": discard_background_tabs,
-            "lazy": lazy,
-            "eagerTabs": eager_tabs,
-            "__background": True,
-        }) or {}
-
-    def job_status(self, job_id: str) -> dict:
-        return self._cmd("jobs.status", {"jobId": job_id}) or {}
-
-    def job_cancel(self, job_id: str) -> dict:
-        return self._cmd("jobs.cancel", {"jobId": job_id}) or {}
-
-    def reload_extension(self) -> None:
-        """Reload the browser-cli extension service worker.
-
-        Schedules a ``chrome.runtime.reload()`` inside the extension and returns
-        immediately.  The extension restarts ~200 ms later and reconnects via the
-        keepalive alarm within ~25 seconds.
-        """
-        self._cmd("extension.reload", {})
-
-    def perf_status(self) -> dict:
-        return self._cmd("perf.status", {}) or {}
-
-    def set_performance_profile(self, profile: str) -> dict:
-        return self._cmd("perf.set_profile", {"profile": profile}) or {}
-
-    def session_diff(self, name_a: str, name_b: str) -> dict:
-        return self._cmd("session.diff", {"nameA": name_a, "nameB": name_b}) or {}
-
-    def session_list(self) -> list[dict]:
-        """Return saved sessions.
-
-        In implicit multi-browser mode each session dict includes a ``browser`` key.
-        """
-        multi_results = self._collect_multi_browser("session.list", {})
-        if multi_results:
-            return [
-                {**session, "browser": target.display_name}
-                for target, sessions in multi_results
-                for session in (sessions or [])
-            ]
-        return self._cmd("session.list", {}) or []
-
-    def session_remove(self, name: str) -> None:
-        self._cmd("session.remove", {"name": name})
-
-    def session_auto_save(self, enabled: bool) -> None:
-        self._cmd("session.auto_save", {"enabled": enabled})
-
-    # ── Misc ──────────────────────────────────────────────────────────────
-
     def clients(self) -> list[dict]:
+        """Return the active browser clients known to this connection."""
         return self._cmd("clients.list", {})
-
-    def _apply_tab_filter(self, filter_fn: Callable[[Tab], bool] | Callable[[list[Tab]], Iterable[Tab]]) -> list[Tab]:
-        tabs = self.tabs_list()
-
-        try:
-            transformed = filter_fn(tabs)
-        except (AttributeError, TypeError):
-            return [tab for tab in tabs if filter_fn(tab)]
-
-        if isinstance(transformed, list):
-            return transformed
-        if isinstance(transformed, tuple):
-            return list(transformed)
-        if isinstance(transformed, set):
-            return list(transformed)
-        if transformed is tabs:
-            return tabs
-        if isinstance(transformed, bool):
-            return [tab for tab in tabs if filter_fn(tab)]
-
-        try:
-            return list(transformed)
-        except TypeError:
-            return [tab for tab in tabs if filter_fn(tab)]
diff --git a/browser_cli/cli.py b/browser_cli/cli.py
index de9f771..4848d49 100755
--- a/browser_cli/cli.py
+++ b/browser_cli/cli.py
@@ -88,7 +88,6 @@ WINDOWS_NATIVE_HOST_REGISTRY_KEYS = {
     "vivaldi": [r"Software\Vivaldi\NativeMessagingHosts"],
 }
 
-
 def _rename_target_profile(target_browser: str | None) -> str | None:
     if target_browser:
         return target_browser
@@ -98,7 +97,6 @@ def _rename_target_profile(target_browser: str | None) -> str | None:
         return active[0].profile
     return None
 
-
 def _ensure_unique_browser_alias(alias: str, target_browser: str | None) -> None:
     target_profile = _rename_target_profile(target_browser)
 
@@ -107,14 +105,12 @@ def _ensure_unique_browser_alias(alias: str, target_browser: str | None) -> None
     if alias in profiles and alias != target_profile:
         raise click.ClickException(f"Browser alias '{alias}' already exists")
 
-
 def _native_host_exe() -> Path:
     base = install_base_dir()
     if is_windows():
         return base / "libexec" / "browser-cli-native-host.cmd"
     return base / "libexec" / "browser-cli-native-host"
 
-
 def _write_native_host_exe(path: Path) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     if is_windows():
@@ -128,13 +124,11 @@ def _write_native_host_exe(path: Path) -> None:
         )
         path.chmod(path.stat().st_mode | 0o111)
 
-
 def _windows_registry_views():
     import winreg
 
     return [0, getattr(winreg, "KEY_WOW64_32KEY", 0), getattr(winreg, "KEY_WOW64_64KEY", 0)]
 
-
 def _register_windows_native_host(browser: str, manifest_path: Path) -> list[str]:
     import winreg
 
@@ -152,7 +146,6 @@ def _register_windows_native_host(browser: str, manifest_path: Path) -> list[str
                 console.print(f"[yellow]Could not write registry key {full_key}: {e}[/yellow]")
     return installed
 
-
 def _project_version() -> str:
     pyproject_path = Path(__file__).resolve().parent.parent / "pyproject.toml"
     try:
@@ -168,7 +161,6 @@ def _project_version() -> str:
     except PackageNotFoundError:
         return "unknown"
 
-
 def _print_version(ctx, param, value):
     if not value or ctx.resilient_parsing:
         return
@@ -214,14 +206,12 @@ def main(ctx, browser, remote, key):
         os.environ["BROWSER_CLI_KEY"] = key
         ctx.call_on_close(lambda: os.environ.pop("BROWSER_CLI_KEY", None))
 
-
 # ── auth ──────────────────────────────────────────────────────────────────────
 
 @click.group("auth")
 def auth_group():
     """Manage Ed25519 keys for public-key authentication with browser-cli serve."""
 
-
 @auth_group.command("keygen")
 @click.option("--output", "-o", default=None, metavar="PATH", help="Output path for the private key PEM.")
 @click.option("--force", is_flag=True, help="Overwrite existing key.")
@@ -243,7 +233,6 @@ def cmd_auth_keygen(output, force):
     console.print(f"\nOn the serve host, trust this key:")
     console.print(f"  [dim]browser-cli auth trust {pub_hex}[/dim]")
 
-
 @auth_group.command("trust")
 @click.argument("pubkey")
 @click.option("--name", default="", metavar="NAME", help="Human-friendly label for this key.")
@@ -290,7 +279,6 @@ def cmd_auth_trust(ctx, pubkey, name, keys_file):
     else:
         console.print(f"[yellow]Already trusted:[/yellow] {pubkey}")
 
-
 @auth_group.command("show")
 @click.option("--key", "key_src", default=None, metavar="PATH|agent[:<selector>]",
               help="Key source: path to PEM file, 'agent', or 'agent:<comment-filter>'.")
@@ -325,7 +313,6 @@ def cmd_auth_show(key_src):
         console.print(f"[red]Failed to load key:[/red] {e}")
         sys.exit(1)
 
-
 @auth_group.command("keys")
 @click.option("--file", "keys_file", default=None, metavar="PATH", help="Authorized keys file (default: ~/.config/browser-cli/authorized_keys).")
 @click.pass_context
@@ -362,7 +349,6 @@ def cmd_auth_keys(ctx, keys_file):
         table.add_row(name, entry.get("pubkey", ""))
     console.print(table)
 
-
 main.add_command(auth_group)
 
 # ── Sub-command groups ─────────────────────────────────────────────────────────
@@ -381,9 +367,15 @@ main.add_command(perf_group)
 main.add_command(extension_group)
 main.add_command(cmd_serve)
 
-
 # ── clients ────────────────────────────────────────────────────────────────────
 
+def _append_clients(into, label, *, profile=None, remote=None, key=None):
+    """Query clients.list for one target and append each, tagged with *label*."""
+    result = send_command("clients.list", profile=profile, remote=remote, key=key)
+    for c in (result or []):
+        c["profile"] = label
+        into.append(c)
+
 @click.group("clients", invoke_without_command=True)
 @click.pass_context
 def clients_group(ctx):
@@ -409,10 +401,7 @@ def clients_group(ctx):
                 sys.exit(1)
             for target in targets:
                 try:
-                    result = send_command("clients.list", profile=target.profile, remote=resolved.remote, key=key)
-                    for c in (result or []):
-                        c["profile"] = target.display_name
-                        all_clients.append(c)
+                    _append_clients(all_clients, target.display_name, profile=target.profile, remote=resolved.remote, key=key)
                 except (BrowserNotConnected, RuntimeError):
                     continue
     elif remote:
@@ -432,10 +421,7 @@ def clients_group(ctx):
         for profile_name, sock_path in profiles.items():
             display_profile = display_browser_name(profile_name, sock_path)
             try:
-                result = send_command("clients.list", profile=profile_name)
-                for c in (result or []):
-                    c["profile"] = display_profile
-                    all_clients.append(c)
+                _append_clients(all_clients, display_profile, profile=profile_name)
             except (BrowserNotConnected, RuntimeError):
                 # Socket registered but browser no longer connected
                 all_clients.append({
@@ -449,10 +435,7 @@ def clients_group(ctx):
             if target.remote is None:
                 continue
             try:
-                result = send_command("clients.list", profile=target.profile, remote=target.remote)
-                for c in (result or []):
-                    c["profile"] = target.display_name
-                    all_clients.append(c)
+                _append_clients(all_clients, target.display_name, profile=target.profile, remote=target.remote)
             except (BrowserNotConnected, RuntimeError):
                 continue
 
@@ -475,10 +458,8 @@ def clients_group(ctx):
         )
     console.print(table)
 
-
 main.add_command(clients_group)
 
-
 @clients_group.command("rename")
 @click.option(
     "--browser", "target_browser", default=None, metavar="ALIAS",
@@ -495,7 +476,6 @@ def cmd_clients_rename(target_browser, alias):
         sys.exit(1)
     console.print(f"[green]Profile renamed to '{alias}'[/green]")
 
-
 # ── install ────────────────────────────────────────────────────────────────────
 
 @main.command("install")
@@ -567,7 +547,6 @@ def cmd_install(browser):
     console.print("\n[green bold]✓ Installation complete![/green bold]")
     console.print("  After restarting the browser, try: [cyan]browser-cli tabs list[/cyan]")
 
-
 # ── native-host (hidden, called by Chrome via native messaging) ────────────────
 
 @main.command("native-host", hidden=True)
@@ -576,7 +555,6 @@ def cmd_native_host():
     from browser_cli.native_host import main as _main
     _main()
 
-
 # ── completion ─────────────────────────────────────────────────────────────────
 
 @main.command("completion")
@@ -624,6 +602,5 @@ def cmd_completion(shell, script):
         console.print()
         console.print(f"  [cyan]uv run browser-cli completion fish --script > ~/.config/fish/completions/browser-cli.fish[/cyan]")
 
-
 if __name__ == "__main__":
     main()
diff --git a/browser_cli/client.py b/browser_cli/client.py
index ad0015e..a79d52d 100644
--- a/browser_cli/client.py
+++ b/browser_cli/client.py
@@ -10,10 +10,8 @@ Profile selection order:
 """
 import json
 import os
-import re
 import socket
 import struct
-import sys
 import uuid
 from dataclasses import dataclass
 from multiprocessing.connection import Client as PipeClient
@@ -21,57 +19,26 @@ from pathlib import Path
 from typing import Any
 
 from browser_cli.platform import endpoint_for_alias, is_windows, registry_path
-from browser_cli.version_manager import MAX_MSG_BYTES as _MAX_MSG_BYTES
 from browser_cli.registry import load_registry
+from browser_cli.version_manager import USER_AGENT as _USER_AGENT
 
-try:
-    from importlib.metadata import version as _pkg_version
-    _USER_AGENT = f"browser-cli/{_pkg_version('browser-cli')}"
-except Exception:
-    _USER_AGENT = "browser-cli/0"
+# Re-exported for backward compatibility — these used to live here and are still
+# referenced as ``browser_cli.client.<name>`` by callers, serve.py, and tests.
+from browser_cli.errors import BrowserNotConnected  # noqa: F401
+from browser_cli.endpoints import (  # noqa: F401
+    _DEFAULT_REMOTE_PORT,
+    _looks_like_domain,
+    _normalize_endpoint,
+    _remote_display_name,
+    _resolve_connect_endpoint,
+    display_browser_name,
+)
+from browser_cli.remote_transport import _recv_all, _recv_exact, _send_remote  # noqa: F401
 
 REGISTRY_PATH = registry_path()
 REMOTE_REGISTRY_PATH = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "browser-cli" / "remotes.json"
 _DEFAULT_KEY_PATH = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) / "browser-cli" / "client.key.pem"
 
-_DEFAULT_REMOTE_PORT = 443
-
-
-def _looks_like_domain(host: str) -> bool:
-    """True if host looks like a domain name rather than an IP address or localhost."""
-    if host in {"localhost", "127.0.0.1", "::1"}:
-        return False
-    if re.match(r'^\d{1,3}(\.\d{1,3}){3}$', host):
-        return False
-    return '.' in host and any(c.isalpha() for c in host)
-
-
-def _normalize_endpoint(endpoint: str) -> str:
-    """Strip :443 from domain-like endpoints so they are stored without the default port."""
-    if not endpoint:
-        return endpoint
-    host, sep, port = endpoint.rpartition(":")
-    if sep and port == "443" and _looks_like_domain(host):
-        return host
-    return endpoint
-
-
-def _resolve_connect_endpoint(endpoint: str) -> str:
-    """Return host:port for TCP connection; domain without port defaults to :443."""
-    _, sep, _ = endpoint.rpartition(":")
-    if not sep:
-        if _looks_like_domain(endpoint):
-            return f"{endpoint}:{_DEFAULT_REMOTE_PORT}"
-        raise BrowserNotConnected(
-            f"Invalid remote endpoint '{endpoint}': expected host:port"
-        )
-    return endpoint
-
-
-class BrowserNotConnected(Exception):
-    """Raised when the native host socket is not available."""
-
-
 @dataclass(frozen=True)
 class BrowserTarget:
     profile: str
@@ -98,12 +65,6 @@ def _active_endpoints(reg: dict) -> dict:
         return dict(reg)
     return {k: v for k, v in reg.items() if _is_reachable_unix_endpoint(v)}
 
-def display_browser_name(profile_name: str, sock_path: str) -> str:
-    if profile_name != "default":
-        return profile_name
-    return Path(sock_path).stem or profile_name
-
-
 def _load_remotes() -> dict[str, dict[str, str]]:
     if not REMOTE_REGISTRY_PATH.exists():
         return {}
@@ -116,13 +77,10 @@ def _load_remotes() -> dict[str, dict[str, str]]:
     # normalize keys so old entries stored as "domain:443" match current lookups
     return {_normalize_endpoint(str(endpoint)): cfg for endpoint, cfg in data.items() if isinstance(cfg, dict)}
 
-
-
 def _is_valid_key_spec(s: str) -> bool:
     """Return True if s looks like a usable key spec: 'agent', 'agent:<sel>', or a file path."""
     return s == "agent" or s.startswith("agent:") or (not s.startswith("<") and ("/" in s or Path(s).suffix in {".pem", ".key"}))
 
-
 def save_remote_key(endpoint: str, key_spec: str) -> None:
     """Persist the key spec (e.g. 'agent' or a file path) for a remote endpoint."""
     if not endpoint or not key_spec:
@@ -138,7 +96,6 @@ def save_remote_key(endpoint: str, key_spec: str) -> None:
     with os.fdopen(fd, "w", encoding="utf-8") as f:
         f.write(json.dumps(remotes, indent=2, sort_keys=True))
 
-
 def key_for_remote(endpoint: str | None) -> str | None:
     if not endpoint:
         return None
@@ -152,16 +109,6 @@ def key_for_remote(endpoint: str | None) -> str | None:
         return None
     return key_str
 
-
-def _remote_display_name(endpoint: str, profile_name: str, display_name: str) -> str:
-    host, sep, port = endpoint.rpartition(":")
-    if sep and (port == "8765" or (port == "443" and _looks_like_domain(host))):
-        display_endpoint = host
-    else:
-        display_endpoint = endpoint  # normalized domain (no port) or non-default port
-    return f"{display_endpoint}:{display_name or profile_name}"
-
-
 def remote_browser_targets(endpoint: str, key=None) -> list[BrowserTarget]:
     """Return browser targets advertised by a single remote endpoint."""
     remote_targets = send_command("browser-cli.targets", remote=endpoint, key=key)
@@ -179,7 +126,6 @@ def remote_browser_targets(endpoint: str, key=None) -> list[BrowserTarget]:
         )
     return targets
 
-
 def _remote_browser_targets(key=None) -> list[BrowserTarget]:
     targets: list[BrowserTarget] = []
     for endpoint in _load_remotes():
@@ -189,7 +135,6 @@ def _remote_browser_targets(key=None) -> list[BrowserTarget]:
             continue
     return targets
 
-
 def remote_target_for_alias(alias: str | None) -> BrowserTarget | None:
     """Resolve a user-facing remote alias such as 'host:profile' to a target."""
     if not alias:
@@ -228,7 +173,6 @@ def remote_target_for_alias(alias: str | None) -> BrowserTarget | None:
         )
     return None
 
-
 def active_browser_targets(*, include_remotes: bool = True, key=None) -> list[BrowserTarget]:
     targets: list[BrowserTarget] = []
     if REGISTRY_PATH.exists():
@@ -241,7 +185,6 @@ def active_browser_targets(*, include_remotes: bool = True, key=None) -> list[Br
         targets.extend(_remote_browser_targets(key=key))
     return targets
 
-
 def _is_active_local_profile(profile: str | None) -> bool:
     """Return True when profile names a reachable local browser endpoint."""
     if not profile:
@@ -257,7 +200,6 @@ def _is_active_local_profile(profile: str | None) -> bool:
             return False
     return False
 
-
 def _resolve_socket(profile: str | None = None) -> str:
     """Return the socket path for the given profile (or auto-detect)."""
     target = profile or os.environ.get("BROWSER_CLI_PROFILE")
@@ -292,7 +234,6 @@ def _resolve_socket(profile: str | None = None) -> str:
         "or pass --browser <alias> / set BROWSER_CLI_PROFILE to a known alias."
     )
 
-
 def _load_private_key(key_path: "Path | str | None" = None):
     """Load an Ed25519 signing key.
 
@@ -320,96 +261,6 @@ def _load_private_key(key_path: "Path | str | None" = None):
     except Exception:
         return None
 
-
-def _send_remote(endpoint: str, msg: dict, private_key=None) -> bytes | None:
-    connect_ep = _resolve_connect_endpoint(endpoint)
-    host, _, port_str = connect_ep.rpartition(":")
-    port = int(port_str)
-    raw_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    raw_sock.settimeout(30)
-    try:
-        raw_sock.connect((host, port))
-        if port == 443:
-            import ssl
-            ctx = ssl.create_default_context()
-            sock = ctx.wrap_socket(raw_sock, server_hostname=host)
-        else:
-            sock = raw_sock
-    except Exception:
-        raw_sock.close()
-        raise
-    with sock:
-
-        # receive challenge
-        challenge_raw = _recv_all(sock)
-        if challenge_raw is None:
-            raise BrowserNotConnected(f"No challenge received from {endpoint}")
-        try:
-            challenge = json.loads(challenge_raw)
-            nonce_hex = challenge.get("nonce") if challenge.get("type") == "challenge" else None
-        except (json.JSONDecodeError, AttributeError):
-            nonce_hex = None
-
-        min_ver = challenge.get("min_client_version") if isinstance(challenge, dict) else None
-        if min_ver:
-            from browser_cli.version_manager import parse_version
-            try:
-                client_ver = _USER_AGENT.split("/", 1)[1]
-                if parse_version(client_ver) < parse_version(min_ver):
-                    raise BrowserNotConnected(
-                        f"Client version {client_ver} is too old for this server "
-                        f"(requires >= {min_ver}). Run: pip install --upgrade browser-cli"
-                    )
-            except (IndexError, ValueError):
-                pass
-
-        pq_shared_secret = None
-        if nonce_hex and private_key is not None:
-            from browser_cli.auth import PQ_KEX_ALG, pq_encrypt, pq_kex_client_encapsulate, sign, public_key_hex
-            nonce = bytes.fromhex(nonce_hex)
-            clean_msg = {k: v for k, v in msg.items() if k not in {"token", "pubkey", "sig", "pq_kex", "encrypted"}}
-            kex = challenge.get("pq_kex") if isinstance(challenge, dict) else None
-            if isinstance(kex, dict) and kex.get("alg") == PQ_KEX_ALG and kex.get("public_key"):
-                ciphertext_hex, pq_shared_secret = pq_kex_client_encapsulate(str(kex["public_key"]))
-                clean_msg["pq_kex"] = {"alg": PQ_KEX_ALG, "ciphertext": ciphertext_hex}
-            else:
-                sys.stderr.write(
-                    "** WARNING: connection is not using a post-quantum key exchange algorithm.\n"
-                    "** This session may be vulnerable to store now, decrypt later attacks.\n"
-                )
-            sig = sign(private_key, nonce, clean_msg, pq_shared_secret)
-            msg = {**clean_msg, "pubkey": public_key_hex(private_key), "sig": sig.hex()}
-            if pq_shared_secret is not None:
-                encrypted = pq_encrypt(pq_shared_secret, "request", json.dumps(clean_msg).encode("utf-8"))
-                msg = {
-                    "id": clean_msg.get("id"),
-                    "user_agent": clean_msg.get("user_agent"),
-                    "pubkey": public_key_hex(private_key),
-                    "sig": sig.hex(),
-                    "pq_kex": clean_msg["pq_kex"],
-                    "encrypted": encrypted,
-                }
-        else:
-            sys.stderr.write(
-                "** WARNING: connection is not using a post-quantum key exchange algorithm.\n"
-                "** This session may be vulnerable to store now, decrypt later attacks.\n"
-            )
-
-        payload = json.dumps(msg).encode("utf-8")
-        framed = struct.pack("<I", len(payload)) + payload
-        sock.sendall(framed)
-        response = _recv_all(sock)
-        if response is not None and pq_shared_secret is not None:
-            try:
-                from browser_cli.auth import pq_decrypt
-                envelope = json.loads(response)
-                if isinstance(envelope, dict) and "encrypted" in envelope:
-                    return pq_decrypt(pq_shared_secret, "response", envelope["encrypted"])
-            except Exception as e:
-                raise BrowserNotConnected(f"Cannot decrypt post-quantum remote response: {e}") from e
-        return response
-
-
 def _auto_route_remote(endpoint: str, key=None) -> str | None:
     targets = remote_browser_targets(endpoint, key=key)
     if len(targets) == 1:
@@ -423,7 +274,6 @@ def _auto_route_remote(endpoint: str, key=None) -> str | None:
         )
     return None
 
-
 def send_command(command: str, args: dict | None = None, profile: str | None = None, remote: str | None = None, key: "Path | None" = None) -> Any:
     """Send a command to the browser and return the response data."""
     requested_profile = profile or os.environ.get("BROWSER_CLI_PROFILE")
@@ -443,7 +293,9 @@ def send_command(command: str, args: dict | None = None, profile: str | None = N
         "args": args or {},
     }
     if remote_endpoint:
+        from browser_cli import transport
         msg["user_agent"] = _USER_AGENT
+        msg["accept_encoding"] = transport.client_accept_encoding()
         # key priority: explicit flag > saved per-remote config > BROWSER_CLI_KEY env > default file
         key_spec = key if key is not None else key_for_remote(remote_endpoint)
         private_key = _load_private_key(key_spec)
@@ -493,25 +345,8 @@ def send_command(command: str, args: dict | None = None, profile: str | None = N
 
     if response is None:
         raise ConnectionError("Connection closed before full response received")
-    result = json.loads(response)
+    from browser_cli import transport
+    result = transport.decode_response(response)
     if not result.get("success", True):
         raise RuntimeError(result.get("error", "unknown error from browser"))
     return result.get("data")
-
-
-def _recv_all(sock: socket.socket) -> bytes:
-    raw_len = _recv_exact(sock, 4)
-    msg_len = struct.unpack("<I", raw_len)[0]
-    if msg_len > _MAX_MSG_BYTES:
-        raise ConnectionError(f"Response too large ({msg_len} bytes)")
-    return _recv_exact(sock, msg_len)
-
-
-def _recv_exact(sock: socket.socket, n: int) -> bytes:
-    buf = b""
-    while len(buf) < n:
-        chunk = sock.recv(n - len(buf))
-        if not chunk:
-            raise ConnectionError("Socket closed before full message received")
-        buf += chunk
-    return buf
diff --git a/browser_cli/commands/__init__.py b/browser_cli/commands/__init__.py
index ff8eae7..55a3b79 100644
--- a/browser_cli/commands/__init__.py
+++ b/browser_cli/commands/__init__.py
@@ -1,40 +1,79 @@
+"""Shared helpers for the Click CLI command modules.
+
+Every CLI command is a thin presentation layer over the Python SDK: it builds a
+:class:`~browser_cli.BrowserCLI` from the global ``--browser/--remote/--key``
+options, calls the matching SDK namespace method, and renders the result. The
+SDK is the single source of truth for command strings, argument shapes, and
+multi-browser routing.
+"""
+import functools
 import click
-from browser_cli.client import BrowserNotConnected, active_browser_targets, remote_browser_targets, send_command
 from rich.console import Console
+from rich.table import Table
+
+from browser_cli import BrowserCLI, BrowserCounts
+from browser_cli.client import BrowserNotConnected
 
 _console = Console()
 
+GENTLE_MODES = ["auto", "normal", "gentle", "ultra"]
 
-def _handle(command, args=None, profile=None):
-    try:
-        return send_command(command, args or {}, profile=profile)
-    except BrowserNotConnected as e:
-        _console.print(f"[red]Error:[/red] {e}")
-        raise SystemExit(1)
-    except RuntimeError as e:
-        _console.print(f"[red]Browser error:[/red] {e}")
-        raise SystemExit(1)
+# Reusable ``--tab`` option: select a tab by ID (default: the active tab).
+tab_option = click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
 
 
-def _handle_multi(command, args=None, profile=None, remote=None):
-    try:
-        if remote:
-            return send_command(command, args or {}, profile=profile, remote=remote)
-        return send_command(command, args or {}, profile=profile)
-    except (BrowserNotConnected, RuntimeError):
-        return None
+def gentle_mode_option(help_text: str):
+    """Reusable ``--gentle-mode`` Click option (throttle mode for large operations)."""
+    return click.option(
+        "--gentle-mode",
+        type=click.Choice(GENTLE_MODES),
+        default="auto",
+        show_default=True,
+        help=help_text,
+    )
 
+def print_counts(result, noun: str, *, single_suffix: str = "") -> None:
+    """Render a count result.
 
-def _multi_browser_targets():
-    root = click.get_current_context().find_root()
-    if root.obj.get("browser_explicit"):
-        return []
-    remote = root.obj.get("remote")
-    key = root.obj.get("key")
-    if remote:
-        targets = remote_browser_targets(remote, key=key)
+    In multi-browser mode (*result* is a :class:`~browser_cli.BrowserCounts`) print a
+    per-browser table with a Total row; otherwise print a single ``N noun(s)`` line.
+    """
+    if isinstance(result, BrowserCounts):
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Browser")
+        table.add_column(f"{noun.capitalize()}s", justify="right")
+        for name, count in result.by_browser.items():
+            table.add_row(name, str(count))
+        table.add_row("Total", str(result.total))
+        _console.print(table)
     else:
-        targets = active_browser_targets(key=key)
-    if len(targets) <= 1 and not any(target.remote for target in targets):
-        return []
-    return targets
+        _console.print(f"[bold]{result}[/bold] {noun}(s){single_suffix}")
+
+def client_from_ctx() -> BrowserCLI:
+    """Build a BrowserCLI from the root context's global options.
+
+    Reads ``browser``/``remote``/``key`` set by the top-level ``main`` group.
+    Falls back to an unconfigured client when a command group is invoked
+    standalone (e.g. in unit tests).
+    """
+    obj = click.get_current_context().find_root().obj or {}
+    return BrowserCLI(browser=obj.get("browser"), remote=obj.get("remote"), key=obj.get("key"))
+
+def handle_errors(fn):
+    """Decorate a CLI command so SDK exceptions become clean errors + exit(1).
+
+    Apply as the innermost decorator (directly above ``def``) so Click's option
+    decorators attach their params to the wrapper.
+    """
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except BrowserNotConnected as e:
+            _console.print(f"[red]Error:[/red] {e}")
+            raise SystemExit(1)
+        except RuntimeError as e:
+            _console.print(f"[red]Browser error:[/red] {e}")
+            raise SystemExit(1)
+
+    return wrapper
diff --git a/browser_cli/commands/cookies.py b/browser_cli/commands/cookies.py
index eea7365..df2f4a8 100644
--- a/browser_cli/commands/cookies.py
+++ b/browser_cli/commands/cookies.py
@@ -1,23 +1,22 @@
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
 @click.group("cookies")
 def cookies_group():
     """Manage browser cookies."""
 
-
 @cookies_group.command("list")
 @click.option("--url", default=None, help="Filter by URL")
 @click.option("--domain", default=None, help="Filter by domain")
 @click.option("--name", default=None, help="Filter by cookie name")
+@handle_errors
 def cookies_list(url, domain, name):
     """List cookies, optionally filtered by URL, domain, or name."""
-    cookies = _handle("cookies.list", {"url": url, "domain": domain, "name": name}) or []
+    cookies = client_from_ctx().cookies.list(url=url, domain=domain, name=name)
     if not cookies:
         console.print("[yellow]No cookies found[/yellow]")
         return
@@ -39,19 +38,18 @@ def cookies_list(url, domain, name):
         )
     console.print(table)
 
-
 @cookies_group.command("get")
 @click.argument("url")
 @click.argument("name")
+@handle_errors
 def cookies_get(url, name):
     """Get the value of a single cookie by URL and NAME."""
-    cookie = _handle("cookies.get", {"url": url, "name": name})
+    cookie = client_from_ctx().cookies.get(url, name)
     if cookie is None:
         console.print(f"[yellow]Cookie '{name}' not found for {url}[/yellow]")
         raise SystemExit(1)
     console.print(cookie.get("value", ""))
 
-
 @cookies_group.command("set")
 @click.argument("url")
 @click.argument("name")
@@ -62,14 +60,13 @@ def cookies_get(url, name):
 @click.option("--http-only", "http_only", is_flag=True)
 @click.option("--expires", "expiration_date", type=float, default=None, help="Unix timestamp")
 @click.option("--same-site", type=click.Choice(["no_restriction", "lax", "strict"]), default=None)
+@handle_errors
 def cookies_set(url, name, value, domain, path, secure, http_only, expiration_date, same_site):
     """Set a cookie on URL."""
-    _handle("cookies.set", {
-        "url": url, "name": name, "value": value,
-        "domain": domain, "path": path,
-        "secure": secure or None,
-        "httpOnly": http_only or None,
-        "expirationDate": expiration_date,
-        "sameSite": same_site,
-    })
+    client_from_ctx().cookies.set(
+        url, name, value,
+        domain=domain, path=path,
+        secure=secure or None, http_only=http_only or None,
+        expiration_date=expiration_date, same_site=same_site,
+    )
     console.print(f"[green]Set cookie:[/green] {name}={value!r} on {url}")
diff --git a/browser_cli/commands/dom.py b/browser_cli/commands/dom.py
index 0d85aeb..ff3ba94 100644
--- a/browser_cli/commands/dom.py
+++ b/browser_cli/commands/dom.py
@@ -1,22 +1,21 @@
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors, tab_option
 from rich.console import Console
 from rich.table import Table
 import json
 
 console = Console()
 
-
 @click.group("dom")
 def dom_group():
     """Query and interact with page DOM elements."""
 
-
 @dom_group.command("query")
 @click.argument("selector")
+@handle_errors
 def dom_query(selector):
     """Return elements matching CSS SELECTOR (like mini DevTools)."""
-    elements = _handle("dom.query", {"selector": selector})
+    elements = client_from_ctx().dom.query(selector)
     if not elements:
         console.print("[yellow]No elements found[/yellow]")
         return
@@ -29,180 +28,164 @@ def dom_query(selector):
         table.add_row(el.get("tag", ""), (el.get("text") or "")[:60], attrs[:80])
     console.print(table)
 
-
 @dom_group.command("click")
 @click.argument("selector")
+@handle_errors
 def dom_click(selector):
     """Click the first element matching CSS SELECTOR."""
-    _handle("dom.click", {"selector": selector})
+    client_from_ctx().dom.click(selector)
     console.print(f"[green]Clicked:[/green] {selector}")
 
-
 @dom_group.command("type")
 @click.argument("selector")
 @click.argument("text")
+@handle_errors
 def dom_type(selector, text):
     """Type TEXT into the element matching CSS SELECTOR."""
-    _handle("dom.type", {"selector": selector, "text": text})
+    client_from_ctx().dom.type(selector, text)
     console.print(f"[green]Typed into:[/green] {selector}")
 
-
 @dom_group.command("attr")
 @click.argument("selector")
 @click.argument("attr_name")
+@handle_errors
 def dom_attr(selector, attr_name):
     """Get attribute ATTR_NAME from elements matching CSS SELECTOR."""
-    values = _handle("dom.attr", {"selector": selector, "attr": attr_name})
-    for v in (values or []):
+    for v in client_from_ctx().dom.attr(selector, attr_name):
         console.print(v)
 
-
 @dom_group.command("text")
 @click.argument("selector")
+@handle_errors
 def dom_text(selector):
     """Get text content of elements matching CSS SELECTOR."""
-    values = _handle("dom.text", {"selector": selector})
-    for v in (values or []):
+    for v in client_from_ctx().dom.text(selector):
         console.print(v)
 
-
 @dom_group.command("exists")
 @click.argument("selector")
+@handle_errors
 def dom_exists(selector):
     """Check if an element matching CSS SELECTOR exists on the page."""
-    exists = _handle("dom.exists", {"selector": selector})
-    if exists:
+    if client_from_ctx().dom.exists(selector):
         console.print(f"[green]exists[/green]: {selector}")
     else:
         console.print(f"[red]not found[/red]: {selector}")
         raise SystemExit(1)
 
-
 @dom_group.command("scroll")
 @click.argument("selector", required=False)
 @click.option("--x", type=int, default=None, help="Horizontal scroll position (px)")
 @click.option("--y", type=int, default=None, help="Vertical scroll position (px)")
+@handle_errors
 def dom_scroll(selector, x, y):
     """Scroll to a CSS SELECTOR or to an X/Y coordinate."""
-    _handle("dom.scroll", {"selector": selector, "x": x, "y": y})
+    client_from_ctx().dom.scroll(selector, x=x, y=y)
     target = selector or f"({x or 0}, {y or 0})"
     console.print(f"[green]Scrolled to:[/green] {target}")
 
-
 @dom_group.command("select")
 @click.argument("selector")
 @click.argument("value")
+@handle_errors
 def dom_select(selector, value):
     """Set the VALUE of a <select> dropdown matching CSS SELECTOR."""
-    _handle("dom.select", {"selector": selector, "value": value})
+    client_from_ctx().dom.select(selector, value)
     console.print(f"[green]Selected '{value}' in:[/green] {selector}")
 
-
 @dom_group.command("eval")
 @click.argument("code")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
+@handle_errors
 def dom_eval(code, tab_id):
     """Evaluate JavaScript CODE in the page and print the result."""
-    result = _handle("dom.eval", {"code": code, "tabId": tab_id})
+    result = client_from_ctx().dom.eval(code, tab_id)
     if result is None:
         console.print("[dim]null[/dim]")
     else:
         console.print(json.dumps(result, indent=2) if isinstance(result, (dict, list)) else str(result))
 
-
 @dom_group.command("wait-for")
 @click.argument("selector")
 @click.option("--timeout", type=float, default=10.0, show_default=True, help="Max seconds to wait")
 @click.option("--visible", is_flag=True, help="Wait until element is visible (non-zero size)")
 @click.option("--hidden", is_flag=True, help="Wait until element is absent or hidden")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
+@handle_errors
 def dom_wait_for(selector, timeout, visible, hidden, tab_id):
     """Wait until CSS SELECTOR appears (or disappears) in the DOM."""
-    _handle("dom.wait_for", {
-        "selector": selector,
-        "timeout": int(timeout * 1000),
-        "visible": visible,
-        "hidden": hidden,
-        "tabId": tab_id,
-    })
+    client_from_ctx().dom.wait_for(selector, timeout=timeout, visible=visible, hidden=hidden, tab_id=tab_id)
     state = "hidden" if hidden else ("visible" if visible else "present")
     console.print(f"[green]Ready ({state}):[/green] {selector}")
 
-
 @dom_group.command("key")
 @click.argument("key")
 @click.option("--selector", default=None, help="CSS selector to target (default: focused element)")
+@handle_errors
 def dom_key(key, selector):
     """Dispatch a keyboard KEY event (e.g. Enter, Tab, Escape, ArrowDown)."""
-    _handle("dom.key", {"key": key, "selector": selector})
+    client_from_ctx().dom.key(key, selector)
     target = selector or "active element"
     console.print(f"[green]Key '{key}' sent to:[/green] {target}")
 
-
 @dom_group.command("hover")
 @click.argument("selector")
+@handle_errors
 def dom_hover(selector):
     """Dispatch mouseover/mouseenter on the element matching CSS SELECTOR."""
-    _handle("dom.hover", {"selector": selector})
+    client_from_ctx().dom.hover(selector)
     console.print(f"[green]Hovered:[/green] {selector}")
 
-
 @dom_group.command("check")
 @click.argument("selector")
+@handle_errors
 def dom_check(selector):
     """Check a checkbox matching CSS SELECTOR."""
-    _handle("dom.check", {"selector": selector})
+    client_from_ctx().dom.check(selector)
     console.print(f"[green]Checked:[/green] {selector}")
 
-
 @dom_group.command("uncheck")
 @click.argument("selector")
+@handle_errors
 def dom_uncheck(selector):
     """Uncheck a checkbox matching CSS SELECTOR."""
-    _handle("dom.uncheck", {"selector": selector})
+    client_from_ctx().dom.uncheck(selector)
     console.print(f"[green]Unchecked:[/green] {selector}")
 
-
 @dom_group.command("clear")
 @click.argument("selector")
+@handle_errors
 def dom_clear(selector):
     """Clear the value of an input matching CSS SELECTOR."""
-    _handle("dom.clear", {"selector": selector})
+    client_from_ctx().dom.clear(selector)
     console.print(f"[green]Cleared:[/green] {selector}")
 
-
 @dom_group.command("focus")
 @click.argument("selector")
+@handle_errors
 def dom_focus(selector):
     """Focus the element matching CSS SELECTOR."""
-    _handle("dom.focus", {"selector": selector})
+    client_from_ctx().dom.focus(selector)
     console.print(f"[green]Focused:[/green] {selector}")
 
-
 @dom_group.command("submit")
 @click.argument("selector")
+@handle_errors
 def dom_submit(selector):
     """Submit the form that contains the element matching CSS SELECTOR."""
-    _handle("dom.submit", {"selector": selector})
+    client_from_ctx().dom.submit(selector)
     console.print(f"[green]Submitted form for:[/green] {selector}")
 
-
 @dom_group.command("poll")
 @click.argument("selector")
 @click.argument("pattern")
 @click.option("--attr", default=None, help="Attribute or property to read (default: textContent/value)")
 @click.option("--timeout", type=float, default=30.0, show_default=True, help="Max seconds to wait")
 @click.option("--interval", type=float, default=0.5, show_default=True, help="Poll interval in seconds")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
+@handle_errors
 def dom_poll(selector, pattern, attr, timeout, interval, tab_id):
     """Poll SELECTOR until its text/value matches regex PATTERN."""
-    result = _handle("dom.poll", {
-        "selector": selector,
-        "pattern": pattern,
-        "attr": attr,
-        "timeout": int(timeout * 1000),
-        "interval": int(interval * 1000),
-        "tabId": tab_id,
-    })
+    result = client_from_ctx().dom.poll(selector, pattern, attr=attr, timeout=timeout, interval=interval, tab_id=tab_id)
     value = result.get("value", "") if isinstance(result, dict) else ""
     console.print(f"[green]Matched:[/green] {selector!r} = {value!r}")
diff --git a/browser_cli/commands/extension.py b/browser_cli/commands/extension.py
index 5b06585..6a87291 100644
--- a/browser_cli/commands/extension.py
+++ b/browser_cli/commands/extension.py
@@ -1,7 +1,6 @@
-import time
 import click
 from rich.console import Console
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
 
 console = Console()
 
@@ -10,6 +9,7 @@ def extension_group():
     """Manage the browser-cli browser extension."""
 
 @extension_group.command("reload")
+@handle_errors
 def extension_reload():
     """Reload the browser-cli extension service worker.
 
@@ -17,5 +17,5 @@ def extension_reload():
     The command returns immediately; the extension restarts ~200 ms later.
     Re-connects automatically via the keepalive alarm within ~25 seconds.
     """
-    _handle("extension.reload")
+    client_from_ctx().extension.reload()
     console.print("[green]Extension reloading…[/green] reconnects automatically")
diff --git a/browser_cli/commands/extract.py b/browser_cli/commands/extract.py
index 3107c0f..2e67da8 100644
--- a/browser_cli/commands/extract.py
+++ b/browser_cli/commands/extract.py
@@ -1,437 +1,24 @@
 import json
-import re
-from html.parser import HTMLParser
 
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
+# Re-exported for backward compatibility: the HTML→Markdown engine now lives in
+# browser_cli.markdown and is applied by the SDK (ExtractNS.markdown).
+from browser_cli.markdown import _clean_markdown_output, _convert_html_to_markdown  # noqa: F401
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
-_FENCE_RE = re.compile(r"```(?:[^\n`]*)\n.*?\n```", re.DOTALL)
-_ESCAPED_MARKDOWN_RE = re.compile(r"\\([_-])")
-_TABLE_SEPARATOR_RE = re.compile(r"^\|(?:\s*:?-{3,}:?\s*\|)+\s*$")
-
-
-class _HtmlNode:
-    def __init__(self, tag=None, attrs=None, text=None):
-        self.tag = tag
-        self.attrs = attrs or {}
-        self.text = text
-        self.children = []
-
-
-class _HtmlTreeBuilder(HTMLParser):
-    _VOID_TAGS = {"br", "hr", "img"}
-
-    def __init__(self):
-        super().__init__(convert_charrefs=True)
-        self.root = _HtmlNode(tag="document")
-        self._stack = [self.root]
-
-    def handle_starttag(self, tag, attrs):
-        node = _HtmlNode(tag=tag.lower(), attrs=dict(attrs))
-        self._stack[-1].children.append(node)
-        if node.tag not in self._VOID_TAGS:
-            self._stack.append(node)
-
-    def handle_startendtag(self, tag, attrs):
-        node = _HtmlNode(tag=tag.lower(), attrs=dict(attrs))
-        self._stack[-1].children.append(node)
-
-    def handle_endtag(self, tag):
-        lowered = tag.lower()
-        for index in range(len(self._stack) - 1, 0, -1):
-            if self._stack[index].tag == lowered:
-                del self._stack[index:]
-                break
-
-    def handle_data(self, data):
-        if data:
-            self._stack[-1].children.append(_HtmlNode(text=data))
-
-
-def _normalize_text(value):
-    return re.sub(r"\s+", " ", value or "").strip()
-
-
-def _normalize_inline(value):
-    value = value.replace("\xa0", " ")
-    value = re.sub(r"[ \t\r\f\v]+", " ", value)
-    value = re.sub(r" *\n *", "\n", value)
-    return value.strip()
-
-
-def _collapse_blank_lines(value):
-    value = re.sub(r"[ \t]+\n", "\n", value)
-    value = re.sub(r"\n{3,}", "\n\n", value)
-    return value.strip()
-
-
-def _escape_markdown(text):
-    return re.sub(r"([\\`[\]])", r"\\\1", text)
-
-
-def _escape_table_cell(text):
-    return text.replace("|", r"\|").replace("\n", " ").strip()
-
-
-def _iter_descendants(node):
-    for child in getattr(node, "children", []):
-        yield child
-        yield from _iter_descendants(child)
-
-
-def _has_class(node, class_name):
-    classes = (node.attrs.get("class") or "").split()
-    return class_name in classes
-
-
-def _is_code_block_node(node):
-    if not node or not node.tag:
-        return False
-    if node.attrs.get("data-is-code-block-view") == "true":
-        return True
-    return node.tag == "pre"
-
-
-def _inline_text(node):
-    if node.text is not None:
-        return _escape_markdown(node.text)
-    if not node.tag:
-        return ""
-
-    tag = node.tag
-    if tag == "br":
-        return "\n"
-    if tag == "img":
-        src = node.attrs.get("src") or ""
-        alt = _normalize_text(node.attrs.get("alt") or "")
-        if not src:
-            return ""
-        return f"![{_escape_markdown(alt)}]({src})" if alt else f"![]({src})"
-    if tag == "a":
-        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
-        href = node.attrs.get("href") or ""
-        return f"[{text or href}]({href})" if href else text
-    if tag == "code":
-        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
-        return f"`{text.replace('`', r'\\`')}`" if text else ""
-    if tag in {"strong", "b"}:
-        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
-        return f"**{text}**" if text else ""
-    if tag in {"em", "i"}:
-        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
-        return f"*{text}*" if text else ""
-
-    chunks = []
-    for child in node.children:
-        rendered = _inline_text(child)
-        if rendered:
-            chunks.append(rendered)
-            if child.tag in {"p", "div", "table", "ul", "ol", "pre"}:
-                chunks.append("\n")
-    return "".join(chunks)
-
-
-def _text_block(node):
-    return _collapse_blank_lines(_normalize_inline("".join(_inline_text(child) for child in node.children)))
-
-
-def _inner_text_preserve(node):
-    if node.text is not None:
-        return node.text
-    if not node.tag:
-        return ""
-    if node.tag == "br":
-        return ""
-    return "".join(_inner_text_preserve(child) for child in node.children)
-
-
-def _table_to_markdown(node):
-    rows = []
-    for descendant in _iter_descendants(node):
-        if descendant.tag != "tr":
-            continue
-        row = []
-        for cell in descendant.children:
-            if cell.tag in {"td", "th"}:
-                row.append(_escape_table_cell(_text_block(cell)))
-        if row:
-            rows.append(row)
-    if not rows:
-        return ""
-
-    widths = max(len(row) for row in rows)
-    normalized_rows = [row + [""] * (widths - len(row)) for row in rows]
-
-    headers = normalized_rows[0]
-    body_rows = normalized_rows[1:]
-    first_row_blank = all(not cell.strip() for cell in headers)
-    if first_row_blank and len(normalized_rows) > 1:
-        headers = normalized_rows[1]
-        body_rows = normalized_rows[2:]
-
-    has_thead = any(child.tag == "thead" for child in node.children)
-    first_row = next((child for child in _iter_descendants(node) if child.tag == "tr"), None)
-    first_row_has_th = bool(first_row and any(child.tag == "th" for child in first_row.children))
-    if not (has_thead or first_row_has_th or first_row_blank):
-        headers = [""] * widths
-        body_rows = normalized_rows
-
-    separator = ["---"] * widths
-    lines = [
-        f"| {' | '.join(headers)} |",
-        f"| {' | '.join(separator)} |",
-    ]
-    lines.extend(f"| {' | '.join(row)} |" for row in body_rows)
-    return "\n".join(lines)
-
-
-def _list_to_markdown(node, depth=0):
-    ordered = node.tag == "ol"
-    items = []
-    index = 1
-    for child in node.children:
-        if child.tag != "li":
-            continue
-        marker = f"{index}. " if ordered else "- "
-        index += 1
-        content = []
-        nested = []
-        for item_child in child.children:
-            if item_child.tag in {"ul", "ol"}:
-                nested.append(_list_to_markdown(item_child, depth + 1))
-            else:
-                content.append(_inline_text(item_child))
-        line = _collapse_blank_lines(_normalize_inline("".join(content)))
-        indent = "  " * depth
-        if line:
-            line_parts = line.splitlines()
-            items.append(f"{indent}{marker}{line_parts[0]}")
-            continuation_indent = f"{indent}{' ' * len(marker)}"
-            items.extend(f"{continuation_indent}{part}" for part in line_parts[1:])
-        items.extend(block for block in nested if block)
-    return "\n".join(items)
-
-
-def _code_block_to_markdown(node):
-    if node.tag == "pre":
-        text = _inner_text_preserve(node).rstrip("\n")
-        return f"```\n{text}\n```" if text else ""
-
-    lines = []
-    for descendant in _iter_descendants(node):
-        if descendant.tag and _has_class(descendant, "cm-line"):
-            lines.append(_inner_text_preserve(descendant))
-    code = "\n".join(lines).rstrip("\n")
-    return f"```\n{code}\n```" if code else ""
-
-
-def _block_to_markdown(node):
-    if node.text is not None:
-        return _normalize_text(node.text)
-    if not node.tag:
-        return ""
-    if _is_code_block_node(node):
-        return _code_block_to_markdown(node)
-    if node.tag == "table":
-        return _table_to_markdown(node)
-    if node.tag in {"ul", "ol"}:
-        return _list_to_markdown(node)
-    if re.fullmatch(r"h[1-6]", node.tag):
-        text = _text_block(node)
-        return f"{'#' * int(node.tag[1])} {text}" if text else ""
-    if node.tag in {"p", "figcaption"}:
-        return _text_block(node)
-    if node.tag == "blockquote":
-        content = _collapse_blank_lines("\n\n".join(filter(None, (_block_to_markdown(child) for child in node.children))))
-        return "\n".join(f"> {line}" if line else ">" for line in content.splitlines()) if content else ""
-    if node.tag == "hr":
-        return "---"
-    if node.tag == "img":
-        return _inline_text(node)
-
-    child_blocks = [block for block in (_block_to_markdown(child) for child in node.children) if block]
-    if child_blocks:
-        return _collapse_blank_lines("\n\n".join(child_blocks))
-    return _text_block(node)
-
-
-def _parse_table_row(line):
-    stripped = line.strip()
-    if not stripped.startswith("|") or not stripped.endswith("|"):
-        return None
-    return [cell.strip() for cell in stripped.strip("|").split("|")]
-
-
-def _repair_table_headers(lines):
-    repaired = []
-    index = 0
-    while index < len(lines):
-        if (
-            index + 2 < len(lines)
-            and _parse_table_row(lines[index]) is not None
-            and _TABLE_SEPARATOR_RE.match(lines[index + 1].strip())
-            and _parse_table_row(lines[index + 2]) is not None
-        ):
-            first = _parse_table_row(lines[index])
-            third = _parse_table_row(lines[index + 2])
-            if first and all(not cell for cell in first) and any(cell for cell in third):
-                repaired.append(lines[index + 2].strip())
-                repaired.append(lines[index + 1].strip())
-                index += 3
-                continue
-        repaired.append(lines[index].strip())
-        index += 1
-    return repaired
-
-
-def _repair_list_continuations(lines):
-    repaired = []
-    previous_was_list_item = False
-    previous_continuation_indent = ""
-
-    for line in lines:
-        stripped = line.strip()
-        list_match = re.match(r"^(\s*)([-*+]|\d+\.)\s+.+$", stripped)
-        is_markdown_block_start = (
-            not stripped
-            or stripped.startswith(("```", "#", ">", "|"))
-            or _TABLE_SEPARATOR_RE.match(stripped)
-            or re.match(r"^(\s*)([-*+]|\d+\.)\s+", stripped)
-        )
-
-        if previous_was_list_item and stripped and not is_markdown_block_start:
-            repaired.append(f"{previous_continuation_indent}{stripped}")
-            previous_was_list_item = False
-            continue
-
-        repaired.append(stripped)
-        if list_match:
-            marker = list_match.group(2)
-            base_indent = list_match.group(1)
-            previous_continuation_indent = f"{base_indent}{' ' * (len(marker) + 1)}"
-            previous_was_list_item = True
-        else:
-            previous_was_list_item = False
-
-    return repaired
-
-
-def _repair_flattened_diagram(text):
-    if "\n" in text:
-        return text
-    if sum(text.count(char) for char in "│▼├└") < 2:
-        return text
-
-    text = re.sub(r"\s{2,}([│▼])", r"\n   \1", text)
-    text = re.sub(r"([│▼])\s{2,}", r"\1\n", text)
-    text = re.sub(r"([│▼])(?=[^\s\n│▼├└])", r"\1\n", text)
-    text = re.sub(r"(?<=[^\s\n])([├└])", r"\n\1", text)
-    text = re.sub(r"([^\s\n])(\()", r"\1\n\2", text)
-    return "\n".join(line.rstrip() for line in text.splitlines() if line.strip())
-
-
-def _convert_dash_lists_to_branches(lines):
-    converted = []
-    index = 0
-    while index < len(lines):
-        match = re.match(r"^(\s*)-\s+(.*)$", lines[index])
-        if not match:
-            converted.append(lines[index])
-            index += 1
-            continue
-
-        indent = match.group(1)
-        items = []
-        while index < len(lines):
-            next_match = re.match(rf"^{re.escape(indent)}-\s+(.*)$", lines[index])
-            if not next_match:
-                break
-            items.append(next_match.group(1))
-            index += 1
-
-        for item_index, item in enumerate(items):
-            branch = "└" if item_index == len(items) - 1 else "├"
-            converted.append(f"{indent}{branch} {item}")
-    return converted
-
-
-def _clean_code_block(code):
-    lines = [line.rstrip() for line in code.splitlines()]
-    while lines and not lines[0].strip():
-        lines.pop(0)
-    while lines and not lines[-1].strip():
-        lines.pop()
-
-    flattened = _repair_flattened_diagram("\n".join(lines))
-    lines = flattened.splitlines() if flattened else []
-    lines = [
-        f"   {line.strip()}"
-        if line.strip() in {"│", "▼"} and not re.match(r"^\s+[│▼]\s*$", line)
-        else line
-        for line in lines
-    ]
-    lines = _convert_dash_lists_to_branches(lines)
-    return "\n".join(lines)
-
-
-def _clean_markdown_output(markdown):
-    if not markdown:
-        return ""
-
-    pieces = []
-    last_index = 0
-    for match in _FENCE_RE.finditer(markdown):
-        prose = markdown[last_index:match.start()]
-        if prose:
-            cleaned = _ESCAPED_MARKDOWN_RE.sub(r"\1", prose)
-            lines = [line.strip() for line in cleaned.splitlines()]
-            lines = _repair_table_headers(lines)
-            lines = _repair_list_continuations(lines)
-            cleaned = "\n".join(lines)
-            cleaned = _collapse_blank_lines(cleaned)
-            if cleaned:
-                pieces.append(cleaned)
-
-        fence = match.group(0)
-        header, _, tail = fence.partition("\n")
-        body, _, _ = tail.rpartition("\n")
-        cleaned_body = _clean_code_block(body)
-        pieces.append(f"{header}\n{cleaned_body}\n```" if cleaned_body else f"{header}\n```")
-        last_index = match.end()
-
-    trailing = markdown[last_index:]
-    if trailing:
-        cleaned = _ESCAPED_MARKDOWN_RE.sub(r"\1", trailing)
-        lines = [line.strip() for line in cleaned.splitlines()]
-        lines = _repair_table_headers(lines)
-        lines = _repair_list_continuations(lines)
-        cleaned = "\n".join(lines)
-        cleaned = _collapse_blank_lines(cleaned)
-        if cleaned:
-            pieces.append(cleaned)
-
-    return "\n\n".join(piece for piece in pieces if piece)
-
-
-def _convert_html_to_markdown(html):
-    parser = _HtmlTreeBuilder()
-    parser.feed(html or "")
-    markdown = _block_to_markdown(parser.root)
-    return _clean_markdown_output(markdown)
-
 
 @click.group("extract")
 def extract_group():
     """Extract content from the active tab."""
 
-
 @extract_group.command("links")
+@handle_errors
 def extract_links():
     """Extract all links from the active tab."""
-    links = _handle("extract.links")
+    links = client_from_ctx().extract.links()
     if not links:
         console.print("[yellow]No links found[/yellow]")
         return
@@ -442,11 +29,11 @@ def extract_links():
         table.add_row((lnk.get("text") or "")[:60], lnk.get("href") or "")
     console.print(table)
 
-
 @extract_group.command("images")
+@handle_errors
 def extract_images():
     """Extract all images from the active tab."""
-    images = _handle("extract.images")
+    images = client_from_ctx().extract.images()
     if not images:
         console.print("[yellow]No images found[/yellow]")
         return
@@ -457,36 +44,30 @@ def extract_images():
         table.add_row((img.get("alt") or "")[:40], img.get("src") or "")
     console.print(table)
 
-
 @extract_group.command("text")
+@handle_errors
 def extract_text():
     """Extract all visible text from the active tab."""
-    text = _handle("extract.text")
-    console.print(text or "")
-
+    console.print(client_from_ctx().extract.text())
 
 @extract_group.command("json")
 @click.argument("selector")
+@handle_errors
 def extract_json(selector):
     """Parse and pretty-print JSON content inside SELECTOR."""
-    data = _handle("extract.json", {"selector": selector})
+    data = client_from_ctx().extract.json(selector)
     console.print_json(json.dumps(data))
 
-
 @extract_group.command("html")
+@handle_errors
 def extract_html():
     """Print the full HTML of the active tab to stdout."""
-    html = _handle("extract.html")
-    click.echo(html or "")
-
+    click.echo(client_from_ctx().extract.html())
 
 @extract_group.command("markdown")
 @click.option("--selector", help="Extract only the DOM subtree matching this CSS selector.")
+@handle_errors
 def extract_markdown(selector):
     """Extract the page's main content as Markdown."""
-    markdown = _handle("extract.markdown", {"selector": selector})
-    if (markdown or "").lstrip().startswith("<"):
-        markdown = _convert_html_to_markdown(markdown)
-    else:
-        markdown = _clean_markdown_output(markdown or "")
+    markdown = client_from_ctx().extract.markdown(selector)
     click.echo(markdown or "", nl=not (markdown or "").endswith("\n"))
diff --git a/browser_cli/commands/groups.py b/browser_cli/commands/groups.py
index b3a758f..0918b42 100644
--- a/browser_cli/commands/groups.py
+++ b/browser_cli/commands/groups.py
@@ -1,12 +1,11 @@
 import click
-from browser_cli.commands import _handle, _handle_multi, _multi_browser_targets
+from browser_cli.commands import client_from_ctx, gentle_mode_option, handle_errors, print_counts
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
-def _print_groups(groups: list[dict], *, show_browser: bool = False) -> None:
+def _print_groups(groups, *, show_browser: bool = False) -> None:
     if not groups:
         console.print("[yellow]No groups found[/yellow]")
         return
@@ -20,128 +19,88 @@ def _print_groups(groups: list[dict], *, show_browser: bool = False) -> None:
     table.add_column("Tabs", width=6)
     for g in groups:
         row = [
-            g.get("browser", "") if show_browser else None,
-            str(g.get("id", "")),
-            g.get("title") or "",
-            g.get("color") or "",
-            "yes" if g.get("collapsed") else "no",
-            str(g.get("tabCount", "")),
+            (g.browser or "") if show_browser else None,
+            str(g.id),
+            g.title or "",
+            g.color or "",
+            "yes" if g.collapsed else "no",
+            str(g.tab_count),
         ]
         table.add_row(*[value for value in row if value is not None])
     console.print(table)
 
-
 @click.group("groups")
 def group_group():
     """Manage tab groups."""
 
-
 @group_group.command("list")
+@handle_errors
 def group_list():
     """List all tab groups."""
-    targets = _multi_browser_targets()
-    if targets:
-        groups = []
-        for target in targets:
-            result = _handle_multi("group.list", profile=target.profile, remote=target.remote)
-            if result is None:
-                continue
-            groups.extend({**group, "browser": target.display_name} for group in result)
-        if not groups:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        _print_groups(groups, show_browser=True)
-        return
-    groups = _handle("group.list")
-    _print_groups(groups or [])
-
+    groups = client_from_ctx().groups.list()
+    _print_groups(groups, show_browser=any(g.browser for g in groups))
 
 @group_group.command("tabs")
 @click.argument("group_id", type=int)
+@handle_errors
 def group_tabs(group_id):
     """List tabs inside a group."""
     from browser_cli.commands.tabs import _print_tabs
-    tabs = _handle("group.tabs", {"groupId": group_id})
-    _print_tabs(tabs or [])
-
+    _print_tabs(client_from_ctx().groups.tabs(group_id))
 
 @group_group.command("count")
+@handle_errors
 def group_count():
     """Count all tab groups."""
-    targets = _multi_browser_targets()
-    if targets:
-        table = Table(show_header=True, header_style="bold cyan")
-        table.add_column("Browser")
-        table.add_column("Groups", justify="right")
-        total = 0
-        rows = 0
-        for target in targets:
-            count = _handle_multi("group.count", profile=target.profile, remote=target.remote)
-            if count is None:
-                continue
-            count = int(count or 0)
-            total += count
-            rows += 1
-            table.add_row(target.display_name, str(count))
-        if rows == 0:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        table.add_row("Total", str(total))
-        console.print(table)
-        return
-    count = _handle("group.count")
-    console.print(f"[bold]{count}[/bold] group(s)")
-
+    print_counts(client_from_ctx().groups.count(), "group")
 
 @group_group.command("query")
 @click.argument("search")
+@handle_errors
 def group_query(search):
     """Search groups by name."""
-    groups = _handle("group.query", {"search": search})
-    _print_groups(groups or [])
-
+    _print_groups(client_from_ctx().groups.query(search))
 
 @group_group.command("close")
 @click.argument("group_id", type=int)
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large group operations.")
+@gentle_mode_option("Throttle mode for large group operations.")
+@handle_errors
 def group_close(group_id, gentle_mode):
     """Close (ungroup and optionally close) a tab group."""
-    _handle("group.close", {"groupId": group_id, "gentleMode": gentle_mode})
+    client_from_ctx().groups.close(group_id, gentle_mode=gentle_mode)
     console.print(f"[green]Group {group_id} closed[/green]")
 
-
 @group_group.command("create")
 @click.argument("name")
+@handle_errors
 def group_create(name):
     """Create a new tab group with NAME."""
-    result = _handle("group.open", {"name": name})
-    gid = result.get("id") if isinstance(result, dict) else result
-    console.print(f"[green]Created group '{name}'[/green] (id: {gid})")
-
+    group = client_from_ctx().groups.create(name)
+    console.print(f"[green]Created group '{name}'[/green] (id: {group.id})")
 
 @group_group.command("add-tab")
 @click.argument("group")
 @click.argument("url", required=False)
+@handle_errors
 def group_add_tab(group, url):
     """Open a new tab (optionally at URL) inside GROUP (name or ID)."""
-    result = _handle("group.add_tab", {"group": group, "url": url})
-    tab_id = result.get("tabId") if isinstance(result, dict) else result
+    tab_id = client_from_ctx().groups.add_tab(group, url)
     label = url or "new tab"
     console.print(f"[green]Opened {label}[/green] in group '{group}' (tab id: {tab_id})")
 
-
 @group_group.command("move")
 @click.argument("group")
 @click.option("-f", "--forward", "forward", is_flag=True, help="Move group one position to the right")
 @click.option("-b", "--backward", "backward", is_flag=True, help="Move group one position to the left")
 @click.option("-r", "--right", "forward", is_flag=True, help="Move group one position to the right")
 @click.option("-l", "--left", "backward", is_flag=True, help="Move group one position to the left")
+@handle_errors
 def group_move(group, forward, backward):
     """Move a tab group forward/backward or right/left (name or ID)."""
     if not forward and not backward:
         console.print("[red]Specify --forward/--right or --backward/--left[/red]")
         raise SystemExit(1)
-    result = _handle("group.move", {"group": group, "forward": forward, "backward": backward})
+    result = client_from_ctx().groups.move(group, forward=forward, backward=backward)
     if isinstance(result, dict) and not result.get("moved"):
         console.print(f"[yellow]Group '{group}' is already at the {'end' if forward else 'start'}[/yellow]")
     else:
diff --git a/browser_cli/commands/navigate.py b/browser_cli/commands/navigate.py
index ef31b1f..1611daa 100644
--- a/browser_cli/commands/navigate.py
+++ b/browser_cli/commands/navigate.py
@@ -1,23 +1,22 @@
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors, tab_option
 from rich.console import Console
 
 console = Console()
 
-
 @click.group("nav")
 def nav_group():
     """Navigate — open URLs, reload, go back/forward, focus tabs."""
 
-
 @nav_group.command("open")
 @click.argument("url")
 @click.option("--bg", is_flag=True, help="Open in background (no focus)")
 @click.option("--window", "window_name", default=None, help="Open in named window")
 @click.option("--group", "group_name", default=None, help="Open directly into a tab group (name or ID)")
+@handle_errors
 def cmd_open(url, bg, window_name, group_name):
     """Open URL in a new tab."""
-    _handle("navigate.open", {"url": url, "background": bg, "window": window_name, "group": group_name})
+    client_from_ctx().nav.open(url, background=bg, window=window_name, group=group_name)
     suffix = ""
     if group_name:
         suffix = f" in group '{group_name}'"
@@ -25,71 +24,67 @@ def cmd_open(url, bg, window_name, group_name):
         suffix = f" in window '{window_name}'"
     console.print(f"[green]Opened:[/green] {url}{suffix}")
 
-
 @nav_group.command("reload")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def cmd_reload(tab_id):
     """Reload the active (or specified) tab."""
-    _handle("navigate.reload", {"tabId": tab_id})
+    client_from_ctx().nav.reload(tab_id)
     console.print("[green]Reloaded[/green]")
 
-
 @nav_group.command("hard-reload")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def cmd_hard_reload(tab_id):
     """Hard reload (bypass cache) the active (or specified) tab."""
-    _handle("navigate.hard_reload", {"tabId": tab_id})
+    client_from_ctx().nav.hard_reload(tab_id)
     console.print("[green]Hard reloaded[/green]")
 
-
 @nav_group.command("back")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def cmd_back(tab_id):
     """Navigate back in the active (or specified) tab."""
-    _handle("navigate.back", {"tabId": tab_id})
+    client_from_ctx().nav.back(tab_id)
     console.print("[green]Navigated back[/green]")
 
-
 @nav_group.command("forward")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def cmd_forward(tab_id):
     """Navigate forward in the active (or specified) tab."""
-    _handle("navigate.forward", {"tabId": tab_id})
+    client_from_ctx().nav.forward(tab_id)
     console.print("[green]Navigated forward[/green]")
 
-
 @nav_group.command("focus")
 @click.argument("pattern")
+@handle_errors
 def cmd_focus(pattern):
     """Jump to a tab by URL pattern or tab ID."""
-    result = _handle("navigate.focus", {"pattern": pattern})
+    result = client_from_ctx().nav.focus(pattern)
     if result:
         console.print(f"[green]Focused:[/green] {result.get('url', result)}")
     else:
         console.print(f"[yellow]No tab found matching:[/yellow] {pattern}")
 
-
 @nav_group.command("open-wait")
 @click.argument("url")
 @click.option("--timeout", type=float, default=30.0, show_default=True, help="Max seconds to wait for load")
 @click.option("--bg", is_flag=True, help="Open in background (no focus)")
 @click.option("--window", "window_name", default=None, help="Open in named window")
 @click.option("--group", "group_name", default=None, help="Open in tab group")
+@handle_errors
 def cmd_open_wait(url, timeout, bg, window_name, group_name):
     """Open URL in a new tab and wait until fully loaded."""
-    result = _handle("navigate.open_wait", {
-        "url": url, "timeout": int(timeout * 1000),
-        "background": bg, "window": window_name, "group": group_name,
-    })
-    title = result.get("title", "") if isinstance(result, dict) else ""
-    console.print(f"[green]Loaded:[/green] {url}" + (f" — {title}" if title else ""))
-
+    tab = client_from_ctx().nav.open_wait(url, timeout=timeout, background=bg, window=window_name, group=group_name)
+    console.print(f"[green]Loaded:[/green] {url}" + (f" — {tab.title}" if tab.title else ""))
 
 @nav_group.command("wait")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
 @click.option("--timeout", type=float, default=30.0, show_default=True, help="Max seconds to wait")
 @click.option("--ready-state", type=click.Choice(["complete", "interactive"]), default="complete", show_default=True, help="Target ready state")
+@handle_errors
 def cmd_wait(tab_id, timeout, ready_state):
     """Wait until tab finishes loading."""
-    result = _handle("navigate.wait", {"tabId": tab_id, "timeout": int(timeout * 1000), "readyState": ready_state})
-    console.print(f"[green]Ready:[/green] {result.get('url', '')} — {result.get('title', '')}")
+    tab = client_from_ctx().tabs.wait_for_load(tab_id, timeout=timeout, ready_state=ready_state)
+    console.print(f"[green]Ready:[/green] {tab.url} — {tab.title}")
diff --git a/browser_cli/commands/page.py b/browser_cli/commands/page.py
index 99cd4de..1d727ff 100644
--- a/browser_cli/commands/page.py
+++ b/browser_cli/commands/page.py
@@ -1,20 +1,19 @@
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
 @click.group("page")
 def page_group():
     """Inspect current page metadata."""
 
-
 @page_group.command("info")
+@handle_errors
 def page_info():
     """Show title, URL, readyState, language, and meta tags of the active tab."""
-    info = _handle("page.info") or {}
+    info = client_from_ctx().page.info()
     table = Table(show_header=False)
     table.add_column("Field", style="bold cyan", no_wrap=True)
     table.add_column("Value")
diff --git a/browser_cli/commands/perf.py b/browser_cli/commands/perf.py
index d9a2dc7..1c688e3 100644
--- a/browser_cli/commands/perf.py
+++ b/browser_cli/commands/perf.py
@@ -1,7 +1,7 @@
 import click
 from rich.console import Console
 from rich.table import Table
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
 
 console = Console()
 
@@ -10,9 +10,10 @@ def perf_group():
     """Inspect and tune browser-cli performance behavior."""
 
 @perf_group.command("status")
+@handle_errors
 def perf_status():
     """Show performance profile, throttle and running jobs."""
-    result = _handle("perf.status") or {}
+    result = client_from_ctx().perf.status()
     console.print(f"Profile: [bold]{result.get('performanceProfile', 'auto')}[/bold]")
     console.print(f"Audible tabs: {'yes' if result.get('audible') else 'no'}")
     throttle = result.get("throttle") or {}
@@ -39,7 +40,8 @@ def perf_status():
 
 @perf_group.command("profile")
 @click.argument("profile", type=click.Choice(["auto", "normal", "gentle", "ultra"]))
+@handle_errors
 def perf_profile(profile):
     """Set global performance profile."""
-    result = _handle("perf.set_profile", {"profile": profile}) or {}
+    result = client_from_ctx().perf.set_profile(profile)
     console.print(f"[green]Performance profile set to {result.get('performanceProfile', profile)}[/green]")
diff --git a/browser_cli/commands/search.py b/browser_cli/commands/search.py
index f0aaeaf..11c7402 100644
--- a/browser_cli/commands/search.py
+++ b/browser_cli/commands/search.py
@@ -1,6 +1,5 @@
 import click
-from urllib.parse import quote_plus
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors
 from rich.console import Console
 
 console = Console()
@@ -61,23 +60,21 @@ _SUBCOMMANDS = [
 def search_group():
     """Search the web — open a query in a search engine."""
 
-
 def _build_command(engine_key: str, help_text: str) -> click.Command:
     @click.command(engine_key, help=help_text)
     @click.argument("query", nargs=-1, required=True)
     @click.option("--bg", is_flag=True, help="Open in background (no focus)")
     @click.option("--window", "window", default=None, help="Open in named window")
     @click.option("--group", "group", default=None, help="Open in tab group (name or ID)")
+    @handle_errors
     def _cmd(query, bg, window, group):
         terms = " ".join(query)
-        url = ENGINES[engine_key].format(query=quote_plus(terms))
-        _handle("navigate.open", {"url": url, "background": bg, "window": window, "group": group})
+        client_from_ctx().nav.search(engine_key, terms, background=bg, window=window, group=group)
         suffix = f" in group '{group}'" if group else (f" in window '{window}'" if window else "")
         display = _DISPLAY_NAMES.get(engine_key, engine_key.capitalize())
         console.print(f"[green]Searching[/green] [cyan]{display}[/cyan]: {terms}{suffix}")
 
     return _cmd
 
-
 for _name, _help in _SUBCOMMANDS:
     search_group.add_command(_build_command(_name, _help))
diff --git a/browser_cli/commands/serve.py b/browser_cli/commands/serve.py
index 5c88577..885621c 100644
--- a/browser_cli/commands/serve.py
+++ b/browser_cli/commands/serve.py
@@ -4,6 +4,7 @@ from pathlib import Path
 
 from rich.console import Console
 
+from browser_cli import transport
 from browser_cli.client import _recv_exact, _recv_all
 from browser_cli.compat import adapt_auth, adapt_request, adapt_response
 from browser_cli.version_manager import PROTOCOL_MIN_CLIENT, MAX_MSG_BYTES, parse_version, get_installed_version
@@ -12,7 +13,6 @@ _UA_PATTERN = re.compile(r"^browser-cli/\d")
 _CONN_LIMIT = threading.BoundedSemaphore(64)
 console = Console()
 
-
 def _framed_send(sock: socket.socket, data: bytes) -> None:
   sock.sendall(struct.pack("<I", len(data)) + data)
 
@@ -25,11 +25,12 @@ def _log(addr:tuple, command:str, profile:str|None, status:str, error:str|None=N
   else:
     console.print(f"[dim]{ts}[/dim] {addr_str} {profile_str}[cyan]{command}[/cyan] [green]{status}[/green]")
 
-def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth_keys:list[str]|None, auth_keys_path:"Path|None", nonce:str, pq_private_key=None) -> None:
+def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth_keys:list[str]|None, auth_keys_path:"Path|None", nonce:str, pq_private_key=None, compress:bool=True) -> None:
   from browser_cli.client import _resolve_socket, BrowserNotConnected
   from browser_cli.platform import is_windows
 
   response_secret = None
+  accept_encoding = None  # set once the (decrypted) request is parsed; None → plain JSON
 
   def _send_payload(data: bytes) -> None:
     if response_secret is not None:
@@ -38,16 +39,17 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
     _framed_send(client_sock, data)
 
   def _send_error(msg_id, msg:str) -> None:
+    # errors stay plain JSON: tiny, and safe for any client
     err = json.dumps({"id": msg_id, "success": False, "error": msg}).encode()
     try:
       _send_payload(err)
     except OSError:
       pass
 
-  def _send_ok(msg_id, payload) -> None:
-    out = json.dumps({"id": msg_id, "success": True, "data": payload}).encode()
+  def _send_ok(msg_id, payload, command=None) -> None:
+    obj = {"id": msg_id, "success": True, "data": payload}
     try:
-      _send_payload(out)
+      _send_payload(transport.encode_response(obj, accept_encoding if compress else None, command))
     except OSError:
       pass
 
@@ -141,13 +143,16 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
       return
     response_secret = pq_shared_secret if transport_encrypted else None
 
+  # client advertises what response encodings it can decode (signed, then stripped)
+  accept_encoding = msg.get("accept_encoding")
+
   if command == "browser-cli.targets":
     from browser_cli.client import active_browser_targets
     targets = [
       {"profile": target.profile, "displayName": target.display_name}
       for target in active_browser_targets(include_remotes=False)
     ]
-    _send_ok(msg_id, targets)
+    _send_ok(msg_id, targets, command)
     _log(addr, command, None, "OK")
     return
 
@@ -158,7 +163,7 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
       return
     from browser_cli.auth import load_authorized_keys_with_names
     entries = [{"pubkey": pk, "name": name} for pk, name in load_authorized_keys_with_names(auth_keys_path)]
-    _send_ok(msg_id, entries)
+    _send_ok(msg_id, entries, command)
     _log(addr, command, None, "OK")
     return
 
@@ -176,14 +181,14 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
       _log(addr, command, None, "ERROR", "invalid pubkey")
       return
     added = add_authorized_key(auth_keys_path, pubkey, name)
-    _send_ok(msg_id, {"added": added})
+    _send_ok(msg_id, {"added": added}, command)
     _log(addr, command, None, "OK" if added else "ALREADY_TRUSTED")
     return
 
   resolved_profile = msg.get("_route") or profile
 
   # ── strip protocol fields, apply request compat shim, forward ─────────────
-  strip = {"token", "_route", "pubkey", "sig", "user_agent", "pq_kex", "encrypted"}
+  strip = {"token", "_route", "pubkey", "sig", "user_agent", "pq_kex", "encrypted", "accept_encoding"}
   clean_msg = {k: v for k, v in msg.items() if k not in strip}
   clean_msg = adapt_request(clean_msg, client_ver)
   clean_payload = json.dumps(clean_msg).encode()
@@ -203,16 +208,19 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
         pipe.send_bytes(clean_payload)
         resp_payload = pipe.recv_bytes()
       resp_payload = adapt_response(resp_payload, command, client_ver)
-      _send_payload(resp_payload)
     else:
       with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as local:
         local.connect(sock_path)
         local.sendall(clean_header + clean_payload)
         resp_payload = _recv_all(local)
       resp_payload = adapt_response(resp_payload, command, client_ver)
-      _send_payload(resp_payload)
 
+    # parse once: drives both the access log and (re-)encoding for the client
     resp_data = json.loads(resp_payload)
+    if compress:
+      _send_payload(transport.encode_response(resp_data, accept_encoding, command))
+    else:
+      _send_payload(resp_payload)
     if resp_data.get("success", True):
       _log(addr, command, resolved_profile, "OK")
     else:
@@ -221,7 +229,7 @@ def _proxy_request(client_sock:socket.socket, addr:tuple, profile:str|None, auth
     _send_error(msg_id, str(e))
     _log(addr, command, resolved_profile, "ERROR", str(e))
 
-def _handle_client(client_sock:socket.socket, addr:tuple, profile:str|None, auth_keys_path:"Path|None") -> None:
+def _handle_client(client_sock:socket.socket, addr:tuple, profile:str|None, auth_keys_path:"Path|None", compress:bool=True) -> None:
   if not _CONN_LIMIT.acquire(blocking=False):
     client_sock.close()
     return
@@ -253,7 +261,7 @@ def _handle_client(client_sock:socket.socket, addr:tuple, profile:str|None, auth
         _framed_send(client_sock, challenge)
       except OSError:
         return
-      _proxy_request(client_sock, addr, profile, auth_keys, auth_keys_path, nonce, pq_private_key)
+      _proxy_request(client_sock, addr, profile, auth_keys, auth_keys_path, nonce, pq_private_key, compress)
   finally:
     _CONN_LIMIT.release()
 
@@ -264,10 +272,13 @@ def _handle_client(client_sock:socket.socket, addr:tuple, profile:str|None, auth
 @click.option("--no-auth", is_flag=True, default=False, help="Disable authentication (dangerous).")
 @click.option("--authorized-keys", "auth_keys_file", default=None, metavar="FILE",
               help="File of trusted Ed25519 public keys (one hex per line). Required unless --no-auth.")
+@click.option("--no-compress", "no_compress", is_flag=True, default=False,
+              help="Disable response compression / msgpack even for clients that support it.")
 @click.pass_context
-def cmd_serve(ctx, host, port, no_auth, auth_keys_file):
+def cmd_serve(ctx, host, port, no_auth, auth_keys_file, no_compress):
   """Expose this browser over TCP so remote hosts can control it."""
   profile = ctx.obj.get("browser") if ctx.obj else None
+  compress = not no_compress
 
   if host in ("0.0.0.0", "::"):
     console.print("[yellow]Warning:[/yellow] Binding to all interfaces — anyone who can reach this port controls your browser.")
@@ -302,18 +313,25 @@ def cmd_serve(ctx, host, port, no_auth, auth_keys_file):
     n = len(load_authorized_keys(auth_keys_path))
     console.print(f"  Auth:   [bold green]Ed25519 pubkey[/bold green] ({n} trusted key{'s' if n != 1 else ''})")
     console.print(f"  CLI:    [dim]browser-cli --remote {host}:{port} tabs list[/dim]")
-    console.print(f"  Python: [dim]BrowserCLI(remote=\"{host}:{port}\").tabs_list()[/dim]")
+    console.print(f"  Python: [dim]BrowserCLI(remote=\"{host}:{port}\").tabs.list()[/dim]")
   else:
     console.print(f"  CLI:    [dim]browser-cli --remote {host}:{port} tabs list[/dim]")
-    console.print(f"  Python: [dim]BrowserCLI(remote=\"{host}:{port}\").tabs_list()[/dim]")
+    console.print(f"  Python: [dim]BrowserCLI(remote=\"{host}:{port}\").tabs.list()[/dim]")
     console.print("[yellow]  Auth disabled (--no-auth)[/yellow]")
 
+  if compress:
+    codecs = "+".join(transport.supported_compression())
+    sers = "+".join(transport.supported_serialization())
+    console.print(f"  Encode: [green]on[/green] [dim](compression: {codecs}; serialization: {sers}; per-client negotiated)[/dim]")
+  else:
+    console.print("  Encode: [yellow]off (--no-compress)[/yellow]")
+
   console.print("Ctrl-C to stop.\n")
 
   try:
     while True:
       conn, addr = server.accept()
-      threading.Thread(target=_handle_client, args=(conn, addr, profile, auth_keys_path), daemon=True).start()
+      threading.Thread(target=_handle_client, args=(conn, addr, profile, auth_keys_path, compress), daemon=True).start()
   except KeyboardInterrupt:
     console.print("[yellow]Stopped.[/yellow]")
   finally:
diff --git a/browser_cli/commands/session.py b/browser_cli/commands/session.py
index 26aaa3e..44e5b89 100644
--- a/browser_cli/commands/session.py
+++ b/browser_cli/commands/session.py
@@ -1,5 +1,5 @@
 import click
-from browser_cli.commands import _handle, _handle_multi, _multi_browser_targets
+from browser_cli.commands import client_from_ctx, gentle_mode_option, handle_errors
 from rich.console import Console
 
 console = Console()
@@ -10,41 +10,47 @@ def session_group():
 
 @session_group.command("save")
 @click.argument("name")
+@handle_errors
 def session_save(name):
     """Save all current tabs as session NAME."""
-    result = _handle("session.save", {"name": name})
+    result = client_from_ctx().session.save(name)
     count = result.get("tabs", 0) if isinstance(result, dict) else 0
     console.print(f"[green]Session '{name}' saved[/green] ({count} tabs)")
 
 @session_group.command("load")
 @click.argument("name")
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large restores.")
+@gentle_mode_option("Throttle mode for large restores.")
 @click.option("--discard-background-tabs", is_flag=True, help="Discard restored background tabs after opening to reduce load.")
 @click.option("--lazy", is_flag=True, help="Create lightweight placeholder tabs after --eager-tabs; placeholders load when selected.")
 @click.option("--eager-tabs", type=int, default=10, show_default=True, help="Number of real tabs to open before lazy placeholders.")
 @click.option("--background", "background_job", is_flag=True, help="Start restore as a background job and return immediately.")
+@handle_errors
 def session_load(name, gentle_mode, discard_background_tabs, lazy, eager_tabs, background_job):
     """Restore session NAME (opens all saved tabs)."""
-    result = _handle("session.load", {
-        "name": name,
-        "gentleMode": gentle_mode,
-        "discardBackgroundTabs": discard_background_tabs,
-        "lazy": lazy,
-        "eagerTabs": eager_tabs,
-        "__background": background_job,
-    })
-    if background_job and isinstance(result, dict) and result.get("jobId"):
-        console.print(f"[green]Session restore started[/green] job={result['jobId']}")
-        return
+    b = client_from_ctx()
+    if background_job:
+        result = b.session.load_background(
+            name, gentle_mode=gentle_mode, discard_background_tabs=discard_background_tabs,
+            lazy=lazy, eager_tabs=eager_tabs,
+        )
+        if isinstance(result, dict) and result.get("jobId"):
+            console.print(f"[green]Session restore started[/green] job={result['jobId']}")
+            return
+    else:
+        result = b.session.load(
+            name, gentle_mode=gentle_mode, discard_background_tabs=discard_background_tabs,
+            lazy=lazy, eager_tabs=eager_tabs,
+        )
     count = result.get("tabs", 0) if isinstance(result, dict) else 0
     console.print(f"[green]Session '{name}' loaded[/green] ({count} tabs opened)")
 
 @session_group.command("diff")
 @click.argument("name_a")
 @click.argument("name_b")
+@handle_errors
 def session_diff(name_a, name_b):
     """Show tabs added/removed between two saved sessions."""
-    diff = _handle("session.diff", {"nameA": name_a, "nameB": name_b})
+    diff = client_from_ctx().session.diff(name_a, name_b)
     if not diff:
         console.print("[yellow]No diff data returned[/yellow]")
         return
@@ -66,26 +72,16 @@ def session_diff(name_a, name_b):
         console.print("[green]Sessions are identical[/green]")
 
 @session_group.command("list")
+@handle_errors
 def session_list():
     """List all saved sessions."""
+    from datetime import datetime
     from rich.table import Table
-    targets = _multi_browser_targets()
-    show_browser = bool(targets)
-    if targets:
-        sessions = []
-        for target in targets:
-            result = _handle_multi("session.list", profile=target.profile, remote=target.remote)
-            if result is None:
-                continue
-            sessions.extend({**session, "browser": target.display_name} for session in result)
-        if not sessions:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-    else:
-        sessions = _handle("session.list")
+    sessions = client_from_ctx().session.list()
     if not sessions:
         console.print("[yellow]No saved sessions[/yellow]")
         return
+    show_browser = any("browser" in s for s in sessions)
     table = Table(show_header=True, header_style="bold cyan")
     if show_browser:
         table.add_column("Browser")
@@ -93,7 +89,6 @@ def session_list():
     table.add_column("Tabs", width=6)
     table.add_column("Saved at")
     for s in sessions:
-        from datetime import datetime
         saved = datetime.fromtimestamp(s["savedAt"] / 1000).strftime("%Y-%m-%d %H:%M") if s.get("savedAt") else ""
         row = [s.get("browser", "")] if show_browser else []
         row.extend([s["name"], str(s["tabs"]), saved])
@@ -102,16 +97,18 @@ def session_list():
 
 @session_group.command("remove")
 @click.argument("name")
+@handle_errors
 def session_remove(name):
     """Delete a saved session."""
-    _handle("session.remove", {"name": name})
+    client_from_ctx().session.remove(name)
     console.print(f"[green]Session '{name}' removed[/green]")
 
 @session_group.command("job-status")
 @click.argument("job_id")
+@handle_errors
 def session_job_status(job_id):
     """Show status for a background session job."""
-    result = _handle("jobs.status", {"jobId": job_id}) or {}
+    result = client_from_ctx().perf.job_status(job_id)
     status = result.get("status", "unknown")
     console.print(f"[bold]{job_id}[/bold]: {status}")
     if result.get("error"):
@@ -121,15 +118,17 @@ def session_job_status(job_id):
 
 @session_group.command("job-cancel")
 @click.argument("job_id")
+@handle_errors
 def session_job_cancel(job_id):
     """Cancel a running background job."""
-    _handle("jobs.cancel", {"jobId": job_id})
+    client_from_ctx().perf.job_cancel(job_id)
     console.print(f"[green]Cancel requested for {job_id}[/green]")
 
 @session_group.command("auto-save")
 @click.argument("state", type=click.Choice(["on", "off"]))
+@handle_errors
 def session_auto_save(state):
     """Enable or disable automatic session saving."""
     enabled = state == "on"
-    _handle("session.auto_save", {"enabled": enabled})
+    client_from_ctx().session.auto_save(enabled)
     console.print(f"[green]Auto-save {state}[/green]")
diff --git a/browser_cli/commands/storage.py b/browser_cli/commands/storage.py
index 7404684..8d1a9a5 100644
--- a/browser_cli/commands/storage.py
+++ b/browser_cli/commands/storage.py
@@ -1,23 +1,22 @@
 import json
 import click
-from browser_cli.commands import _handle
+from browser_cli.commands import client_from_ctx, handle_errors, tab_option
 from rich.console import Console
 
 console = Console()
 
-
 @click.group("storage")
 def storage_group():
     """Read and write the page's localStorage / sessionStorage."""
 
-
 @storage_group.command("get")
 @click.argument("key", required=False)
 @click.option("--type", "store_type", type=click.Choice(["local", "session"]), default="local", show_default=True)
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
+@handle_errors
 def storage_get(key, store_type, tab_id):
     """Get a localStorage KEY (or dump all keys if omitted)."""
-    result = _handle("storage.get", {"key": key, "type": store_type, "tabId": tab_id})
+    result = client_from_ctx().storage.get(key, type=store_type, tab_id=tab_id)
     if result is None:
         console.print("[dim]null[/dim]")
     elif isinstance(result, dict):
@@ -25,13 +24,13 @@ def storage_get(key, store_type, tab_id):
     else:
         console.print(str(result))
 
-
 @storage_group.command("set")
 @click.argument("key")
 @click.argument("value")
 @click.option("--type", "store_type", type=click.Choice(["local", "session"]), default="local", show_default=True)
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
+@handle_errors
 def storage_set(key, value, store_type, tab_id):
     """Set localStorage KEY to VALUE."""
-    _handle("storage.set", {"key": key, "value": value, "type": store_type, "tabId": tab_id})
+    client_from_ctx().storage.set(key, value, type=store_type, tab_id=tab_id)
     console.print(f"[green]Set[/green] {store_type}[{key!r}] = {value!r}")
diff --git a/browser_cli/commands/tabs.py b/browser_cli/commands/tabs.py
index 4e76839..00277e2 100644
--- a/browser_cli/commands/tabs.py
+++ b/browser_cli/commands/tabs.py
@@ -1,14 +1,13 @@
 import base64
 import binascii
 import click
-from browser_cli.commands import _handle, _handle_multi, _multi_browser_targets
+from browser_cli.commands import client_from_ctx, gentle_mode_option, handle_errors, print_counts, tab_option
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
-def _print_tabs(tabs: list[dict], *, show_browser: bool = False) -> None:
+def _print_tabs(tabs, *, show_browser: bool = False) -> None:
     if not tabs:
         console.print("[yellow]No tabs found[/yellow]")
         return
@@ -22,58 +21,42 @@ def _print_tabs(tabs: list[dict], *, show_browser: bool = False) -> None:
     table.add_column("Title")
     table.add_column("URL")
     for t in tabs:
-        active = "[green]✓[/green]" if t.get("active") else ""
-        muted = "[yellow]✓[/yellow]" if t.get("muted") else ""
+        active = "[green]✓[/green]" if t.active else ""
+        muted = "[yellow]✓[/yellow]" if t.muted else ""
         row = [
-            t.get("browser", "") if show_browser else None,
-            str(t.get("id", "")),
-            str(t.get("windowId", "")),
+            (t.browser or "") if show_browser else None,
+            str(t.id),
+            str(t.window_id),
             active,
             muted,
-            (t.get("title") or "")[:60],
-            (t.get("url") or "")[:80],
+            (t.title or "")[:60],
+            (t.url or "")[:80],
         ]
         table.add_row(*[value for value in row if value is not None])
     console.print(table)
 
-
 @click.group("tabs")
 def tabs_group():
     """Manage browser tabs."""
 
-
 @tabs_group.command("list")
+@handle_errors
 def tabs_list():
     """List all open tabs across all windows."""
-    targets = _multi_browser_targets()
-    if targets:
-        tabs = []
-        for target in targets:
-            result = _handle_multi("tabs.list", profile=target.profile, remote=target.remote)
-            if result is None:
-                continue
-            tabs.extend({**tab, "browser": target.display_name} for tab in result)
-        if not tabs:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        _print_tabs(tabs, show_browser=True)
-        return
-    tabs = _handle("tabs.list")
-    _print_tabs(tabs or [])
-
+    tabs = client_from_ctx().tabs.list()
+    _print_tabs(tabs, show_browser=any(t.browser for t in tabs))
 
 @tabs_group.command("close")
 @click.argument("tab_id", type=int, required=False)
 @click.option("--inactive", is_flag=True, help="Close all inactive tabs")
 @click.option("--duplicates", is_flag=True, help="Close duplicate tabs (keep first)")
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large close operations.")
+@gentle_mode_option("Throttle mode for large close operations.")
+@handle_errors
 def tabs_close(tab_id, inactive, duplicates, gentle_mode):
     """Close a tab, all inactive tabs, or all duplicate tabs."""
-    result = _handle("tabs.close", {"tabId": tab_id, "inactive": inactive, "duplicates": duplicates, "gentleMode": gentle_mode})
-    count = result.get("closed", 0) if isinstance(result, dict) else 1
+    count = client_from_ctx().tabs.close(tab_id, inactive=inactive, duplicates=duplicates, gentle_mode=gentle_mode)
     console.print(f"[green]Closed {count} tab(s)[/green]")
 
-
 @tabs_group.command("move")
 @click.argument("tab_id", type=int)
 @click.option("-f", "--forward", "forward", is_flag=True, help="Move one position to the right")
@@ -83,180 +66,148 @@ def tabs_close(tab_id, inactive, duplicates, gentle_mode):
 @click.option("--group", "group_id", type=int, default=None, help="Move to tab group ID")
 @click.option("--window", "window_id", type=int, default=None, help="Move to window ID")
 @click.option("--index", type=int, default=None, help="Absolute position index in target")
+@handle_errors
 def tabs_move(tab_id, forward, backward, group_id, window_id, index):
     """Move a tab. Use --forward/--backward or --right/--left for relative movement."""
-    _handle("tabs.move", {
-        "tabId": tab_id, "forward": forward, "backward": backward,
-        "groupId": group_id, "windowId": window_id, "index": index,
-    })
+    client_from_ctx().tabs.move(
+        tab_id, forward=forward, backward=backward,
+        group_id=group_id, window_id=window_id, index=index,
+    )
     console.print("[green]Tab moved[/green]")
 
-
 @tabs_group.command("active")
 @click.argument("tab_id", type=int)
+@handle_errors
 def tabs_active(tab_id):
     """Switch browser focus to a tab."""
-    _handle("tabs.active", {"tabId": tab_id})
+    client_from_ctx().tabs.activate(tab_id)
     console.print(f"[green]Switched to tab {tab_id}[/green]")
 
-
 @tabs_group.command("status")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_status(tab_id):
     """Show status for the active tab or a specific tab."""
-    tab = _handle("tabs.status", {"tabId": tab_id}) or {}
+    tab = client_from_ctx().tabs.status(tab_id)
     table = Table(show_header=False)
     table.add_column("Field", style="bold cyan")
     table.add_column("Value")
-    table.add_row("ID", str(tab.get("id", "")))
-    table.add_row("Window", str(tab.get("windowId", "")))
-    table.add_row("Active", "yes" if tab.get("active") else "no")
-    table.add_row("Muted", "yes" if tab.get("muted") else "no")
-    table.add_row("Title", tab.get("title") or "")
-    table.add_row("URL", tab.get("url") or "")
+    table.add_row("ID", str(tab.id))
+    table.add_row("Window", str(tab.window_id))
+    table.add_row("Active", "yes" if tab.active else "no")
+    table.add_row("Muted", "yes" if tab.muted else "no")
+    table.add_row("Title", tab.title or "")
+    table.add_row("URL", tab.url or "")
     console.print(table)
 
-
 @tabs_group.command("filter")
 @click.argument("pattern")
+@handle_errors
 def tabs_filter(pattern):
     """List tabs whose URL contains PATTERN."""
-    tabs = _handle("tabs.filter", {"pattern": pattern})
-    _print_tabs(tabs or [])
-
+    _print_tabs(client_from_ctx().tabs.filter(pattern))
 
 @tabs_group.command("count")
 @click.argument("pattern", required=False)
+@handle_errors
 def tabs_count(pattern):
     """Count open tabs, optionally filtered by URL PATTERN."""
-    targets = _multi_browser_targets()
-    if targets:
-        table = Table(show_header=True, header_style="bold cyan")
-        table.add_column("Browser")
-        table.add_column("Tabs", justify="right")
-        total = 0
-        rows = 0
-        for target in targets:
-            count = _handle_multi("tabs.count", {"pattern": pattern}, profile=target.profile, remote=target.remote)
-            if count is None:
-                continue
-            count = int(count or 0)
-            total += count
-            rows += 1
-            table.add_row(target.display_name, str(count))
-        if rows == 0:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        table.add_row("Total", str(total))
-        console.print(table)
-        return
-    count = _handle("tabs.count", {"pattern": pattern})
     label = f" matching '{pattern}'" if pattern else ""
-    console.print(f"[bold]{count}[/bold] tab(s){label}")
-
+    print_counts(client_from_ctx().tabs.count(pattern), "tab", single_suffix=label)
 
 @tabs_group.command("query")
 @click.argument("search")
+@handle_errors
 def tabs_query(search):
     """Search tabs by URL or title."""
-    tabs = _handle("tabs.query", {"search": search})
-    _print_tabs(tabs or [])
-
+    _print_tabs(client_from_ctx().tabs.query(search))
 
 @tabs_group.command("html")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_html(tab_id):
     """Print the full HTML of a tab."""
-    html = _handle("tabs.html", {"tabId": tab_id})
-    console.print(html or "")
-
+    console.print(client_from_ctx().tabs.html(tab_id))
 
 @tabs_group.command("dedupe")
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large dedupe operations.")
+@gentle_mode_option("Throttle mode for large dedupe operations.")
+@handle_errors
 def tabs_dedupe(gentle_mode):
     """Close duplicate tabs (keep the first occurrence of each URL)."""
-    result = _handle("tabs.dedupe", {"gentleMode": gentle_mode})
-    count = result.get("closed", 0) if isinstance(result, dict) else 0
+    count = client_from_ctx().tabs.dedupe(gentle_mode=gentle_mode)
     console.print(f"[green]Closed {count} duplicate tab(s)[/green]")
 
-
 @tabs_group.command("sort")
 @click.option("--by", type=click.Choice(["domain", "title", "time"]), default="domain", show_default=True)
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large sort operations.")
+@gentle_mode_option("Throttle mode for large sort operations.")
+@handle_errors
 def tabs_sort(by, gentle_mode):
     """Sort tabs within each window."""
-    _handle("tabs.sort", {"by": by, "gentleMode": gentle_mode})
+    client_from_ctx().tabs.sort(by=by, gentle_mode=gentle_mode)
     console.print(f"[green]Tabs sorted by {by}[/green]")
 
-
 @tabs_group.command("merge-windows")
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large merge operations.")
+@gentle_mode_option("Throttle mode for large merge operations.")
+@handle_errors
 def tabs_merge_windows(gentle_mode):
     """Move all tabs into the focused window."""
-    result = _handle("tabs.merge_windows", {"gentleMode": gentle_mode})
-    count = result.get("moved", 0) if isinstance(result, dict) else 0
+    count = client_from_ctx().tabs.merge_windows(gentle_mode=gentle_mode)
     console.print(f"[green]Merged — moved {count} tab(s) into current window[/green]")
 
-
 @tabs_group.command("mute")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_mute(tab_id):
     """Mute the active tab or a specific tab."""
-    result = _handle("tabs.mute", {"tabId": tab_id})
-    target = result.get("tabId", tab_id) if isinstance(result, dict) else tab_id
+    target = client_from_ctx().tabs.mute(tab_id)
     console.print(f"[green]Muted tab {target}[/green]")
 
-
 @tabs_group.command("unmute")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_unmute(tab_id):
     """Unmute the active tab or a specific tab."""
-    result = _handle("tabs.unmute", {"tabId": tab_id})
-    target = result.get("tabId", tab_id) if isinstance(result, dict) else tab_id
+    target = client_from_ctx().tabs.unmute(tab_id)
     console.print(f"[green]Unmuted tab {target}[/green]")
 
-
 @tabs_group.command("pin")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_pin(tab_id):
     """Pin the active tab or a specific tab."""
-    result = _handle("tabs.pin", {"tabId": tab_id})
-    target = result.get("tabId", tab_id) if isinstance(result, dict) else tab_id
+    target = client_from_ctx().tabs.pin(tab_id)
     console.print(f"[green]Pinned tab {target}[/green]")
 
-
 @tabs_group.command("unpin")
 @click.argument("tab_id", type=int, required=False)
+@handle_errors
 def tabs_unpin(tab_id):
     """Unpin the active tab or a specific tab."""
-    result = _handle("tabs.unpin", {"tabId": tab_id})
-    target = result.get("tabId", tab_id) if isinstance(result, dict) else tab_id
+    target = client_from_ctx().tabs.unpin(tab_id)
     console.print(f"[green]Unpinned tab {target}[/green]")
 
-
 @tabs_group.command("watch-url")
 @click.argument("pattern")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
 @click.option("--timeout", type=float, default=30.0, show_default=True, help="Max seconds to wait")
+@handle_errors
 def tabs_watch_url(pattern, tab_id, timeout):
     """Wait until the active (or specified) tab URL matches regex PATTERN."""
-    result = _handle("tabs.watch_url", {"pattern": pattern, "tabId": tab_id, "timeout": int(timeout * 1000)})
-    url = result.get("url", "") if isinstance(result, dict) else ""
-    console.print(f"[green]URL matched:[/green] {url}")
-
+    tab = client_from_ctx().tabs.watch_url(pattern, tab_id=tab_id, timeout=timeout)
+    console.print(f"[green]URL matched:[/green] {tab.url}")
 
 @tabs_group.command("screenshot")
 @click.argument("output", required=False, metavar="FILE")
-@click.option("--tab", "tab_id", type=int, default=None, help="Tab ID (default: active tab)")
+@tab_option
 @click.option("--format", "fmt", type=click.Choice(["png", "jpeg"]), default="png", show_default=True)
 @click.option("--quality", type=int, default=None, help="JPEG quality 0-100")
+@handle_errors
 def tabs_screenshot(output, tab_id, fmt, quality):
     """Capture a screenshot of the active (or specified) tab.
 
     Saves to FILE if given, otherwise prints the base64 data URL.
     """
-    result = _handle("tabs.screenshot", {"tabId": tab_id, "format": fmt, "quality": quality})
-    data_url = result.get("dataUrl", "") if isinstance(result, dict) else ""
+    data_url = client_from_ctx().tabs.screenshot(tab_id, format=fmt, quality=quality)
     if output:
         header = f"data:image/{fmt};base64,"
         if not data_url.startswith(header):
diff --git a/browser_cli/commands/windows.py b/browser_cli/commands/windows.py
index 3d814e3..1ad33c4 100644
--- a/browser_cli/commands/windows.py
+++ b/browser_cli/commands/windows.py
@@ -1,11 +1,10 @@
 import click
-from browser_cli.commands import _handle, _handle_multi, _multi_browser_targets
+from browser_cli.commands import client_from_ctx, handle_errors
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
 def _print_windows(windows: list[dict], *, show_browser: bool = False) -> None:
     if not windows:
         console.print("[yellow]No windows found[/yellow]")
@@ -28,53 +27,39 @@ def _print_windows(windows: list[dict], *, show_browser: bool = False) -> None:
         table.add_row(*[value for value in row if value is not None])
     console.print(table)
 
-
 @click.group("windows")
 def windows_group():
     """Manage browser windows."""
 
-
 @windows_group.command("list")
+@handle_errors
 def windows_list():
     """List all browser windows."""
-    targets = _multi_browser_targets()
-    if targets:
-        windows = []
-        for target in targets:
-            result = _handle_multi("windows.list", profile=target.profile, remote=target.remote)
-            if result is None:
-                continue
-            windows.extend({**window, "browser": target.display_name} for window in result)
-        if not windows:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        _print_windows(windows, show_browser=True)
-        return
-    windows = _handle("windows.list")
-    _print_windows(windows or [])
-
+    windows = client_from_ctx().windows.list()
+    _print_windows(windows, show_browser=any("browser" in w for w in windows))
 
 @windows_group.command("rename")
 @click.argument("window_id", type=int)
 @click.argument("name")
+@handle_errors
 def windows_rename(window_id, name):
     """Give a window a local alias NAME (stored in native host)."""
-    _handle("windows.rename", {"windowId": window_id, "name": name})
+    client_from_ctx().windows.rename(window_id, name)
     console.print(f"[green]Window {window_id} aliased as '{name}'[/green]")
 
-
 @windows_group.command("close")
 @click.argument("window_id", type=int)
+@handle_errors
 def windows_close(window_id):
     """Close a browser window."""
-    _handle("windows.close", {"windowId": window_id})
+    client_from_ctx().windows.close(window_id)
     console.print(f"[green]Window {window_id} closed[/green]")
 
-
 @windows_group.command("open")
 @click.argument("url", required=False)
+@handle_errors
 def windows_open(url):
     """Open a new browser window."""
-    result = _handle("windows.open", {"url": url})
+    result = client_from_ctx().windows.open(url)
     wid = result.get("id") if isinstance(result, dict) else result
     console.print(f"[green]Opened new window[/green] (id: {wid})" + (f" with {url}" if url else ""))
diff --git a/browser_cli/endpoints.py b/browser_cli/endpoints.py
new file mode 100644
index 0000000..649c6e2
--- /dev/null
+++ b/browser_cli/endpoints.py
@@ -0,0 +1,57 @@
+"""Remote endpoint string handling — parsing, normalization, display.
+
+Pure helpers (no sockets, no I/O) for turning user-facing ``host[:port]``
+strings into the canonical forms the rest of the client uses, and back into the
+short forms shown to humans. Re-exported from :mod:`browser_cli.client` for
+backward compatibility.
+"""
+from __future__ import annotations
+
+import re
+
+from browser_cli.errors import BrowserNotConnected
+
+_DEFAULT_REMOTE_PORT = 443
+
+def _looks_like_domain(host: str) -> bool:
+    """True if host looks like a domain name rather than an IP address or localhost."""
+    if host in {"localhost", "127.0.0.1", "::1"}:
+        return False
+    if re.match(r'^\d{1,3}(\.\d{1,3}){3}$', host):
+        return False
+    return '.' in host and any(c.isalpha() for c in host)
+
+def _normalize_endpoint(endpoint: str) -> str:
+    """Strip :443 from domain-like endpoints so they are stored without the default port."""
+    if not endpoint:
+        return endpoint
+    host, sep, port = endpoint.rpartition(":")
+    if sep and port == "443" and _looks_like_domain(host):
+        return host
+    return endpoint
+
+def _resolve_connect_endpoint(endpoint: str) -> str:
+    """Return host:port for TCP connection; domain without port defaults to :443."""
+    _, sep, _ = endpoint.rpartition(":")
+    if not sep:
+        if _looks_like_domain(endpoint):
+            return f"{endpoint}:{_DEFAULT_REMOTE_PORT}"
+        raise BrowserNotConnected(
+            f"Invalid remote endpoint '{endpoint}': expected host:port"
+        )
+    return endpoint
+
+def display_browser_name(profile_name: str, sock_path: str) -> str:
+    from pathlib import Path
+
+    if profile_name != "default":
+        return profile_name
+    return Path(sock_path).stem or profile_name
+
+def _remote_display_name(endpoint: str, profile_name: str, display_name: str) -> str:
+    host, sep, port = endpoint.rpartition(":")
+    if sep and (port == "8765" or (port == "443" and _looks_like_domain(host))):
+        display_endpoint = host
+    else:
+        display_endpoint = endpoint  # normalized domain (no port) or non-default port
+    return f"{display_endpoint}:{display_name or profile_name}"
diff --git a/browser_cli/errors.py b/browser_cli/errors.py
new file mode 100644
index 0000000..bc490ba
--- /dev/null
+++ b/browser_cli/errors.py
@@ -0,0 +1,10 @@
+"""Shared exception types for the browser-cli client stack.
+
+Kept dependency-free so the transport/endpoint modules and ``client`` itself can
+import it without creating an import cycle. ``BrowserNotConnected`` is re-exported
+from :mod:`browser_cli.client` for backward compatibility.
+"""
+from __future__ import annotations
+
+class BrowserNotConnected(Exception):
+    """Raised when the native host socket is not available."""
diff --git a/browser_cli/markdown.py b/browser_cli/markdown.py
new file mode 100644
index 0000000..01e99e3
--- /dev/null
+++ b/browser_cli/markdown.py
@@ -0,0 +1,413 @@
+"""HTML → Markdown conversion and Markdown clean-up.
+
+Pure, presentation-agnostic text transforms shared by the SDK
+(:meth:`browser_cli.sdk.dom.ExtractNS.markdown`) and the ``extract markdown``
+CLI command. No Click/Rich/IPC dependencies — just an HTML tree walker plus a
+set of repair passes for the markdown the page (or a markdown editor like
+Obsidian/CodeMirror) hands back.
+"""
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+
+_FENCE_RE = re.compile(r"```(?:[^\n`]*)\n.*?\n```", re.DOTALL)
+_ESCAPED_MARKDOWN_RE = re.compile(r"\\([_-])")
+_TABLE_SEPARATOR_RE = re.compile(r"^\|(?:\s*:?-{3,}:?\s*\|)+\s*$")
+
+class _HtmlNode:
+    def __init__(self, tag=None, attrs=None, text=None):
+        self.tag = tag
+        self.attrs = attrs or {}
+        self.text = text
+        self.children = []
+
+class _HtmlTreeBuilder(HTMLParser):
+    _VOID_TAGS = {"br", "hr", "img"}
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.root = _HtmlNode(tag="document")
+        self._stack = [self.root]
+
+    def handle_starttag(self, tag, attrs):
+        node = _HtmlNode(tag=tag.lower(), attrs=dict(attrs))
+        self._stack[-1].children.append(node)
+        if node.tag not in self._VOID_TAGS:
+            self._stack.append(node)
+
+    def handle_startendtag(self, tag, attrs):
+        node = _HtmlNode(tag=tag.lower(), attrs=dict(attrs))
+        self._stack[-1].children.append(node)
+
+    def handle_endtag(self, tag):
+        lowered = tag.lower()
+        for index in range(len(self._stack) - 1, 0, -1):
+            if self._stack[index].tag == lowered:
+                del self._stack[index:]
+                break
+
+    def handle_data(self, data):
+        if data:
+            self._stack[-1].children.append(_HtmlNode(text=data))
+
+def _normalize_text(value):
+    return re.sub(r"\s+", " ", value or "").strip()
+
+def _normalize_inline(value):
+    value = value.replace("\xa0", " ")
+    value = re.sub(r"[ \t\r\f\v]+", " ", value)
+    value = re.sub(r" *\n *", "\n", value)
+    return value.strip()
+
+def _collapse_blank_lines(value):
+    value = re.sub(r"[ \t]+\n", "\n", value)
+    value = re.sub(r"\n{3,}", "\n\n", value)
+    return value.strip()
+
+def _escape_markdown(text):
+    return re.sub(r"([\\`[\]])", r"\\\1", text)
+
+def _escape_table_cell(text):
+    return text.replace("|", r"\|").replace("\n", " ").strip()
+
+def _iter_descendants(node):
+    for child in getattr(node, "children", []):
+        yield child
+        yield from _iter_descendants(child)
+
+def _has_class(node, class_name):
+    classes = (node.attrs.get("class") or "").split()
+    return class_name in classes
+
+def _is_code_block_node(node):
+    if not node or not node.tag:
+        return False
+    if node.attrs.get("data-is-code-block-view") == "true":
+        return True
+    return node.tag == "pre"
+
+def _inline_text(node):
+    if node.text is not None:
+        return _escape_markdown(node.text)
+    if not node.tag:
+        return ""
+
+    tag = node.tag
+    if tag == "br":
+        return "\n"
+    if tag == "img":
+        src = node.attrs.get("src") or ""
+        alt = _normalize_text(node.attrs.get("alt") or "")
+        if not src:
+            return ""
+        return f"![{_escape_markdown(alt)}]({src})" if alt else f"![]({src})"
+    if tag == "a":
+        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
+        href = node.attrs.get("href") or ""
+        return f"[{text or href}]({href})" if href else text
+    if tag == "code":
+        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
+        return f"`{text.replace('`', r'\\`')}`" if text else ""
+    if tag in {"strong", "b"}:
+        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
+        return f"**{text}**" if text else ""
+    if tag in {"em", "i"}:
+        text = _normalize_inline("".join(_inline_text(child) for child in node.children))
+        return f"*{text}*" if text else ""
+
+    chunks = []
+    for child in node.children:
+        rendered = _inline_text(child)
+        if rendered:
+            chunks.append(rendered)
+            if child.tag in {"p", "div", "table", "ul", "ol", "pre"}:
+                chunks.append("\n")
+    return "".join(chunks)
+
+def _text_block(node):
+    return _collapse_blank_lines(_normalize_inline("".join(_inline_text(child) for child in node.children)))
+
+def _inner_text_preserve(node):
+    if node.text is not None:
+        return node.text
+    if not node.tag:
+        return ""
+    if node.tag == "br":
+        return ""
+    return "".join(_inner_text_preserve(child) for child in node.children)
+
+def _table_to_markdown(node):
+    rows = []
+    for descendant in _iter_descendants(node):
+        if descendant.tag != "tr":
+            continue
+        row = []
+        for cell in descendant.children:
+            if cell.tag in {"td", "th"}:
+                row.append(_escape_table_cell(_text_block(cell)))
+        if row:
+            rows.append(row)
+    if not rows:
+        return ""
+
+    widths = max(len(row) for row in rows)
+    normalized_rows = [row + [""] * (widths - len(row)) for row in rows]
+
+    headers = normalized_rows[0]
+    body_rows = normalized_rows[1:]
+    first_row_blank = all(not cell.strip() for cell in headers)
+    if first_row_blank and len(normalized_rows) > 1:
+        headers = normalized_rows[1]
+        body_rows = normalized_rows[2:]
+
+    has_thead = any(child.tag == "thead" for child in node.children)
+    first_row = next((child for child in _iter_descendants(node) if child.tag == "tr"), None)
+    first_row_has_th = bool(first_row and any(child.tag == "th" for child in first_row.children))
+    if not (has_thead or first_row_has_th or first_row_blank):
+        headers = [""] * widths
+        body_rows = normalized_rows
+
+    separator = ["---"] * widths
+    lines = [
+        f"| {' | '.join(headers)} |",
+        f"| {' | '.join(separator)} |",
+    ]
+    lines.extend(f"| {' | '.join(row)} |" for row in body_rows)
+    return "\n".join(lines)
+
+def _list_to_markdown(node, depth=0):
+    ordered = node.tag == "ol"
+    items = []
+    index = 1
+    for child in node.children:
+        if child.tag != "li":
+            continue
+        marker = f"{index}. " if ordered else "- "
+        index += 1
+        content = []
+        nested = []
+        for item_child in child.children:
+            if item_child.tag in {"ul", "ol"}:
+                nested.append(_list_to_markdown(item_child, depth + 1))
+            else:
+                content.append(_inline_text(item_child))
+        line = _collapse_blank_lines(_normalize_inline("".join(content)))
+        indent = "  " * depth
+        if line:
+            line_parts = line.splitlines()
+            items.append(f"{indent}{marker}{line_parts[0]}")
+            continuation_indent = f"{indent}{' ' * len(marker)}"
+            items.extend(f"{continuation_indent}{part}" for part in line_parts[1:])
+        items.extend(block for block in nested if block)
+    return "\n".join(items)
+
+def _code_block_to_markdown(node):
+    if node.tag == "pre":
+        text = _inner_text_preserve(node).rstrip("\n")
+        return f"```\n{text}\n```" if text else ""
+
+    lines = []
+    for descendant in _iter_descendants(node):
+        if descendant.tag and _has_class(descendant, "cm-line"):
+            lines.append(_inner_text_preserve(descendant))
+    code = "\n".join(lines).rstrip("\n")
+    return f"```\n{code}\n```" if code else ""
+
+def _block_to_markdown(node):
+    if node.text is not None:
+        return _normalize_text(node.text)
+    if not node.tag:
+        return ""
+    if _is_code_block_node(node):
+        return _code_block_to_markdown(node)
+    if node.tag == "table":
+        return _table_to_markdown(node)
+    if node.tag in {"ul", "ol"}:
+        return _list_to_markdown(node)
+    if re.fullmatch(r"h[1-6]", node.tag):
+        text = _text_block(node)
+        return f"{'#' * int(node.tag[1])} {text}" if text else ""
+    if node.tag in {"p", "figcaption"}:
+        return _text_block(node)
+    if node.tag == "blockquote":
+        content = _collapse_blank_lines("\n\n".join(filter(None, (_block_to_markdown(child) for child in node.children))))
+        return "\n".join(f"> {line}" if line else ">" for line in content.splitlines()) if content else ""
+    if node.tag == "hr":
+        return "---"
+    if node.tag == "img":
+        return _inline_text(node)
+
+    child_blocks = [block for block in (_block_to_markdown(child) for child in node.children) if block]
+    if child_blocks:
+        return _collapse_blank_lines("\n\n".join(child_blocks))
+    return _text_block(node)
+
+def _parse_table_row(line):
+    stripped = line.strip()
+    if not stripped.startswith("|") or not stripped.endswith("|"):
+        return None
+    return [cell.strip() for cell in stripped.strip("|").split("|")]
+
+def _repair_table_headers(lines):
+    repaired = []
+    index = 0
+    while index < len(lines):
+        if (
+            index + 2 < len(lines)
+            and _parse_table_row(lines[index]) is not None
+            and _TABLE_SEPARATOR_RE.match(lines[index + 1].strip())
+            and _parse_table_row(lines[index + 2]) is not None
+        ):
+            first = _parse_table_row(lines[index])
+            third = _parse_table_row(lines[index + 2])
+            if first and all(not cell for cell in first) and any(cell for cell in third):
+                repaired.append(lines[index + 2].strip())
+                repaired.append(lines[index + 1].strip())
+                index += 3
+                continue
+        repaired.append(lines[index].strip())
+        index += 1
+    return repaired
+
+def _repair_list_continuations(lines):
+    repaired = []
+    previous_was_list_item = False
+    previous_continuation_indent = ""
+
+    for line in lines:
+        stripped = line.strip()
+        list_match = re.match(r"^(\s*)([-*+]|\d+\.)\s+.+$", stripped)
+        is_markdown_block_start = (
+            not stripped
+            or stripped.startswith(("```", "#", ">", "|"))
+            or _TABLE_SEPARATOR_RE.match(stripped)
+            or re.match(r"^(\s*)([-*+]|\d+\.)\s+", stripped)
+        )
+
+        if previous_was_list_item and stripped and not is_markdown_block_start:
+            repaired.append(f"{previous_continuation_indent}{stripped}")
+            previous_was_list_item = False
+            continue
+
+        repaired.append(stripped)
+        if list_match:
+            marker = list_match.group(2)
+            base_indent = list_match.group(1)
+            previous_continuation_indent = f"{base_indent}{' ' * (len(marker) + 1)}"
+            previous_was_list_item = True
+        else:
+            previous_was_list_item = False
+
+    return repaired
+
+def _repair_flattened_diagram(text):
+    if "\n" in text:
+        return text
+    if sum(text.count(char) for char in "│▼├└") < 2:
+        return text
+
+    text = re.sub(r"\s{2,}([│▼])", r"\n   \1", text)
+    text = re.sub(r"([│▼])\s{2,}", r"\1\n", text)
+    text = re.sub(r"([│▼])(?=[^\s\n│▼├└])", r"\1\n", text)
+    text = re.sub(r"(?<=[^\s\n])([├└])", r"\n\1", text)
+    text = re.sub(r"([^\s\n])(\()", r"\1\n\2", text)
+    return "\n".join(line.rstrip() for line in text.splitlines() if line.strip())
+
+def _convert_dash_lists_to_branches(lines):
+    converted = []
+    index = 0
+    while index < len(lines):
+        match = re.match(r"^(\s*)-\s+(.*)$", lines[index])
+        if not match:
+            converted.append(lines[index])
+            index += 1
+            continue
+
+        indent = match.group(1)
+        items = []
+        while index < len(lines):
+            next_match = re.match(rf"^{re.escape(indent)}-\s+(.*)$", lines[index])
+            if not next_match:
+                break
+            items.append(next_match.group(1))
+            index += 1
+
+        for item_index, item in enumerate(items):
+            branch = "└" if item_index == len(items) - 1 else "├"
+            converted.append(f"{indent}{branch} {item}")
+    return converted
+
+def _clean_code_block(code):
+    lines = [line.rstrip() for line in code.splitlines()]
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    while lines and not lines[-1].strip():
+        lines.pop()
+
+    flattened = _repair_flattened_diagram("\n".join(lines))
+    lines = flattened.splitlines() if flattened else []
+    lines = [
+        f"   {line.strip()}"
+        if line.strip() in {"│", "▼"} and not re.match(r"^\s+[│▼]\s*$", line)
+        else line
+        for line in lines
+    ]
+    lines = _convert_dash_lists_to_branches(lines)
+    return "\n".join(lines)
+
+def _clean_markdown_output(markdown):
+    if not markdown:
+        return ""
+
+    pieces = []
+    last_index = 0
+    for match in _FENCE_RE.finditer(markdown):
+        prose = markdown[last_index:match.start()]
+        if prose:
+            cleaned = _ESCAPED_MARKDOWN_RE.sub(r"\1", prose)
+            lines = [line.strip() for line in cleaned.splitlines()]
+            lines = _repair_table_headers(lines)
+            lines = _repair_list_continuations(lines)
+            cleaned = "\n".join(lines)
+            cleaned = _collapse_blank_lines(cleaned)
+            if cleaned:
+                pieces.append(cleaned)
+
+        fence = match.group(0)
+        header, _, tail = fence.partition("\n")
+        body, _, _ = tail.rpartition("\n")
+        cleaned_body = _clean_code_block(body)
+        pieces.append(f"{header}\n{cleaned_body}\n```" if cleaned_body else f"{header}\n```")
+        last_index = match.end()
+
+    trailing = markdown[last_index:]
+    if trailing:
+        cleaned = _ESCAPED_MARKDOWN_RE.sub(r"\1", trailing)
+        lines = [line.strip() for line in cleaned.splitlines()]
+        lines = _repair_table_headers(lines)
+        lines = _repair_list_continuations(lines)
+        cleaned = "\n".join(lines)
+        cleaned = _collapse_blank_lines(cleaned)
+        if cleaned:
+            pieces.append(cleaned)
+
+    return "\n\n".join(piece for piece in pieces if piece)
+
+def _convert_html_to_markdown(html):
+    parser = _HtmlTreeBuilder()
+    parser.feed(html or "")
+    markdown = _block_to_markdown(parser.root)
+    return _clean_markdown_output(markdown)
+
+def render_markdown(raw: str | None) -> str:
+    """Normalize *raw* extractor output into clean Markdown.
+
+    If the payload looks like HTML (first non-space char is ``<``) it is run
+    through the HTML→Markdown converter; otherwise it is treated as Markdown and
+    only the clean-up/repair passes are applied.
+    """
+    raw = raw or ""
+    if raw.lstrip().startswith("<"):
+        return _convert_html_to_markdown(raw)
+    return _clean_markdown_output(raw)
diff --git a/browser_cli/models.py b/browser_cli/models.py
index c6d465d..c30d732 100644
--- a/browser_cli/models.py
+++ b/browser_cli/models.py
@@ -4,11 +4,11 @@ Typed dataclasses returned by the BrowserCLI Python API.
 Each object is bound to a BrowserCLI instance so you can call actions
 directly on it:
 
-    tabs = b.tabs_list()
+    tabs = b.tabs.list()
     tabs[0].close()
     tabs[0].move(forward=True)
 
-    groups = b.group_list()
+    groups = b.groups.list()
     groups[0].tabs()
     groups[0].add_tab("https://example.com")
 """
@@ -21,6 +21,14 @@ if TYPE_CHECKING:
     from browser_cli import BrowserCLI
 
 
+# ── BrowserCounts ───────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class BrowserCounts:
+    """Aggregated per-browser counts returned in implicit multi-browser mode."""
+    total: int
+    by_browser: dict[str, int]
+
 # ── Tab ───────────────────────────────────────────────────────────────────────
 
 @dataclass
@@ -97,7 +105,7 @@ class Tab:
 
     def screenshot(self, *, format: str = "png", quality: int | None = None) -> str:
         """Capture this tab's visible area. Returns a base64 data URL."""
-        return self._b().tabs_screenshot(self.id, format=format, quality=quality)
+        return self._b().tabs.screenshot(self.id, format=format, quality=quality)
 
     def pin(self) -> None:
         """Pin this tab."""
@@ -109,19 +117,19 @@ class Tab:
 
     def refresh(self) -> Tab:
         """Return a fresh snapshot of this tab."""
-        return self._b().tabs_status(self.id)
+        return self._b().tabs.status(self.id)
 
     def wait_for_load(self, *, timeout: float = 30.0, ready_state: str = "complete") -> Tab:
         """Wait until this tab reaches the requested readyState."""
-        return self._b().wait_for_load(self.id, timeout=timeout, ready_state=ready_state)
+        return self._b().tabs.wait_for_load(self.id, timeout=timeout, ready_state=ready_state)
 
     def watch_url(self, pattern: str, *, timeout: float = 30.0) -> Tab:
         """Wait until this tab's URL matches regex *pattern*."""
-        return self._b().tabs_watch_url(pattern, tab_id=self.id, timeout=timeout)
+        return self._b().tabs.watch_url(pattern, tab_id=self.id, timeout=timeout)
 
     def open(self, url: str, *, background: bool = False) -> None:
         """Navigate this tab to *url* in place."""
-        self._b().navigate_tab(self.id, url)
+        self._b().nav.to(self.id, url)
 
 
 # ── Group ─────────────────────────────────────────────────────────────────────
@@ -148,7 +156,7 @@ class Group:
 
     def tabs(self) -> list[Tab]:
         """Return all tabs inside this group."""
-        return self._b().group_tabs(self.id)
+        return self._b().groups.tabs(self.id)
 
     def move(self, *, forward: bool = False, backward: bool = False) -> None:
         """Move this group forward or backward among groups."""
@@ -160,4 +168,4 @@ class Group:
 
     def add_tab(self, url: str | None = None) -> int | None:
         """Open a new tab inside this group. Returns the new tab ID."""
-        return self._b().group_add_tab(self.id, url)
+        return self._b().groups.add_tab(self.id, url)
diff --git a/browser_cli/remote_transport.py b/browser_cli/remote_transport.py
new file mode 100644
index 0000000..295783b
--- /dev/null
+++ b/browser_cli/remote_transport.py
@@ -0,0 +1,123 @@
+"""TCP/TLS transport for talking to a remote ``browser-cli serve``.
+
+Owns the wire mechanics of the remote leg: open a socket (TLS on :443),
+complete the signed challenge/response handshake with an optional post-quantum
+key exchange, frame the request, and read the framed (possibly encrypted)
+response. The higher-level "which endpoint / which profile / which key"
+decisions stay in :mod:`browser_cli.client`, which re-exports these for
+backward compatibility.
+"""
+from __future__ import annotations
+
+import json
+import socket
+import struct
+import sys
+
+from browser_cli.errors import BrowserNotConnected
+from browser_cli.endpoints import _resolve_connect_endpoint
+from browser_cli.version_manager import MAX_MSG_BYTES as _MAX_MSG_BYTES
+from browser_cli.version_manager import USER_AGENT as _USER_AGENT
+
+_PQ_WARNING = (
+    "** WARNING: connection is not using a post-quantum key exchange algorithm.\n"
+    "** This session may be vulnerable to store now, decrypt later attacks.\n"
+)
+
+def _recv_exact(sock: socket.socket, n: int) -> bytes:
+    buf = b""
+    while len(buf) < n:
+        chunk = sock.recv(n - len(buf))
+        if not chunk:
+            raise ConnectionError("Socket closed before full message received")
+        buf += chunk
+    return buf
+
+def _recv_all(sock: socket.socket) -> bytes:
+    raw_len = _recv_exact(sock, 4)
+    msg_len = struct.unpack("<I", raw_len)[0]
+    if msg_len > _MAX_MSG_BYTES:
+        raise ConnectionError(f"Response too large ({msg_len} bytes)")
+    return _recv_exact(sock, msg_len)
+
+def _send_remote(endpoint: str, msg: dict, private_key=None) -> bytes | None:
+    connect_ep = _resolve_connect_endpoint(endpoint)
+    host, _, port_str = connect_ep.rpartition(":")
+    port = int(port_str)
+    raw_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    raw_sock.settimeout(30)
+    try:
+        raw_sock.connect((host, port))
+        if port == 443:
+            import ssl
+            ctx = ssl.create_default_context()
+            sock = ctx.wrap_socket(raw_sock, server_hostname=host)
+        else:
+            sock = raw_sock
+    except Exception:
+        raw_sock.close()
+        raise
+    with sock:
+
+        # receive challenge
+        challenge_raw = _recv_all(sock)
+        if challenge_raw is None:
+            raise BrowserNotConnected(f"No challenge received from {endpoint}")
+        try:
+            challenge = json.loads(challenge_raw)
+            nonce_hex = challenge.get("nonce") if challenge.get("type") == "challenge" else None
+        except (json.JSONDecodeError, AttributeError):
+            nonce_hex = None
+
+        min_ver = challenge.get("min_client_version") if isinstance(challenge, dict) else None
+        if min_ver:
+            from browser_cli.version_manager import parse_version
+            try:
+                client_ver = _USER_AGENT.split("/", 1)[1]
+                if parse_version(client_ver) < parse_version(min_ver):
+                    raise BrowserNotConnected(
+                        f"Client version {client_ver} is too old for this server "
+                        f"(requires >= {min_ver}). Run: pip install --upgrade browser-cli"
+                    )
+            except (IndexError, ValueError):
+                pass
+
+        pq_shared_secret = None
+        if nonce_hex and private_key is not None:
+            from browser_cli.auth import PQ_KEX_ALG, pq_encrypt, pq_kex_client_encapsulate, sign, public_key_hex
+            nonce = bytes.fromhex(nonce_hex)
+            clean_msg = {k: v for k, v in msg.items() if k not in {"token", "pubkey", "sig", "pq_kex", "encrypted"}}
+            kex = challenge.get("pq_kex") if isinstance(challenge, dict) else None
+            if isinstance(kex, dict) and kex.get("alg") == PQ_KEX_ALG and kex.get("public_key"):
+                ciphertext_hex, pq_shared_secret = pq_kex_client_encapsulate(str(kex["public_key"]))
+                clean_msg["pq_kex"] = {"alg": PQ_KEX_ALG, "ciphertext": ciphertext_hex}
+            else:
+                sys.stderr.write(_PQ_WARNING)
+            sig = sign(private_key, nonce, clean_msg, pq_shared_secret)
+            msg = {**clean_msg, "pubkey": public_key_hex(private_key), "sig": sig.hex()}
+            if pq_shared_secret is not None:
+                encrypted = pq_encrypt(pq_shared_secret, "request", json.dumps(clean_msg).encode("utf-8"))
+                msg = {
+                    "id": clean_msg.get("id"),
+                    "user_agent": clean_msg.get("user_agent"),
+                    "pubkey": public_key_hex(private_key),
+                    "sig": sig.hex(),
+                    "pq_kex": clean_msg["pq_kex"],
+                    "encrypted": encrypted,
+                }
+        else:
+            sys.stderr.write(_PQ_WARNING)
+
+        payload = json.dumps(msg).encode("utf-8")
+        framed = struct.pack("<I", len(payload)) + payload
+        sock.sendall(framed)
+        response = _recv_all(sock)
+        if response is not None and pq_shared_secret is not None:
+            try:
+                from browser_cli.auth import pq_decrypt
+                envelope = json.loads(response)
+                if isinstance(envelope, dict) and "encrypted" in envelope:
+                    return pq_decrypt(pq_shared_secret, "response", envelope["encrypted"])
+            except Exception as e:
+                raise BrowserNotConnected(f"Cannot decrypt post-quantum remote response: {e}") from e
+        return response
diff --git a/browser_cli/sdk/__init__.py b/browser_cli/sdk/__init__.py
new file mode 100644
index 0000000..cc659cf
--- /dev/null
+++ b/browser_cli/sdk/__init__.py
@@ -0,0 +1,30 @@
+"""SDK command namespaces for :class:`browser_cli.BrowserCLI`.
+
+Each namespace groups related browser commands under a short accessor on the
+client (``b.tabs``, ``b.dom``, ``b.session``, ...), mirroring the command groups
+in the browser extension.
+"""
+from browser_cli.sdk.browser_data import CookiesNS, StorageNS
+from browser_cli.sdk.dom import DomNS, ExtractNS, PageNS
+from browser_cli.sdk.extension import ExtensionNS
+from browser_cli.sdk.groups import GroupsNS
+from browser_cli.sdk.navigation import NavigationNS
+from browser_cli.sdk.perf import PerfNS
+from browser_cli.sdk.session import SessionNS
+from browser_cli.sdk.tabs import TabsNS
+from browser_cli.sdk.windows import WindowsNS
+
+__all__ = [
+    "NavigationNS",
+    "TabsNS",
+    "GroupsNS",
+    "WindowsNS",
+    "DomNS",
+    "ExtractNS",
+    "PageNS",
+    "StorageNS",
+    "CookiesNS",
+    "SessionNS",
+    "PerfNS",
+    "ExtensionNS",
+]
diff --git a/browser_cli/sdk/base.py b/browser_cli/sdk/base.py
new file mode 100644
index 0000000..7cd9df0
--- /dev/null
+++ b/browser_cli/sdk/base.py
@@ -0,0 +1,19 @@
+"""Base class for SDK command namespaces.
+
+Each namespace (``b.tabs``, ``b.dom``, ...) is a thin object bound to its
+:class:`~browser_cli.BrowserCLI` client. Namespaces hold no state of their own;
+they delegate to the client's shared infrastructure (``_cmd``, the multi-browser
+helpers, and the ``Tab``/``Group`` factories).
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from browser_cli import BrowserCLI
+
+class Namespace:
+    """A group of related SDK methods, bound to a BrowserCLI client."""
+
+    def __init__(self, client: "BrowserCLI"):
+        self._c = client
diff --git a/browser_cli/sdk/browser_data.py b/browser_cli/sdk/browser_data.py
new file mode 100644
index 0000000..d21c6e0
--- /dev/null
+++ b/browser_cli/sdk/browser_data.py
@@ -0,0 +1,66 @@
+"""Storage and cookies namespaces: ``b.storage.*``, ``b.cookies.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class StorageNS(Namespace):
+    """Read and write localStorage / sessionStorage."""
+
+    def get(
+        self,
+        key: str | None = None,
+        *,
+        type: str = "local",
+        tab_id: int | None = None,
+    ) -> str | dict | None:
+        """Get a localStorage/sessionStorage entry (or all entries if key omitted)."""
+        return self._c._cmd("storage.get", {"key": key, "type": type, "tabId": tab_id})
+
+    def set(
+        self,
+        key: str,
+        value: str,
+        *,
+        type: str = "local",
+        tab_id: int | None = None,
+    ) -> None:
+        """Set a localStorage/sessionStorage entry."""
+        self._c._cmd("storage.set", {"key": key, "value": value, "type": type, "tabId": tab_id})
+
+class CookiesNS(Namespace):
+    """List, get, and set cookies."""
+
+    def list(
+        self,
+        *,
+        url: str | None = None,
+        domain: str | None = None,
+        name: str | None = None,
+    ) -> list[dict]:
+        """List cookies, optionally filtered by url, domain, or name."""
+        return self._c._cmd("cookies.list", {"url": url, "domain": domain, "name": name}) or []
+
+    def get(self, url: str, name: str) -> dict | None:
+        """Get a single cookie by url and name."""
+        return self._c._cmd("cookies.get", {"url": url, "name": name})
+
+    def set(
+        self,
+        url: str,
+        name: str,
+        value: str,
+        *,
+        domain: str | None = None,
+        path: str | None = None,
+        secure: bool | None = None,
+        http_only: bool | None = None,
+        expiration_date: float | None = None,
+        same_site: str | None = None,
+    ) -> dict:
+        """Set a cookie. Returns the created cookie dict."""
+        return self._c._cmd("cookies.set", {
+            "url": url, "name": name, "value": value,
+            "domain": domain, "path": path,
+            "secure": secure, "httpOnly": http_only,
+            "expirationDate": expiration_date, "sameSite": same_site,
+        })
diff --git a/browser_cli/sdk/dom.py b/browser_cli/sdk/dom.py
new file mode 100644
index 0000000..8fa41e8
--- /dev/null
+++ b/browser_cli/sdk/dom.py
@@ -0,0 +1,150 @@
+"""DOM, content-extraction, and page-info namespaces: ``b.dom.*``, ``b.extract.*``, ``b.page.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class DomNS(Namespace):
+    """Query and drive page elements in the active (or specified) tab."""
+
+    def query(self, selector: str) -> list[dict]:
+        return self._c._cmd("dom.query", {"selector": selector}) or []
+
+    def click(self, selector: str) -> None:
+        self._c._cmd("dom.click", {"selector": selector})
+
+    def type(self, selector: str, text: str) -> None:
+        self._c._cmd("dom.type", {"selector": selector, "text": text})
+
+    def attr(self, selector: str, attr: str) -> list[str]:
+        return self._c._cmd("dom.attr", {"selector": selector, "attr": attr}) or []
+
+    def text(self, selector: str) -> list[str]:
+        return self._c._cmd("dom.text", {"selector": selector}) or []
+
+    def exists(self, selector: str) -> bool:
+        return self._c._cmd("dom.exists", {"selector": selector}) or False
+
+    def scroll(self, selector: str | None = None, *, x: int | None = None, y: int | None = None) -> None:
+        """Scroll to a CSS selector or to pixel coordinates."""
+        self._c._cmd("dom.scroll", {"selector": selector, "x": x, "y": y})
+
+    def select(self, selector: str, value: str) -> None:
+        """Set the value of a <select> element."""
+        self._c._cmd("dom.select", {"selector": selector, "value": value})
+
+    def eval(self, code: str, tab_id: int | None = None):
+        """Evaluate JavaScript in the page's main world and return the result."""
+        return self._c._cmd("dom.eval", {"code": code, "tabId": tab_id})
+
+    def key(self, key: str, selector: str | None = None) -> None:
+        """Dispatch a keyboard event. key examples: 'Enter', 'Tab', 'Escape', 'ArrowDown'."""
+        self._c._cmd("dom.key", {"key": key, "selector": selector})
+
+    def hover(self, selector: str) -> None:
+        """Dispatch mouseover/mouseenter on an element."""
+        self._c._cmd("dom.hover", {"selector": selector})
+
+    def check(self, selector: str) -> None:
+        """Check a checkbox."""
+        self._c._cmd("dom.check", {"selector": selector})
+
+    def uncheck(self, selector: str) -> None:
+        """Uncheck a checkbox."""
+        self._c._cmd("dom.uncheck", {"selector": selector})
+
+    def clear(self, selector: str) -> None:
+        """Clear the value of an input element."""
+        self._c._cmd("dom.clear", {"selector": selector})
+
+    def focus(self, selector: str) -> None:
+        """Focus an element."""
+        self._c._cmd("dom.focus", {"selector": selector})
+
+    def submit(self, selector: str) -> None:
+        """Submit the form containing the matched element."""
+        self._c._cmd("dom.submit", {"selector": selector})
+
+    def poll(
+        self,
+        selector: str,
+        pattern: str,
+        *,
+        attr: str | None = None,
+        timeout: float = 30.0,
+        interval: float = 0.5,
+        tab_id: int | None = None,
+    ) -> dict:
+        """Poll selector's text/value until it matches regex pattern.
+
+        Returns ``{"selector": ..., "value": ..., "pattern": ...}`` when matched.
+        """
+        return self._c._cmd("dom.poll", {
+            "selector": selector,
+            "pattern": pattern,
+            "attr": attr,
+            "timeout": int(timeout * 1000),
+            "interval": int(interval * 1000),
+            "tabId": tab_id,
+        })
+
+    def wait_for(
+        self,
+        selector: str,
+        *,
+        timeout: float = 10.0,
+        visible: bool = False,
+        hidden: bool = False,
+        tab_id: int | None = None,
+    ) -> dict:
+        """Wait until a CSS selector appears (or disappears) in the DOM.
+
+        Args:
+            selector: CSS selector to watch.
+            timeout: Max seconds to wait before raising ``RuntimeError``.
+            visible: Wait until the element has non-zero dimensions.
+            hidden: Wait until the element is absent or has ``offsetParent == null``.
+            tab_id: Tab to watch. Defaults to the active tab.
+        """
+        return self._c._cmd("dom.wait_for", {
+            "selector": selector,
+            "timeout": int(timeout * 1000),
+            "visible": visible,
+            "hidden": hidden,
+            "tabId": tab_id,
+        })
+
+class ExtractNS(Namespace):
+    """Extract structured content from the active tab."""
+
+    def links(self) -> list[dict]:
+        return self._c._cmd("extract.links", {}) or []
+
+    def images(self) -> list[dict]:
+        return self._c._cmd("extract.images", {}) or []
+
+    def text(self) -> str:
+        return self._c._cmd("extract.text", {}) or ""
+
+    def json(self, selector: str):
+        return self._c._cmd("extract.json", {"selector": selector})
+
+    def html(self) -> str:
+        """Return the full HTML source of the active tab."""
+        return self._c._cmd("extract.html", {}) or ""
+
+    def markdown(self, selector: str | None = None) -> str:
+        """Extract the page's main content as clean Markdown.
+
+        The extractor may return either Markdown or raw HTML; both are
+        normalized to Markdown here so SDK and CLI callers get identical output.
+        """
+        from browser_cli.markdown import render_markdown
+
+        return render_markdown(self._c._cmd("extract.markdown", {"selector": selector}))
+
+class PageNS(Namespace):
+    """Inspect the active page."""
+
+    def info(self) -> dict:
+        """Return title, URL, readyState, lang, and meta tags of the active tab."""
+        return self._c._cmd("page.info", {}) or {}
diff --git a/browser_cli/sdk/extension.py b/browser_cli/sdk/extension.py
new file mode 100644
index 0000000..595f5e5
--- /dev/null
+++ b/browser_cli/sdk/extension.py
@@ -0,0 +1,16 @@
+"""Extension-control namespace: ``b.extension.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class ExtensionNS(Namespace):
+    """Control the browser-cli extension itself."""
+
+    def reload(self) -> None:
+        """Reload the browser-cli extension service worker.
+
+        Schedules a ``chrome.runtime.reload()`` inside the extension and returns
+        immediately. The extension restarts ~200 ms later and reconnects via the
+        keepalive alarm within ~25 seconds.
+        """
+        self._c._cmd("extension.reload", {})
diff --git a/browser_cli/sdk/factories.py b/browser_cli/sdk/factories.py
new file mode 100644
index 0000000..c569dcf
--- /dev/null
+++ b/browser_cli/sdk/factories.py
@@ -0,0 +1,94 @@
+"""Object-factory mixin for :class:`~browser_cli.BrowserCLI`.
+
+Builds the typed :class:`~browser_cli.models.Tab` / :class:`~browser_cli.models.Group`
+dataclasses from raw command responses and binds each one to the client that
+should run its actions. In multi-browser mode an object is bound to a sibling
+client targeting the browser it came from, so ``tab.close()`` routes correctly.
+"""
+from __future__ import annotations
+
+from browser_cli.models import Group, Tab
+
+class FactoryMixin:
+    """Turn raw response dicts into bound ``Tab``/``Group`` objects.
+
+    Mixed into :class:`~browser_cli.BrowserCLI`; relies on the client providing
+    ``_browser``/``_remote``/``_key`` and being constructible via ``type(self)``.
+    """
+
+    def _make_tab(
+        self,
+        data: dict,
+        *,
+        browser_profile: str | None = None,
+        browser_name: str | None = None,
+        browser_remote: str | None = None,
+    ) -> Tab:
+        tab = Tab(
+            id=data["id"],
+            window_id=data.get("windowId", 0),
+            active=data.get("active", False),
+            muted=data.get("muted", False),
+            title=data.get("title") or "",
+            url=data.get("url") or "",
+            group_id=data.get("groupId") or None,
+            browser=browser_name,
+        )
+        tab._browser = self if browser_profile is None else type(self)(
+            browser=browser_profile,
+            remote=browser_remote,
+            key=self._key,
+        )
+        return tab
+
+    def _require_tab(self, data, error: str) -> Tab:
+        """Build a bound Tab from a tab-shaped response, or raise ``RuntimeError(error)``."""
+        if not isinstance(data, dict) or "id" not in data:
+            raise RuntimeError(error)
+        return self._make_tab(data)
+
+    def _make_group(
+        self,
+        data: dict,
+        *,
+        browser_profile: str | None = None,
+        browser_name: str | None = None,
+        browser_remote: str | None = None,
+    ) -> Group:
+        group = Group(
+            id=data["id"],
+            title=data.get("title") or "",
+            color=data.get("color") or "",
+            collapsed=data.get("collapsed", False),
+            tab_count=data.get("tabCount", 0),
+            browser=browser_name,
+        )
+        group._browser = self if browser_profile is None else type(self)(
+            browser=browser_profile,
+            remote=browser_remote,
+            key=self._key,
+        )
+        return group
+
+    def _make_tab_for(self, data: dict, target) -> Tab:
+        """Build a Tab, tagging it with *target* in multi-browser mode (``None`` = local)."""
+        return self._make_tab(
+            data,
+            browser_profile=target.profile if target else None,
+            browser_name=target.display_name if target else None,
+            browser_remote=target.remote if target else None,
+        )
+
+    def _make_group_for(self, data: dict, target) -> Group:
+        """Build a Group, tagging it with *target* in multi-browser mode (``None`` = local)."""
+        return self._make_group(
+            data,
+            browser_profile=target.profile if target else None,
+            browser_name=target.display_name if target else None,
+            browser_remote=target.remote if target else None,
+        )
+
+    @staticmethod
+    def _tag_browser(item: dict, target) -> dict:
+        """Return *item* as-is locally, or with a ``browser`` key in multi-browser mode."""
+        return item if target is None else {**item, "browser": target.display_name}
diff --git a/browser_cli/sdk/groups.py b/browser_cli/sdk/groups.py
new file mode 100644
index 0000000..4af442c
--- /dev/null
+++ b/browser_cli/sdk/groups.py
@@ -0,0 +1,56 @@
+"""Tab groups namespace: ``b.groups.*``."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from browser_cli.models import Group, Tab
+from browser_cli.sdk.base import Namespace
+
+if TYPE_CHECKING:
+    from browser_cli import BrowserCounts
+
+class GroupsNS(Namespace):
+    """List, create, query, and modify tab groups."""
+
+    def list(self) -> list[Group]:
+        """Return all tab groups.
+
+        When multiple browsers are active and no browser was specified, each Group
+        includes ``group.browser`` naming its source browser.
+        """
+        return self._c._multi_list("group.list", {}, self._c._make_group_for)
+
+    def count(self) -> "int | BrowserCounts":
+        """Return the number of tab groups.
+
+        Returns ``BrowserCounts`` in implicit multi-browser mode.
+        """
+        return self._c._multi_count("group.count", {})
+
+    def query(self, search: str) -> list[Group]:
+        """Search groups by name."""
+        return [self._c._make_group(g) for g in (self._c._cmd("group.query", {"search": search}) or [])]
+
+    def create(self, name: str) -> Group:
+        """Create a new tab group with *name*. Returns the created Group."""
+        data = self._c._cmd("group.open", {"name": name})
+        if isinstance(data, dict):
+            return self._c._make_group(data)
+        return Group(id=data, title=name, color="", collapsed=False, tab_count=0)
+
+    def tabs(self, group_id: int) -> list[Tab]:
+        """Return all tabs inside a group."""
+        return [self._c._make_tab(t) for t in (self._c._cmd("group.tabs", {"groupId": group_id}) or [])]
+
+    def add_tab(self, group: str | int, url: str | None = None) -> int | None:
+        """Open a new tab (optionally at URL) inside a group. Returns the new tab ID."""
+        result = self._c._cmd("group.add_tab", {"group": str(group), "url": url})
+        return self._c._field(result, "tabId", fallback=result)
+
+    def move(self, group: str | int, *, forward: bool = False, backward: bool = False) -> dict | None:
+        """Move a tab group forward or backward. Returns the raw move result."""
+        return self._c._cmd("group.move", {"group": str(group), "forward": forward, "backward": backward})
+
+    def close(self, group_id: int, *, gentle_mode: str = "auto") -> None:
+        """Ungroup (and close) a tab group by ID."""
+        self._c._cmd("group.close", {"groupId": group_id, "gentleMode": gentle_mode})
diff --git a/browser_cli/sdk/navigation.py b/browser_cli/sdk/navigation.py
new file mode 100644
index 0000000..a5c5417
--- /dev/null
+++ b/browser_cli/sdk/navigation.py
@@ -0,0 +1,63 @@
+"""Navigation namespace: ``b.nav.*``."""
+from __future__ import annotations
+
+from browser_cli.models import Tab
+from browser_cli.sdk.base import Namespace
+
+class NavigationNS(Namespace):
+    """Open URLs, navigate history, and focus tabs."""
+
+    def open(self, url: str, *, background: bool = False, window: str | None = None, group: str | None = None) -> None:
+        """Open *url* in a new tab."""
+        self._c._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group})
+
+    def open_wait(
+        self,
+        url: str,
+        *,
+        timeout: float = 30.0,
+        background: bool = False,
+        window: str | None = None,
+        group: str | None = None,
+    ) -> Tab:
+        """Open *url* in a new tab and block until fully loaded. Returns the Tab."""
+        return self._c._require_tab(
+            self._c._cmd("navigate.open_wait", {
+                "url": url, "timeout": int(timeout * 1000),
+                "background": background, "window": window, "group": group,
+            }),
+            "navigate.open_wait returned unexpected data",
+        )
+
+    def reload(self, tab_id: int | None = None) -> None:
+        self._c._cmd("navigate.reload", {"tabId": tab_id})
+
+    def hard_reload(self, tab_id: int | None = None) -> None:
+        self._c._cmd("navigate.hard_reload", {"tabId": tab_id})
+
+    def back(self, tab_id: int | None = None) -> None:
+        self._c._cmd("navigate.back", {"tabId": tab_id})
+
+    def forward(self, tab_id: int | None = None) -> None:
+        self._c._cmd("navigate.forward", {"tabId": tab_id})
+
+    def focus(self, pattern: str) -> dict | None:
+        """Focus the first tab whose URL matches *pattern*. Returns the matched tab info, if any."""
+        return self._c._cmd("navigate.focus", {"pattern": pattern})
+
+    def to(self, tab_id: int, url: str) -> None:
+        """Navigate a specific tab to *url* in place."""
+        self._c._cmd("navigate.to", {"tabId": tab_id, "url": url})
+
+    def search(
+        self, engine: str, query: str, *,
+        background: bool = False, window: str | None = None, group: str | None = None,
+    ) -> None:
+        """Open a search query in the given engine (e.g. 'google', 'youtube', 'ddg')."""
+        from urllib.parse import quote_plus
+        from browser_cli.commands.search import ENGINES
+        template = ENGINES.get(engine)
+        if template is None:
+            raise ValueError(f"Unknown search engine '{engine}'. Available: {', '.join(ENGINES)}")
+        url = template.format(query=quote_plus(query))
+        self._c._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group})
diff --git a/browser_cli/sdk/perf.py b/browser_cli/sdk/perf.py
new file mode 100644
index 0000000..23c0dd7
--- /dev/null
+++ b/browser_cli/sdk/perf.py
@@ -0,0 +1,19 @@
+"""Performance and background-jobs namespace: ``b.perf.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class PerfNS(Namespace):
+    """Inspect the performance profile and manage background jobs."""
+
+    def status(self) -> dict:
+        return self._c._cmd("perf.status", {}) or {}
+
+    def set_profile(self, profile: str) -> dict:
+        return self._c._cmd("perf.set_profile", {"profile": profile}) or {}
+
+    def job_status(self, job_id: str) -> dict:
+        return self._c._cmd("jobs.status", {"jobId": job_id}) or {}
+
+    def job_cancel(self, job_id: str) -> dict:
+        return self._c._cmd("jobs.cancel", {"jobId": job_id}) or {}
diff --git a/browser_cli/sdk/routing.py b/browser_cli/sdk/routing.py
new file mode 100644
index 0000000..fea3332
--- /dev/null
+++ b/browser_cli/sdk/routing.py
@@ -0,0 +1,123 @@
+"""Multi-browser routing mixin for :class:`~browser_cli.BrowserCLI`.
+
+When no specific browser is selected and more than one browser (local or
+remote) is active, list/count commands fan out to every target and aggregate
+the results. This mixin holds that fan-out machinery plus a few small response
+helpers; single-browser mode falls straight through to ``_cmd``.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+
+import browser_cli as _pkg
+from browser_cli.client import BrowserNotConnected
+from browser_cli.models import BrowserCounts, Tab
+
+# send_command / active_browser_targets / remote_browser_targets are resolved
+# through the ``browser_cli`` package namespace (``_pkg``) at call time, not bound
+# here at import, so tests patching ``browser_cli.send_command`` still take effect.
+
+_UNSET = object()
+
+class RoutingMixin:
+    """Fan-out + aggregation across active browsers, mixed into ``BrowserCLI``.
+
+    Relies on the client exposing ``_browser``/``_remote``/``_key``, ``_cmd``,
+    and a ``tabs`` namespace.
+    """
+
+    def _multi_browser_targets(self):
+        if self._browser is not None:
+            return []
+        if self._remote:
+            targets = _pkg.remote_browser_targets(self._remote, key=self._key)
+        else:
+            targets = _pkg.active_browser_targets()
+        if len(targets) <= 1 and not any(target.remote for target in targets):
+            return []
+        return targets
+
+    def _collect_multi_browser(self, command: str, args: dict | None = None):
+        results = []
+        targets = self._multi_browser_targets()
+        for target in targets:
+            try:
+                if target.remote:
+                    data = _pkg.send_command(command, args, profile=target.profile, remote=target.remote, key=self._key)
+                else:
+                    data = _pkg.send_command(command, args, profile=target.profile)
+            except (BrowserNotConnected, RuntimeError):
+                continue
+            results.append((target, data))
+        if results:
+            return results
+        if targets:
+            raise BrowserNotConnected(
+                "Cannot resolve a browser socket automatically.\n"
+                "Make sure the browser is running with the browser-cli extension enabled,\n"
+                "or pass --browser <alias> / set BROWSER_CLI_PROFILE to a known alias."
+            )
+        return []
+
+    @staticmethod
+    def _field(result, key, default=None, *, fallback=_UNSET):
+        """Pull *key* out of a dict response, with a non-dict fallback.
+
+        Returns ``result[key]`` (or *default*) when *result* is a dict. When it
+        is not a dict, returns *fallback* if given, else *default*.
+        """
+        if isinstance(result, dict):
+            return result.get(key, default)
+        return default if fallback is _UNSET else fallback
+
+    def _toggle_tab(self, command: str, tab_id: int | None) -> int:
+        """Run a tab toggle command (mute/pin/...) and return the target tab ID."""
+        result = self._cmd(command, {"tabId": tab_id})
+        return self._field(result, "tabId", tab_id, fallback=int(tab_id or 0))
+
+    def _multi_count(self, command: str, args: dict | None = None) -> "int | BrowserCounts":
+        """Count command that aggregates into :class:`BrowserCounts` in multi-browser mode."""
+        multi_results = self._collect_multi_browser(command, args or {})
+        if not multi_results:
+            return self._cmd(command, args or {})
+        by_browser = {target.display_name: int(count or 0) for target, count in multi_results}
+        return BrowserCounts(total=sum(by_browser.values()), by_browser=by_browser)
+
+    def _multi_list(self, command: str, args: dict | None, mapper):
+        """List command, flattening per-browser results in multi-browser mode.
+
+        *mapper* is ``(item, target) -> mapped`` where ``target`` is the source
+        :class:`BrowserTarget` in multi mode, or ``None`` in single-browser mode.
+        """
+        multi_results = self._collect_multi_browser(command, args or {})
+        if multi_results:
+            return [
+                mapper(item, target)
+                for target, items in multi_results
+                for item in (items or [])
+            ]
+        return [mapper(item, None) for item in (self._cmd(command, args or {}) or [])]
+
+    def _apply_tab_filter(self, filter_fn: Callable[[Tab], bool] | Callable[[list[Tab]], Iterable[Tab]]) -> list[Tab]:
+        tabs = self.tabs.list()
+
+        try:
+            transformed = filter_fn(tabs)
+        except (AttributeError, TypeError):
+            return [tab for tab in tabs if filter_fn(tab)]
+
+        if isinstance(transformed, list):
+            return transformed
+        if isinstance(transformed, tuple):
+            return list(transformed)
+        if isinstance(transformed, set):
+            return list(transformed)
+        if transformed is tabs:
+            return tabs
+        if isinstance(transformed, bool):
+            return [tab for tab in tabs if filter_fn(tab)]
+
+        try:
+            return list(transformed)
+        except TypeError:
+            return [tab for tab in tabs if filter_fn(tab)]
diff --git a/browser_cli/sdk/session.py b/browser_cli/sdk/session.py
new file mode 100644
index 0000000..19f059a
--- /dev/null
+++ b/browser_cli/sdk/session.py
@@ -0,0 +1,63 @@
+"""Session namespace: ``b.session.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class SessionNS(Namespace):
+    """Save, restore, list, and diff browser sessions."""
+
+    def save(self, name: str) -> dict:
+        """Save all current tabs as session *name*. Returns the save result (incl. tab count)."""
+        return self._c._cmd("session.save", {"name": name}) or {}
+
+    @staticmethod
+    def _load_args(name, gentle_mode, discard_background_tabs, lazy, eager_tabs) -> dict:
+        return {
+            "name": name,
+            "gentleMode": gentle_mode,
+            "discardBackgroundTabs": discard_background_tabs,
+            "lazy": lazy,
+            "eagerTabs": eager_tabs,
+        }
+
+    def load(
+        self,
+        name: str,
+        *,
+        gentle_mode: str = "auto",
+        discard_background_tabs: bool = False,
+        lazy: bool = False,
+        eager_tabs: int = 10,
+    ) -> dict:
+        """Restore session *name*. Returns the load result (incl. tabs opened)."""
+        args = self._load_args(name, gentle_mode, discard_background_tabs, lazy, eager_tabs)
+        return self._c._cmd("session.load", args) or {}
+
+    def load_background(
+        self,
+        name: str,
+        *,
+        gentle_mode: str = "auto",
+        discard_background_tabs: bool = False,
+        lazy: bool = False,
+        eager_tabs: int = 10,
+    ) -> dict:
+        """Restore session *name* as a background job. Returns the job descriptor."""
+        args = self._load_args(name, gentle_mode, discard_background_tabs, lazy, eager_tabs)
+        return self._c._cmd("session.load", {**args, "__background": True}) or {}
+
+    def diff(self, name_a: str, name_b: str) -> dict:
+        return self._c._cmd("session.diff", {"nameA": name_a, "nameB": name_b}) or {}
+
+    def list(self) -> list[dict]:
+        """Return saved sessions.
+
+        In implicit multi-browser mode each session dict includes a ``browser`` key.
+        """
+        return self._c._multi_list("session.list", {}, self._c._tag_browser)
+
+    def remove(self, name: str) -> None:
+        self._c._cmd("session.remove", {"name": name})
+
+    def auto_save(self, enabled: bool) -> None:
+        self._c._cmd("session.auto_save", {"enabled": enabled})
diff --git a/browser_cli/sdk/tabs.py b/browser_cli/sdk/tabs.py
new file mode 100644
index 0000000..bb39051
--- /dev/null
+++ b/browser_cli/sdk/tabs.py
@@ -0,0 +1,215 @@
+"""Tabs namespace: ``b.tabs.*``."""
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING
+
+from browser_cli.models import Tab
+from browser_cli.sdk.base import Namespace
+
+if TYPE_CHECKING:
+    from browser_cli import BrowserCounts
+
+class TabsNS(Namespace):
+    """List, open, close, move, and inspect browser tabs."""
+
+    def list(self) -> list[Tab]:
+        """Return all open tabs across all windows.
+
+        When multiple browsers are active and no browser was specified, each Tab
+        includes ``tab.browser`` naming its source browser.
+        """
+        return self._c._multi_list("tabs.list", {}, self._c._make_tab_for)
+
+    def open(
+        self,
+        url: str,
+        *,
+        wait: bool = False,
+        timeout: float = 30.0,
+        background: bool = False,
+        window: str | None = None,
+        group: str | None = None,
+    ) -> Tab:
+        """Open *url* in a new tab and return a bound :class:`Tab`.
+
+        Set ``wait=True`` to block until the page reaches ``readyState=complete``.
+        """
+        if wait:
+            return self._c.nav.open_wait(url, timeout=timeout, background=background, window=window, group=group)
+        return self._c._require_tab(
+            self._c._cmd("navigate.open", {"url": url, "background": background, "window": window, "group": group}),
+            "navigate.open returned unexpected data",
+        )
+
+    def get(self, tab_id: int) -> Tab:
+        """Return a specific tab by ID."""
+        return self.status(tab_id)
+
+    def active(self) -> Tab:
+        """Return the active tab."""
+        return self.status()
+
+    def query(self, search: str) -> list[Tab]:
+        """Search tabs by URL or title."""
+        return [self._c._make_tab(t) for t in (self._c._cmd("tabs.query", {"search": search}) or [])]
+
+    def first(self, search: str) -> Tab | None:
+        """Return the first tab matching *search*, or ``None``."""
+        matches = self.query(search)
+        return matches[0] if matches else None
+
+    def close(
+        self,
+        tab_id: int | None = None,
+        *,
+        tab_ids: Iterable[int | Tab] | None = None,
+        inactive: bool = False,
+        duplicates: bool = False,
+        gentle_mode: str = "auto",
+    ) -> int:
+        """Close tab(s). Returns the number of tabs closed.
+
+        Pass ``tab_ids`` to close many tabs in a single round-trip. Accepts tab
+        IDs or :class:`Tab` objects. ``gentle_mode`` (auto/normal/gentle/ultra)
+        controls throttling of large close operations.
+        """
+        ids = None
+        if tab_ids is not None:
+            ids = [t.id if isinstance(t, Tab) else t for t in tab_ids]
+        result = self._c._cmd("tabs.close", {
+            "tabId": tab_id,
+            "tabIds": ids,
+            "inactive": inactive,
+            "duplicates": duplicates,
+            "gentleMode": gentle_mode,
+        })
+        return self._c._field(result, "closed", 1)
+
+    def close_inactive(self) -> int:
+        """Close all inactive tabs. Returns count closed."""
+        return self._c._field(self._c._cmd("tabs.close", {"inactive": True}), "closed", 0)
+
+    def close_duplicates(self) -> int:
+        """Close duplicate tabs. Returns count closed."""
+        return self._c._field(self._c._cmd("tabs.close", {"duplicates": True}), "closed", 0)
+
+    def move(
+        self, tab_id: int, *,
+        forward: bool = False, backward: bool = False,
+        group_id: int | None = None, window_id: int | None = None, index: int | None = None,
+    ) -> None:
+        self._c._cmd("tabs.move", {
+            "tabId": tab_id, "forward": forward, "backward": backward,
+            "groupId": group_id, "windowId": window_id, "index": index,
+        })
+
+    def activate(self, tab_id: int) -> None:
+        """Switch browser focus to a tab by ID."""
+        self._c._cmd("tabs.active", {"tabId": tab_id})
+
+    def status(self, tab_id: int | None = None) -> Tab:
+        """Return status for the active tab or a specific tab."""
+        return self._c._require_tab(self._c._cmd("tabs.status", {"tabId": tab_id}), "No tab status returned")
+
+    def mute(self, tab_id: int | None = None) -> int:
+        """Mute the active tab or a specific tab. Returns the target tab ID."""
+        return self._c._toggle_tab("tabs.mute", tab_id)
+
+    def unmute(self, tab_id: int | None = None) -> int:
+        """Unmute the active tab or a specific tab. Returns the target tab ID."""
+        return self._c._toggle_tab("tabs.unmute", tab_id)
+
+    def pin(self, tab_id: int | None = None) -> int:
+        """Pin the active tab or a specific tab. Returns the target tab ID."""
+        return self._c._toggle_tab("tabs.pin", tab_id)
+
+    def unpin(self, tab_id: int | None = None) -> int:
+        """Unpin the active tab or a specific tab. Returns the target tab ID."""
+        return self._c._toggle_tab("tabs.unpin", tab_id)
+
+    def watch_url(self, pattern: str, *, tab_id: int | None = None, timeout: float = 30.0) -> Tab:
+        """Block until the tab URL matches regex pattern. Returns the Tab."""
+        return self._c._require_tab(
+            self._c._cmd("tabs.watch_url", {"pattern": pattern, "tabId": tab_id, "timeout": int(timeout * 1000)}),
+            "tabs.watch_url returned unexpected data",
+        )
+
+    def wait_for_load(
+        self,
+        tab_id: int | None = None,
+        *,
+        timeout: float = 30.0,
+        ready_state: str = "complete",
+    ) -> Tab:
+        """Block until the tab finishes loading. Returns the Tab when ready.
+
+        Args:
+            tab_id: Tab to watch. Defaults to the active tab.
+            timeout: Max seconds to wait before raising ``RuntimeError``.
+            ready_state: ``"complete"`` (default) or ``"interactive"``.
+        """
+        return self._c._require_tab(
+            self._c._cmd("navigate.wait", {
+                "tabId": tab_id,
+                "timeout": int(timeout * 1000),
+                "readyState": ready_state,
+            }),
+            "navigate.wait returned unexpected data",
+        )
+
+    def screenshot(
+        self,
+        tab_id: int | None = None,
+        *,
+        format: str = "png",
+        quality: int | None = None,
+    ) -> str:
+        """Capture the visible area of a tab. Returns a base64 data URL.
+
+        Args:
+            tab_id: Tab to capture. Defaults to the active tab.
+            format: ``"png"`` (default) or ``"jpeg"``.
+            quality: JPEG quality 0-100 (ignored for PNG).
+        """
+        result = self._c._cmd("tabs.screenshot", {"tabId": tab_id, "format": format, "quality": quality})
+        return self._c._field(result, "dataUrl", "", fallback=str(result))
+
+    def active_in_window(self, window_id: int) -> Tab:
+        """Return active tab for a specific browser window."""
+        return self._c._require_tab(
+            self._c._cmd("tabs.active_in_window", {"windowId": window_id}),
+            f"No active tab found for window {window_id}",
+        )
+
+    def filter(
+        self,
+        pattern_or_filter: str | Callable[[Tab], bool] | Callable[[list[Tab]], Iterable[Tab]],
+    ) -> list[Tab]:
+        """Return tabs filtered by URL pattern or a Python callable."""
+        if isinstance(pattern_or_filter, str):
+            return [self._c._make_tab(t) for t in (self._c._cmd("tabs.filter", {"pattern": pattern_or_filter}) or [])]
+        return self._c._apply_tab_filter(pattern_or_filter)
+
+    def count(self, pattern: str | None = None) -> "int | BrowserCounts":
+        """Count open tabs, optionally filtered by URL pattern.
+
+        Returns ``BrowserCounts`` in implicit multi-browser mode.
+        """
+        return self._c._multi_count("tabs.count", {"pattern": pattern})
+
+    def html(self, tab_id: int | None = None) -> str:
+        """Return the full HTML source of the active (or specified) tab."""
+        return self._c._cmd("tabs.html", {"tabId": tab_id}) or ""
+
+    def dedupe(self, *, gentle_mode: str = "auto") -> int:
+        """Close duplicate tabs (keep the first occurrence of each URL). Returns count closed."""
+        return self._c._field(self._c._cmd("tabs.dedupe", {"gentleMode": gentle_mode}), "closed", 0)
+
+    def sort(self, by: str = "domain", *, gentle_mode: str = "auto") -> None:
+        """Sort tabs within each window. *by* is one of 'domain', 'title', 'time'."""
+        self._c._cmd("tabs.sort", {"by": by, "gentleMode": gentle_mode})
+
+    def merge_windows(self, *, gentle_mode: str = "auto") -> int:
+        """Move all tabs into the focused window. Returns count moved."""
+        return self._c._field(self._c._cmd("tabs.merge_windows", {"gentleMode": gentle_mode}), "moved", 0)
diff --git a/browser_cli/sdk/windows.py b/browser_cli/sdk/windows.py
new file mode 100644
index 0000000..2e5e47f
--- /dev/null
+++ b/browser_cli/sdk/windows.py
@@ -0,0 +1,24 @@
+"""Windows namespace: ``b.windows.*``."""
+from __future__ import annotations
+
+from browser_cli.sdk.base import Namespace
+
+class WindowsNS(Namespace):
+    """List, open, close, and rename browser windows."""
+
+    def list(self) -> list[dict]:
+        """Return browser windows.
+
+        In implicit multi-browser mode each window dict includes a ``browser`` key.
+        """
+        return self._c._multi_list("windows.list", {}, self._c._tag_browser)
+
+    def open(self, url: str | None = None) -> dict:
+        """Open a new browser window, optionally on a URL."""
+        return self._c._cmd("windows.open", {"url": url}) or {}
+
+    def close(self, window_id: int) -> None:
+        self._c._cmd("windows.close", {"windowId": window_id})
+
+    def rename(self, window_id: int, name: str) -> None:
+        self._c._cmd("windows.rename", {"windowId": window_id, "name": name})
diff --git a/browser_cli/transport.py b/browser_cli/transport.py
new file mode 100644
index 0000000..81d7b0b
--- /dev/null
+++ b/browser_cli/transport.py
@@ -0,0 +1,213 @@
+"""Response payload encoding for the TCP serve <-> client leg.
+
+The wire frame stays ``4-byte LE length + payload``. The payload is made
+self-describing so old peers keep working unchanged:
+
+  * A payload that starts with ``{`` or ``[`` is plain JSON (the historical
+    format). Old clients and old servers only ever produce/consume this.
+  * Any other leading byte is a 1-byte codec tag followed by the encoded body.
+    The tag's high nibble selects serialization, the low nibble compression::
+
+        tag = (serialization << 4) | compression
+
+This is only ever emitted toward a peer that advertised support for it, so it
+is fully backward compatible: clients announce what they can decode via the
+``accept_encoding`` field in their request, and the server encodes the
+response accordingly. Requests themselves stay plain JSON (they are tiny).
+
+Compression is the big win — response payloads (``extract.html``,
+``dom.query``, ``tabs.list`` over hundreds of tabs, base64 screenshots) are
+heavy and text-like. msgpack additionally lets ``tabs.screenshot`` ship the
+image as raw bytes instead of a base64 data URL (~33% smaller before
+compression); the client transparently rebuilds the data URL so the SDK/CLI
+API is unchanged.
+"""
+from __future__ import annotations
+
+import base64
+import gzip
+import json
+import re
+import zlib
+
+try:  # optional: better ratio + speed than zlib/gzip
+    import zstandard as _zstd
+except Exception:  # pragma: no cover - depends on optional extra
+    _zstd = None
+
+try:  # optional: alternate serialization + raw binary for screenshots
+    import msgpack as _msgpack
+except Exception:  # pragma: no cover - depends on optional extra
+    _msgpack = None
+
+# ── codec ids ────────────────────────────────────────────────────────────────
+SER_JSON = 0
+SER_MSGPACK = 1
+
+COMP_NONE = 0
+COMP_ZLIB = 1
+COMP_GZIP = 2
+COMP_ZSTD = 3
+
+_SER_NAME = {SER_JSON: "json", SER_MSGPACK: "msgpack"}
+_SER_ID = {v: k for k, v in _SER_NAME.items()}
+_COMP_NAME = {COMP_NONE: "none", COMP_ZLIB: "zlib", COMP_GZIP: "gzip", COMP_ZSTD: "zstd"}
+_COMP_ID = {v: k for k, v in _COMP_NAME.items()}
+
+# Don't compress payloads smaller than this — the header/CPU cost is not worth it.
+DEFAULT_THRESHOLD = 512
+
+# JSON top-level values always start with one of these bytes; a tag byte never does.
+_JSON_FIRST_BYTES = frozenset(b"{[")
+
+def msgpack_available() -> bool:
+    return _msgpack is not None
+
+def zstd_available() -> bool:
+    return _zstd is not None
+
+def supported_serialization() -> list[str]:
+    """Serializations this build can produce/consume, best first."""
+    return (["msgpack"] if _msgpack is not None else []) + ["json"]
+
+def supported_compression() -> list[str]:
+    """Compression codecs this build can produce/consume, best first."""
+    return (["zstd"] if _zstd is not None else []) + ["gzip", "zlib"]
+
+def client_accept_encoding() -> dict:
+    """What the local client advertises it can decode (sent with each request)."""
+    return {"ser": supported_serialization(), "comp": supported_compression()}
+
+# ── compression primitives ────────────────────────────────────────────────────
+
+def _compress(comp_id: int, data: bytes) -> bytes:
+    if comp_id == COMP_NONE:
+        return data
+    if comp_id == COMP_ZLIB:
+        return zlib.compress(data, 6)
+    if comp_id == COMP_GZIP:
+        return gzip.compress(data, compresslevel=6)
+    if comp_id == COMP_ZSTD:
+        if _zstd is None:
+            raise ValueError("zstd compression requested but zstandard is not installed")
+        return _zstd.ZstdCompressor(level=10).compress(data)
+    raise ValueError(f"unknown compression id {comp_id}")
+
+def _decompress(comp_id: int, data: bytes) -> bytes:
+    if comp_id == COMP_NONE:
+        return data
+    if comp_id == COMP_ZLIB:
+        return zlib.decompress(data)
+    if comp_id == COMP_GZIP:
+        return gzip.decompress(data)
+    if comp_id == COMP_ZSTD:
+        if _zstd is None:
+            raise ValueError("zstd payload received but zstandard is not installed")
+        return _zstd.ZstdDecompressor().decompress(data)
+    raise ValueError(f"unknown compression id {comp_id}")
+
+# ── codec negotiation ──────────────────────────────────────────────────────────
+
+def _choose(accept: dict | None) -> tuple[int, int]:
+    """Pick (serialization_id, compression_id) the peer accepts, server preference first."""
+    accept = accept if isinstance(accept, dict) else {}
+    accept_ser = accept.get("ser") or ["json"]
+    accept_comp = accept.get("comp") or []
+
+    ser = SER_JSON
+    if _msgpack is not None and "msgpack" in accept_ser:
+        ser = SER_MSGPACK
+
+    comp = COMP_NONE
+    for name in supported_compression():  # server preference: zstd > gzip > zlib
+        if name in accept_comp:
+            comp = _COMP_ID[name]
+            break
+    return ser, comp
+
+# ── raw-binary hoisting (screenshots) ──────────────────────────────────────────
+
+_DATA_URL_RE = re.compile(r"^data:([^;,]+);base64,(.+)$", re.S)
+_B64_MARKER = "__b64__"
+
+def _hoist_screenshot(obj, command: str | None):
+    """Replace a screenshot data URL with raw bytes so msgpack ships it unencoded.
+
+    Gated to ``tabs.screenshot`` so we never touch arbitrary page-derived data.
+    """
+    if command != "tabs.screenshot" or not isinstance(obj, dict):
+        return obj
+    data = obj.get("data")
+    if not isinstance(data, dict):
+        return obj
+    url = data.get("dataUrl")
+    if not isinstance(url, str):
+        return obj
+    m = _DATA_URL_RE.match(url)
+    if not m:
+        return obj
+    try:
+        raw = base64.b64decode(m.group(2))
+    except Exception:
+        return obj
+    new_data = dict(data)
+    new_data["dataUrl"] = {_B64_MARKER: True, "mime": m.group(1), "raw": raw}
+    return {**obj, "data": new_data}
+
+def _unhoist_binary(obj):
+    """Rebuild any hoisted data URL so callers see the original string again."""
+    if isinstance(obj, dict):
+        raw = obj.get("raw")
+        if obj.get(_B64_MARKER) and isinstance(raw, (bytes, bytearray)):
+            mime = obj.get("mime") or "application/octet-stream"
+            return f"data:{mime};base64," + base64.b64encode(bytes(raw)).decode("ascii")
+        return {k: _unhoist_binary(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_unhoist_binary(v) for v in obj]
+    return obj
+
+# ── encode / decode ─────────────────────────────────────────────────────────────
+
+def encode_response(obj, accept: dict | None = None, command: str | None = None,
+                    threshold: int = DEFAULT_THRESHOLD) -> bytes:
+    """Encode a response object for the chosen/accepted codec.
+
+    Returns bare JSON bytes when no encoding is negotiated, which is byte-for-byte
+    what an old server would have sent.
+    """
+    ser, comp = _choose(accept)
+
+    if ser == SER_MSGPACK:
+        body = _msgpack.packb(_hoist_screenshot(obj, command), use_bin_type=True)
+    else:
+        body = json.dumps(obj).encode("utf-8")
+
+    if comp != COMP_NONE and len(body) >= threshold:
+        body = _compress(comp, body)
+    else:
+        comp = COMP_NONE
+
+    if ser == SER_JSON and comp == COMP_NONE:
+        return body  # plain JSON — historical wire format, no tag byte
+
+    return bytes([(ser << 4) | comp]) + body
+
+def decode_response(raw: bytes | None):
+    """Decode a payload produced by :func:`encode_response` (or plain JSON)."""
+    if raw is None:
+        return None
+    if not raw:
+        raise ValueError("empty response payload")
+    if raw[0] in _JSON_FIRST_BYTES:
+        return json.loads(raw)
+
+    tag = raw[0]
+    ser, comp = tag >> 4, tag & 0x0F
+    body = _decompress(comp, raw[1:])
+    if ser == SER_MSGPACK:
+        if _msgpack is None:
+            raise ValueError("msgpack payload received but msgpack is not installed")
+        return _unhoist_binary(_msgpack.unpackb(body, raw=False))
+    if ser == SER_JSON:
+        return json.loads(body)
+    raise ValueError(f"unknown serialization id {ser}")
diff --git a/browser_cli/version_manager.py b/browser_cli/version_manager.py
index be8653a..d6d8de5 100644
--- a/browser_cli/version_manager.py
+++ b/browser_cli/version_manager.py
@@ -3,16 +3,16 @@ from importlib.metadata import version as _pkg_version
 PROTOCOL_MIN_CLIENT = "0.9.0"
 MAX_MSG_BYTES = 32 * 1024 * 1024
 
-
 def parse_version(v: str) -> tuple[int, ...]:
     try:
         return tuple(int(x) for x in v.lstrip("v").split("."))
     except ValueError:
         return (0,)
 
-
 def get_installed_version() -> str:
     try:
         return _pkg_version("browser-cli")
     except Exception:
         return "0.0.0"
+
+USER_AGENT = f"browser-cli/{get_installed_version()}"
diff --git a/examples/demo.py b/examples/demo.py
index 55cf71e..ed03d96 100644
--- a/examples/demo.py
+++ b/examples/demo.py
@@ -1,8 +1,11 @@
 """
-browser-cli Python API demo
+browser-cli Python SDK demo
 ----------------------------
 Shows how to manage your running browser from a Python script.
 
+Commands are grouped into namespaces on the client: b.tabs, b.nav, b.groups,
+b.dom, b.extract, b.session, ...
+
 Run with:
     uv run python examples/demo.py
 """
@@ -13,10 +16,10 @@ b = BrowserCLI()
 
 # ── 1. See what's open ────────────────────────────────────────────────────────
 print("=== Open tabs ===")
-tabs = b.tabs_list()
+tabs = b.tabs.list()
 for tab in tabs:
-    active = " <-- active" if tab["active"] else ""
-    print(f"  [{tab['id']}] (window {tab['windowId']}) {tab['title'][:50]}{active}")
+    active = " <-- active" if tab.active else ""
+    print(f"  [{tab.id}] (window {tab.window_id}) {tab.title[:50]}{active}")
 
 
 # ── 2. Count tabs per domain ──────────────────────────────────────────────────
@@ -25,9 +28,9 @@ from urllib.parse import urlparse
 from collections import Counter
 
 domains = Counter(
-    urlparse(t["url"]).netloc
+    urlparse(t.url).netloc
     for t in tabs
-    if t.get("url") and not t["url"].startswith("chrome")
+    if t.url and not t.url.startswith("chrome")
 )
 for domain, count in domains.most_common(5):
     print(f"  {count:>3}x  {domain}")
@@ -35,8 +38,8 @@ for domain, count in domains.most_common(5):
 
 # ── 3. Open a group and add tabs to it ───────────────────────────────────────
 print("\n=== Creating 'demo' tab group ===")
-group = b.group_open("demo")
-group_id = group["id"]
+group = b.groups.create("demo")
+group_id = group.id
 print(f"  Created group id: {group_id}")
 
 urls = [
@@ -45,34 +48,34 @@ urls = [
 ]
 first_tab_id = None
 for url in urls:
-    b.open(url, background=True)
+    b.nav.open(url, background=True)
     # find the tab we just opened and move it into the group
-    fresh = b.tabs_list()
-    new_tab = next((t for t in reversed(fresh) if t.get("url", "").startswith(url[:20])), None)
+    fresh = b.tabs.list()
+    new_tab = next((t for t in reversed(fresh) if t.url.startswith(url[:20])), None)
     if new_tab:
-        b.tabs_move(new_tab["id"], group_id=group_id)
-        print(f"  Added {url} → tab {new_tab['id']}")
+        b.tabs.move(new_tab.id, group_id=group_id)
+        print(f"  Added {url} → tab {new_tab.id}")
         if first_tab_id is None:
-            first_tab_id = new_tab["id"]
+            first_tab_id = new_tab.id
 
 # Activate the first opened tab so DOM/extract have a real page to work with
 if first_tab_id:
-    b.tabs_active(first_tab_id)
+    b.tabs.activate(first_tab_id)
     print(f"  Switched to tab {first_tab_id} for DOM demo")
 
 
 # ── 4. Extract links from the active tab ─────────────────────────────────────
 # Re-fetch tabs so we have the current active tab (it may have changed)
-current_tabs = b.tabs_list()
-active_tab = next((t for t in current_tabs if t.get("active")), None)
-active_url = active_tab.get("url", "") if active_tab else ""
+current_tabs = b.tabs.list()
+active_tab = next((t for t in current_tabs if t.active), None)
+active_url = active_tab.url if active_tab else ""
 scriptable = active_url.startswith("http://") or active_url.startswith("https://")
 
 print("\n=== Links on active tab ===")
 if not scriptable:
     print(f"  Skipped — active tab is {active_url!r} (not a web page)")
 else:
-    links = b.extract_links()
+    links = b.extract.links()
     for link in links[:5]:
         print(f"  {link['text'][:30]:<32} {link['href'][:60]}")
     if len(links) > 5:
@@ -83,8 +86,8 @@ else:
 print("\n=== DOM: page heading ===")
 if not scriptable:
     print(f"  Skipped — active tab is {active_url!r} (not a web page)")
-elif b.dom_exists("h1"):
-    headings = b.dom_text("h1")
+elif b.dom.exists("h1"):
+    headings = b.dom.text("h1")
     for h in headings:
         print(f"  <h1> {h}")
 else:
@@ -93,15 +96,14 @@ else:
 
 # ── 6. Save current session and show how to restore ──────────────────────────
 print("\n=== Saving session as 'demo-session' ===")
-result = b.session_save("demo-session")
-print(f"  Saved {result['tabs']} tabs")
-print("  Restore later with: b.session_load('demo-session')")
+b.session.save("demo-session")
+print("  Saved current session")
+print("  Restore later with: b.session.load('demo-session')")
 
 
-# ── 7. Clean up: close inactive tabs ─────────────────────────────────────────
+# ── 7. Clean up: close duplicate tabs ────────────────────────────────────────
 print("\n=== Closing duplicate tabs ===")
-result = b.tabs_close_duplicates()
-closed = result.get("closed", 0) if isinstance(result, dict) else 0
+closed = b.tabs.close_duplicates()
 print(f"  Closed {closed} duplicate tab(s)")
 
 print("\nDone!")
diff --git a/extension/manifest.json b/extension/manifest.json
index 9a80817..131e4c5 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "browser-cli",
-  "version": "0.10.4",
+  "version": "0.12.0",
   "description": "Control your browser from the terminal or Python SDK",
   "permissions": [
     "tabs",
diff --git a/justfile b/justfile
new file mode 100644
index 0000000..e78a41f
--- /dev/null
+++ b/justfile
@@ -0,0 +1,81 @@
+# browser-cli — task runner
+# Run `just` or `just --list` to see all recipes.
+
+# Default browser profile for `install` / quick checks
+browser := "brave"
+
+# Show available recipes
+default:
+    @just --list
+
+# ── Setup ──────────────────────────────────────────────────────────────
+
+# Install Python deps + Node deps for the extension build
+setup:
+    uv sync
+    npm ci
+
+# Register the native messaging host for a browser (default: {{browser}})
+install browser=browser:
+    uv run browser-cli install {{browser}}
+
+# ── Python ─────────────────────────────────────────────────────────────
+
+# Run the full Python test suite
+test:
+    uv run pytest -q
+
+# Run tests verbosely
+testv:
+    uv run pytest -v
+
+# Run a single test file or node id, e.g. `just test-one tests/test_api.py`
+test-one target:
+    uv run pytest -v {{target}}
+
+# Run tests with a coverage report
+cov:
+    uv run pytest --cov=browser_cli --cov-report=term-missing
+
+# ── Extension (TypeScript / MV3) ───────────────────────────────────────
+
+# Build the extension bundle (extension/background.js)
+build:
+    npm run build:extension
+
+# Run the JS (node:test) extension tests
+test-ext:
+    npm run test:extension
+
+# Full extension gate: tsc + build + node --check + JS tests
+check:
+    npm run check:extension
+
+# ── Everything ─────────────────────────────────────────────────────────
+
+# Run the complete gate: extension check + Python tests
+ci: check test
+
+# ── Release ────────────────────────────────────────────────────────────
+
+# Show the current version
+version:
+    @grep -m1 '^version' pyproject.toml | cut -d'"' -f2
+
+# Bump version in pyproject.toml AND extension/manifest.json, e.g. `just bump 0.10.5`
+bump new:
+    sed -i 's/^version = ".*"/version = "{{new}}"/' pyproject.toml
+    sed -i 's/"version": ".*"/"version": "{{new}}"/' extension/manifest.json
+    @echo "bumped to {{new}} — remember to update uv.lock (uv lock) and rebuild the extension"
+
+# Verify both version files agree
+version-check:
+    @py=$(grep -m1 '^version' pyproject.toml | cut -d'"' -f2); \
+     ext=$(grep -m1 '"version"' extension/manifest.json | cut -d'"' -f4); \
+     if [ "$py" = "$ext" ]; then echo "ok: $py"; else echo "MISMATCH pyproject=$py manifest=$ext"; exit 1; fi
+
+# ── Demos ──────────────────────────────────────────────────────────────
+
+# Run the Python SDK demo
+demo:
+    uv run python examples/demo.py
diff --git a/pyproject.toml b/pyproject.toml
index 116f09e..7005a6d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,19 @@
 [project]
 name = "browser-cli"
-version = "0.10.4"
+version = "0.12.0"
 description = "Control your real running browser from the terminal or Python SDK"
 requires-python = ">=3.10"
 dependencies = [
     "click>=8",
     "cryptography>=48",
     "rich>=13",
+    "msgpack>=1",
 ]
 
+[project.optional-dependencies]
+# Better/faster remote response compression than the stdlib zlib/gzip fallback.
+fast = ["zstandard>=0.22"]
+
 [project.scripts]
 browser-cli = "browser_cli.cli:main"
 
@@ -16,6 +21,7 @@ browser-cli = "browser_cli.cli:main"
 dev = [
     "pytest>=8",
     "pytest-cov>=7.1.0",
+    "zstandard>=0.22",
 ]
 
 [build-system]
diff --git a/tests/test_api.py b/tests/test_api.py
index e497afd..789561d 100644
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -1,6 +1,7 @@
-"""Unit tests for the BrowserCLI Python API (BrowserCLI, Tab, Group).
+"""Unit tests for the BrowserCLI Python SDK (BrowserCLI, namespaces, Tab, Group).
 
 These tests mock `send_command` so no live browser connection is required.
+Commands live on namespace accessors: b.tabs.list(), b.dom.click(), b.groups.create(), ...
 """
 import pytest
 from unittest.mock import MagicMock, patch, call
@@ -29,7 +30,6 @@ GROUP_DATA = {
     "tabCount": 3,
 }
 
-
 @pytest.fixture()
 def mock_send():
     """Patch send_command for the duration of one test.
@@ -40,19 +40,16 @@ def mock_send():
     with patch("browser_cli.send_command") as m, patch("browser_cli.active_browser_targets", return_value=[]):
         yield m
 
-
 @pytest.fixture()
 def b(mock_send):
     """A BrowserCLI instance with send_command mocked."""
     return BrowserCLI()
 
-
 @pytest.fixture()
 def b_profile(mock_send):
     """A BrowserCLI instance targeting a specific profile."""
     return BrowserCLI(browser="brave")
 
-
 # ── BrowserCLI construction ───────────────────────────────────────────────────
 
 class TestBrowserCLIInit:
@@ -75,6 +72,14 @@ class TestBrowserCLIInit:
         assert b.remote == "browser-host.example:443"
         assert b.key == "agent"
 
+    def test_namespaces_present_and_bound(self):
+        b = BrowserCLI()
+        for name in ("nav", "tabs", "groups", "windows", "dom", "extract",
+                     "page", "storage", "cookies", "session", "perf", "extension"):
+            ns = getattr(b, name)
+            assert ns is not None
+            assert ns._c is b
+
     def test_raw_command_escape_hatch(self, mock_send):
         mock_send.return_value = {"ok": True}
         b = BrowserCLI(browser="work", remote="browser-host.example:443", key="agent")
@@ -94,7 +99,6 @@ class TestBrowserCLIInit:
         b.command("custom.command")
         mock_send.assert_called_once_with("custom.command", {}, profile=None, remote=None, key=None)
 
-
 # ── Internal factories ────────────────────────────────────────────────────────
 
 class TestMakeTab:
@@ -144,12 +148,11 @@ class TestMakeGroup:
         assert group.collapsed is False
         assert group.tab_count == 0
 
-
 # ── Navigation ────────────────────────────────────────────────────────────────
 
 class TestNavigation:
     def test_open(self, b, mock_send):
-        b.open("https://example.com")
+        b.nav.open("https://example.com")
         mock_send.assert_called_once_with(
             "navigate.open",
             {"url": "https://example.com", "background": False, "window": None, "group": None},
@@ -157,18 +160,18 @@ class TestNavigation:
         )
 
     def test_open_background(self, b, mock_send):
-        b.open("https://example.com", background=True)
+        b.nav.open("https://example.com", background=True)
         args = mock_send.call_args[0]
         assert args[1]["background"] is True
 
     def test_open_with_group(self, b, mock_send):
-        b.open("https://x.com", group="Work")
+        b.nav.open("https://x.com", group="Work")
         assert mock_send.call_args[0][1]["group"] == "Work"
 
-    def test_open_tab_returns_bound_tab(self, b, mock_send):
+    def test_tabs_open_returns_bound_tab(self, b, mock_send):
         mock_send.return_value = {"id": 123, "url": "https://example.com"}
 
-        tab = b.open_tab("https://example.com", background=True)
+        tab = b.tabs.open("https://example.com", background=True)
 
         assert tab.id == 123
         assert tab.url == "https://example.com"
@@ -181,10 +184,10 @@ class TestNavigation:
             key=None,
         )
 
-    def test_open_tab_wait_uses_open_wait(self, b, mock_send):
+    def test_tabs_open_wait_uses_open_wait(self, b, mock_send):
         mock_send.return_value = TAB_DATA
 
-        tab = b.open_tab("https://example.com", wait=True, timeout=1.5)
+        tab = b.tabs.open("https://example.com", wait=True, timeout=1.5)
 
         assert tab.id == 10
         mock_send.assert_called_once_with(
@@ -195,185 +198,199 @@ class TestNavigation:
             key=None,
         )
 
-    def test_open_tab_unexpected_response_raises(self, b, mock_send):
+    def test_tabs_open_unexpected_response_raises(self, b, mock_send):
         mock_send.return_value = None
         with pytest.raises(RuntimeError, match="navigate.open returned unexpected data"):
-            b.open_tab("https://example.com")
+            b.tabs.open("https://example.com")
+
+    def test_nav_open_wait_unexpected_response_raises(self, b, mock_send):
+        mock_send.return_value = None
+        with pytest.raises(RuntimeError, match="navigate.open_wait returned unexpected data"):
+            b.nav.open_wait("https://example.com")
 
     def test_reload(self, b, mock_send):
-        b.reload(tab_id=5)
+        b.nav.reload(tab_id=5)
         mock_send.assert_called_once_with("navigate.reload", {"tabId": 5}, profile=None, remote=None, key=None)
 
     def test_hard_reload(self, b, mock_send):
-        b.hard_reload(tab_id=7)
+        b.nav.hard_reload(tab_id=7)
         mock_send.assert_called_once_with("navigate.hard_reload", {"tabId": 7}, profile=None, remote=None, key=None)
 
     def test_back(self, b, mock_send):
-        b.back(tab_id=3)
+        b.nav.back(tab_id=3)
         mock_send.assert_called_once_with("navigate.back", {"tabId": 3}, profile=None, remote=None, key=None)
 
     def test_forward(self, b, mock_send):
-        b.forward(tab_id=3)
+        b.nav.forward(tab_id=3)
         mock_send.assert_called_once_with("navigate.forward", {"tabId": 3}, profile=None, remote=None, key=None)
 
-    def test_focus_url(self, b, mock_send):
-        b.focus_url("github.com")
+    def test_focus(self, b, mock_send):
+        b.nav.focus("github.com")
         mock_send.assert_called_once_with("navigate.focus", {"pattern": "github.com"}, profile=None, remote=None, key=None)
 
-    def test_navigate_tab(self, b, mock_send):
-        b.navigate_tab(5, "https://example.com")
+    def test_nav_to(self, b, mock_send):
+        b.nav.to(5, "https://example.com")
         mock_send.assert_called_once_with(
             "navigate.to", {"tabId": 5, "url": "https://example.com"}, profile=None, remote=None, key=None
         )
 
     def test_profile_forwarded(self, b_profile, mock_send):
-        b_profile.reload()
+        b_profile.nav.reload()
         mock_send.assert_called_once_with("navigate.reload", {"tabId": None}, profile="brave", remote=None, key=None)
 
     def test_remote_forwarded(self, mock_send):
         b = BrowserCLI(browser="work", remote="host:8765", key=None)
-        b.reload()
+        b.nav.reload()
         mock_send.assert_called_once_with("navigate.reload", {"tabId": None}, profile="work", remote="host:8765", key=None)
 
-
 # ── Search ────────────────────────────────────────────────────────────────────
 
 class TestSearch:
     def test_known_engine_builds_url(self, b, mock_send):
-        b.search("google", "python asyncio")
+        b.nav.search("google", "python asyncio")
         call_args = mock_send.call_args[0]
         assert call_args[0] == "navigate.open"
-        assert "python+asyncio" in call_args[1]["url"] or "python%20asyncio" in call_args[1]["url"] or "python+asyncio" in call_args[1]["url"]
+        assert "python+asyncio" in call_args[1]["url"] or "python%20asyncio" in call_args[1]["url"]
 
     def test_unknown_engine_raises(self, b):
         with pytest.raises(ValueError, match="Unknown search engine"):
-            b.search("nonexistent", "query")
+            b.nav.search("nonexistent", "query")
 
     def test_search_alias_ddg(self, b, mock_send):
-        b.search("ddg", "hello")
+        b.nav.search("ddg", "hello")
         url = mock_send.call_args[0][1]["url"]
         assert "duckduckgo.com" in url
 
     def test_search_background(self, b, mock_send):
-        b.search("bing", "test", background=True)
+        b.nav.search("bing", "test", background=True)
         assert mock_send.call_args[0][1]["background"] is True
 
+# ── Extract ───────────────────────────────────────────────────────────────────
 
 class TestExtract:
     def test_extract_markdown_default(self, b, mock_send):
         mock_send.return_value = "# Title"
 
-        result = b.extract_markdown()
+        result = b.extract.markdown()
 
         assert result == "# Title"
         mock_send.assert_called_once_with("extract.markdown", {"selector": None}, profile=None, remote=None, key=None)
 
     def test_extract_markdown_selector(self, b, mock_send):
-        b.extract_markdown("article")
+        mock_send.return_value = "## Post"
 
+        assert b.extract.markdown("article") == "## Post"
         mock_send.assert_called_once_with("extract.markdown", {"selector": "article"}, profile=None, remote=None, key=None)
 
+    def test_extract_links(self, b, mock_send):
+        mock_send.return_value = [{"href": "https://x"}]
+        assert b.extract.links() == [{"href": "https://x"}]
+        mock_send.assert_called_once_with("extract.links", {}, profile=None, remote=None, key=None)
+
+    def test_extract_text_none(self, b, mock_send):
+        mock_send.return_value = None
+        assert b.extract.text() == ""
 
 # ── Tabs ──────────────────────────────────────────────────────────────────────
 
 class TestTabs:
     def test_tabs_list_returns_tab_objects(self, b, mock_send):
         mock_send.return_value = [TAB_DATA]
-        tabs = b.tabs_list()
+        tabs = b.tabs.list()
         assert len(tabs) == 1
         assert isinstance(tabs[0], Tab)
         assert tabs[0].id == 10
 
     def test_tabs_list_empty(self, b, mock_send):
         mock_send.return_value = []
-        assert b.tabs_list() == []
+        assert b.tabs.list() == []
 
     def test_tabs_list_none_response(self, b, mock_send):
         mock_send.return_value = None
-        assert b.tabs_list() == []
+        assert b.tabs.list() == []
 
     def test_tabs_close_returns_count(self, b, mock_send):
         mock_send.return_value = {"closed": 3}
-        assert b.tabs_close() == 3
+        assert b.tabs.close() == 3
 
     def test_tabs_close_non_dict_response(self, b, mock_send):
         mock_send.return_value = None
-        assert b.tabs_close() == 1
+        assert b.tabs.close() == 1
 
     def test_tabs_close_by_id(self, b, mock_send):
         mock_send.return_value = {"closed": 1}
-        b.tabs_close(tab_id=10)
+        b.tabs.close(tab_id=10)
         mock_send.assert_called_once_with(
             "tabs.close",
-            {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False},
+            {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"},
             profile=None, remote=None, key=None,
         )
 
     def test_tabs_close_by_ids(self, b, mock_send):
         mock_send.return_value = {"closed": 3}
-        assert b.tabs_close(tab_ids=[10, 20, 30]) == 3
+        assert b.tabs.close(tab_ids=[10, 20, 30]) == 3
         mock_send.assert_called_once_with(
             "tabs.close",
-            {"tabId": None, "tabIds": [10, 20, 30], "inactive": False, "duplicates": False},
+            {"tabId": None, "tabIds": [10, 20, 30], "inactive": False, "duplicates": False, "gentleMode": "auto"},
             profile=None, remote=None, key=None,
         )
 
     def test_tabs_close_by_ids_accepts_tab_objects(self, b, mock_send):
         tabs = [b._make_tab({**TAB_DATA, "id": 10}), b._make_tab({**TAB_DATA, "id": 20})]
         mock_send.return_value = {"closed": 2}
-        assert b.tabs_close(tab_ids=tabs) == 2
+        assert b.tabs.close(tab_ids=tabs) == 2
         mock_send.assert_called_once_with(
             "tabs.close",
-            {"tabId": None, "tabIds": [10, 20], "inactive": False, "duplicates": False},
+            {"tabId": None, "tabIds": [10, 20], "inactive": False, "duplicates": False, "gentleMode": "auto"},
             profile=None, remote=None, key=None,
         )
 
     def test_tabs_move(self, b, mock_send):
-        b.tabs_move(10, forward=True)
+        b.tabs.move(10, forward=True)
         mock_send.assert_called_once_with(
             "tabs.move",
             {"tabId": 10, "forward": True, "backward": False, "groupId": None, "windowId": None, "index": None},
             profile=None, remote=None, key=None,
         )
 
-    def test_tabs_active(self, b, mock_send):
-        b.tabs_active(10)
+    def test_tabs_activate(self, b, mock_send):
+        b.tabs.activate(10)
         mock_send.assert_called_once_with("tabs.active", {"tabId": 10}, profile=None, remote=None, key=None)
 
-    def test_window_active_tab(self, b, mock_send):
+    def test_tabs_active_in_window(self, b, mock_send):
         mock_send.return_value = TAB_DATA
-        tab = b.window_active_tab(1)
+        tab = b.tabs.active_in_window(1)
         assert isinstance(tab, Tab)
         assert tab.id == 10
         mock_send.assert_called_once_with("tabs.active_in_window", {"windowId": 1}, profile=None, remote=None, key=None)
 
-    def test_window_active_tab_missing_raises(self, b, mock_send):
+    def test_tabs_active_in_window_missing_raises(self, b, mock_send):
         mock_send.return_value = None
         with pytest.raises(RuntimeError, match="No active tab found for window 1"):
-            b.window_active_tab(1)
+            b.tabs.active_in_window(1)
 
     def test_tabs_filter(self, b, mock_send):
         mock_send.return_value = [TAB_DATA]
-        tabs = b.tabs_filter("example")
+        tabs = b.tabs.filter("example")
         assert isinstance(tabs[0], Tab)
 
     def test_tabs_filter_none(self, b, mock_send):
         mock_send.return_value = None
-        assert b.tabs_filter("x") == []
+        assert b.tabs.filter("x") == []
 
     def test_tabs_filter_predicate(self, b, mock_send):
         mock_send.return_value = [TAB_DATA, {**TAB_DATA, "id": 11, "url": "https://youtube.com"}]
-        tabs = b.tabs_filter(lambda tab: "youtube" in tab.url)
+        tabs = b.tabs.filter(lambda tab: "youtube" in tab.url)
         assert [tab.id for tab in tabs] == [11]
 
     def test_tabs_filter_list_transformer(self, b, mock_send):
         mock_send.return_value = [TAB_DATA, {**TAB_DATA, "id": 11, "url": "https://example.com"}]
-        tabs = b.tabs_filter(lambda tabs: tabs[:1])
+        tabs = b.tabs.filter(lambda tabs: tabs[:1])
         assert [tab.id for tab in tabs] == [10]
 
     def test_tabs_count(self, b, mock_send):
         mock_send.return_value = 5
-        assert b.tabs_count() == 5
+        assert b.tabs.count() == 5
 
     def test_tabs_list_multi_browser_annotates_browser_and_binds_actions(self, b, mock_send):
         with patch(
@@ -389,7 +406,7 @@ class TestTabs:
                 None,
             ]
 
-            tabs = b.tabs_list()
+            tabs = b.tabs.list()
             tabs[1].close()
 
         assert [tab.browser for tab in tabs] == ["uuid-1", "work"]
@@ -410,7 +427,7 @@ class TestTabs:
             return_value=[BrowserTarget("work", "host:work", "", remote="host:8765")],
         ):
             mock_send.side_effect = [[TAB_DATA], None]
-            tabs = b.tabs_list()
+            tabs = b.tabs.list()
             tabs[0].close()
 
         assert [tab.browser for tab in tabs] == ["host:work"]
@@ -426,7 +443,7 @@ class TestTabs:
             return_value=[BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example")],
         ):
             mock_send.side_effect = [[TAB_DATA], None]
-            tabs = b.tabs_list()
+            tabs = b.tabs.list()
             tabs[0].close()
 
         assert mock_send.call_args_list == [
@@ -434,11 +451,11 @@ class TestTabs:
             call("tabs.close", {"tabId": 10}, profile="work", remote="browser-host.example", key="agent"),
         ]
 
-    def test_tabs_alias_and_active_tab(self, b, mock_send):
+    def test_tabs_active_returns_active_tab(self, b, mock_send):
         mock_send.side_effect = [[TAB_DATA], TAB_DATA]
 
-        tabs = b.tabs()
-        active = b.active_tab()
+        tabs = b.tabs.list()
+        active = b.tabs.active()
 
         assert tabs[0].id == 10
         assert active.id == 10
@@ -447,14 +464,14 @@ class TestTabs:
             call("tabs.status", {"tabId": None}, profile=None, remote=None, key=None),
         ]
 
-    def test_tab_find_and_close_helpers(self, b, mock_send):
+    def test_tabs_get_first_and_close_helpers(self, b, mock_send):
         mock_send.side_effect = [TAB_DATA, [TAB_DATA], [], {"closed": 1}, {"closed": 1}]
 
-        tab = b.tab(10)
-        found = b.find_tab("Example")
-        missing = b.find_tab("Missing")
-        closed_by_object = b.close_tab(tab)
-        closed_by_id = b.close_tab(10)
+        tab = b.tabs.get(10)
+        found = b.tabs.first("Example")
+        missing = b.tabs.first("Missing")
+        closed_by_object = b.tabs.close(tab.id)
+        closed_by_id = b.tabs.close(10)
 
         assert tab.id == 10
         assert found and found.id == 10
@@ -465,18 +482,10 @@ class TestTabs:
             call("tabs.status", {"tabId": 10}, profile=None, remote=None, key=None),
             call("tabs.query", {"search": "Example"}, profile=None, remote=None, key=None),
             call("tabs.query", {"search": "Missing"}, profile=None, remote=None, key=None),
-            call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False}, profile=None, remote=None, key=None),
-            call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False}, profile=None, remote=None, key=None),
+            call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}, profile=None, remote=None, key=None),
+            call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}, profile=None, remote=None, key=None),
         ]
 
-    def test_find_tabs_alias(self, b, mock_send):
-        mock_send.return_value = [TAB_DATA]
-
-        tabs = b.find_tabs("Example")
-
-        assert [tab.id for tab in tabs] == [10]
-        mock_send.assert_called_once_with("tabs.query", {"search": "Example"}, profile=None, remote=None, key=None)
-
     def test_tabs_count_multi_browser_returns_browser_counts(self, b, mock_send):
         with patch(
             "browser_cli.active_browser_targets",
@@ -486,7 +495,7 @@ class TestTabs:
             ],
         ):
             mock_send.side_effect = [3, 4]
-            result = b.tabs_count("github")
+            result = b.tabs.count("github")
 
         assert result == BrowserCounts(total=7, by_browser={"uuid-1": 3, "work": 4})
         assert mock_send.call_args_list == [
@@ -496,65 +505,81 @@ class TestTabs:
 
     def test_tabs_query(self, b, mock_send):
         mock_send.return_value = [TAB_DATA]
-        result = b.tabs_query("example")
+        result = b.tabs.query("example")
         assert isinstance(result[0], Tab)
+        mock_send.assert_called_once_with("tabs.query", {"search": "example"}, profile=None, remote=None, key=None)
 
     def test_tabs_html(self, b, mock_send):
         mock_send.return_value = "<html></html>"
-        assert b.tabs_html(10) == "<html></html>"
+        assert b.tabs.html(10) == "<html></html>"
 
     def test_tabs_html_none(self, b, mock_send):
         mock_send.return_value = None
-        assert b.tabs_html() == ""
+        assert b.tabs.html() == ""
 
     def test_tabs_dedupe(self, b, mock_send):
         mock_send.return_value = {"closed": 2}
-        assert b.tabs_dedupe() == 2
+        assert b.tabs.dedupe() == 2
 
     def test_tabs_dedupe_non_dict(self, b, mock_send):
         mock_send.return_value = None
-        assert b.tabs_dedupe() == 0
+        assert b.tabs.dedupe() == 0
 
     def test_tabs_sort(self, b, mock_send):
-        b.tabs_sort(by="title")
-        mock_send.assert_called_once_with("tabs.sort", {"by": "title"}, profile=None, remote=None, key=None)
+        b.tabs.sort(by="title")
+        mock_send.assert_called_once_with("tabs.sort", {"by": "title", "gentleMode": "auto"}, profile=None, remote=None, key=None)
 
     def test_tabs_merge_windows(self, b, mock_send):
         mock_send.return_value = {"moved": 4}
-        assert b.tabs_merge_windows() == 4
+        assert b.tabs.merge_windows() == 4
 
     def test_tabs_close_inactive(self, b, mock_send):
         mock_send.return_value = {"closed": 2}
-        assert b.tabs_close_inactive() == 2
+        assert b.tabs.close_inactive() == 2
 
     def test_tabs_close_duplicates(self, b, mock_send):
         mock_send.return_value = {"closed": 1}
-        assert b.tabs_close_duplicates() == 1
+        assert b.tabs.close_duplicates() == 1
 
+    def test_tabs_mute_pin_return_tab_id(self, b, mock_send):
+        mock_send.side_effect = [{"tabId": 10}, None]
+        assert b.tabs.mute(10) == 10
+        assert b.tabs.pin() == 0
+        assert mock_send.call_args_list == [
+            call("tabs.mute", {"tabId": 10}, profile=None, remote=None, key=None),
+            call("tabs.pin", {"tabId": None}, profile=None, remote=None, key=None),
+        ]
+
+    def test_tabs_screenshot(self, b, mock_send):
+        mock_send.return_value = {"dataUrl": "data:image/png;base64,abc"}
+        assert b.tabs.screenshot(10) == "data:image/png;base64,abc"
+        mock_send.assert_called_once_with(
+            "tabs.screenshot", {"tabId": 10, "format": "png", "quality": None}, profile=None, remote=None, key=None
+        )
 
 # ── Groups ────────────────────────────────────────────────────────────────────
 
 class TestGroups:
     def test_group_list_returns_group_objects(self, b, mock_send):
         mock_send.return_value = [GROUP_DATA]
-        groups = b.group_list()
+        groups = b.groups.list()
         assert len(groups) == 1
         assert isinstance(groups[0], Group)
         assert groups[0].id == 42
 
     def test_group_list_empty(self, b, mock_send):
         mock_send.return_value = None
-        assert b.group_list() == []
+        assert b.groups.list() == []
 
     def test_group_tabs(self, b, mock_send):
         mock_send.return_value = [TAB_DATA]
-        tabs = b.group_tabs(42)
+        tabs = b.groups.tabs(42)
         assert isinstance(tabs[0], Tab)
         mock_send.assert_called_once_with("group.tabs", {"groupId": 42}, profile=None, remote=None, key=None)
 
     def test_group_count(self, b, mock_send):
         mock_send.return_value = 7
-        assert b.group_count() == 7
+        assert b.groups.count() == 7
 
     def test_group_list_multi_browser_annotates_browser_and_binds_actions(self, b, mock_send):
         with patch(
@@ -570,7 +595,7 @@ class TestGroups:
                 None,
             ]
 
-            groups = b.group_list()
+            groups = b.groups.list()
             groups[1].close()
 
         assert [group.browser for group in groups] == ["uuid-1", "work"]
@@ -591,7 +616,7 @@ class TestGroups:
             return_value=[BrowserTarget("work", "host:work", "", remote="host:8765")],
         ):
             mock_send.side_effect = [[GROUP_DATA], None]
-            groups = b.group_list()
+            groups = b.groups.list()
             groups[0].close()
 
         assert [group.browser for group in groups] == ["host:work"]
@@ -607,7 +632,7 @@ class TestGroups:
             return_value=[BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example")],
         ):
             mock_send.side_effect = [[GROUP_DATA], None]
-            groups = b.group_list()
+            groups = b.groups.list()
             groups[0].close()
 
         assert mock_send.call_args_list == [
@@ -615,25 +640,6 @@ class TestGroups:
             call("group.close", {"groupId": 42}, profile="work", remote="browser-host.example", key="agent"),
         ]
 
-    def test_group_aliases(self, b, mock_send):
-        mock_send.side_effect = [[GROUP_DATA], [GROUP_DATA], 1, [GROUP_DATA], GROUP_DATA, GROUP_DATA]
-
-        assert b.groups()[0].id == 42
-        assert b.groups_list()[0].id == 42
-        assert b.groups_count() == 1
-        assert b.groups_query("Work")[0].id == 42
-        assert b.groups_create("Work").id == 42
-        assert b.group_open("Work").id == 42
-
-        assert mock_send.call_args_list == [
-            call("group.list", {}, profile=None, remote=None, key=None),
-            call("group.list", {}, profile=None, remote=None, key=None),
-            call("group.count", {}, profile=None, remote=None, key=None),
-            call("group.query", {"search": "Work"}, profile=None, remote=None, key=None),
-            call("group.open", {"name": "Work"}, profile=None, remote=None, key=None),
-            call("group.open", {"name": "Work"}, profile=None, remote=None, key=None),
-        ]
-
     def test_group_count_multi_browser_returns_browser_counts(self, b, mock_send):
         with patch(
             "browser_cli.active_browser_targets",
@@ -643,35 +649,36 @@ class TestGroups:
             ],
         ):
             mock_send.side_effect = [2, 5]
-            result = b.group_count()
+            result = b.groups.count()
 
         assert result == BrowserCounts(total=7, by_browser={"uuid-1": 2, "work": 5})
 
     def test_group_query(self, b, mock_send):
         mock_send.return_value = [GROUP_DATA]
-        groups = b.group_query("Work")
+        groups = b.groups.query("Work")
         assert isinstance(groups[0], Group)
+        mock_send.assert_called_once_with("group.query", {"search": "Work"}, profile=None, remote=None, key=None)
 
     def test_group_close(self, b, mock_send):
-        b.group_close(42)
-        mock_send.assert_called_once_with("group.close", {"groupId": 42}, profile=None, remote=None, key=None)
+        b.groups.close(42)
+        mock_send.assert_called_once_with("group.close", {"groupId": 42, "gentleMode": "auto"}, profile=None, remote=None, key=None)
 
     def test_group_create_dict_response(self, b, mock_send):
         mock_send.return_value = GROUP_DATA
-        group = b.group_create("Work")
+        group = b.groups.create("Work")
         assert isinstance(group, Group)
         assert group.id == 42
         assert group.title == "Work"
 
     def test_group_create_int_response(self, b, mock_send):
         mock_send.return_value = 99
-        group = b.group_create("Misc")
+        group = b.groups.create("Misc")
         assert group.id == 99
         assert group.title == "Misc"
 
     def test_group_add_tab(self, b, mock_send):
         mock_send.return_value = {"tabId": 55}
-        tab_id = b.group_add_tab(42, "https://example.com")
+        tab_id = b.groups.add_tab(42, "https://example.com")
         assert tab_id == 55
         mock_send.assert_called_once_with(
             "group.add_tab", {"group": "42", "url": "https://example.com"}, profile=None, remote=None, key=None
@@ -679,15 +686,14 @@ class TestGroups:
 
     def test_group_add_tab_non_dict_response(self, b, mock_send):
         mock_send.return_value = 55
-        assert b.group_add_tab(42) == 55
+        assert b.groups.add_tab(42) == 55
 
     def test_group_move_forward(self, b, mock_send):
-        b.group_move(42, forward=True)
+        b.groups.move(42, forward=True)
         mock_send.assert_called_once_with(
             "group.move", {"group": "42", "forward": True, "backward": False}, profile=None, remote=None, key=None
         )
 
-
 class TestWindows:
     def test_windows_list_multi_browser_adds_browser(self, b, mock_send):
         with patch(
@@ -701,7 +707,7 @@ class TestWindows:
                 [{"id": 1, "tabCount": 2, "state": "normal"}],
                 [{"id": 2, "tabCount": 3, "state": "maximized"}],
             ]
-            result = b.windows_list()
+            result = b.windows.list()
 
         assert result == [
             {"id": 1, "tabCount": 2, "state": "normal", "browser": "uuid-1"},
@@ -711,7 +717,7 @@ class TestWindows:
     def test_windows_open_without_url(self, b, mock_send):
         mock_send.return_value = {"id": 5}
 
-        result = b.windows_open()
+        result = b.windows.open()
 
         assert result == {"id": 5}
         mock_send.assert_called_once_with("windows.open", {"url": None}, profile=None, remote=None, key=None)
@@ -719,17 +725,32 @@ class TestWindows:
     def test_windows_open_with_url(self, b, mock_send):
         mock_send.return_value = {"id": 9}
 
-        result = b.windows_open("https://example.com")
+        result = b.windows.open("https://example.com")
 
         assert result == {"id": 9}
         mock_send.assert_called_once_with("windows.open", {"url": "https://example.com"}, profile=None, remote=None, key=None)
 
+class TestDom:
+    def test_dom_click(self, b, mock_send):
+        b.dom.click("#go")
+        mock_send.assert_called_once_with("dom.click", {"selector": "#go"}, profile=None, remote=None, key=None)
 
-class TestDomConvenience:
-    def test_wait_for_selector_alias(self, b, mock_send):
+    def test_dom_type(self, b, mock_send):
+        b.dom.type("#in", "hello")
+        mock_send.assert_called_once_with("dom.type", {"selector": "#in", "text": "hello"}, profile=None, remote=None, key=None)
+
+    def test_dom_query_none(self, b, mock_send):
+        mock_send.return_value = None
+        assert b.dom.query("a") == []
+
+    def test_dom_exists_falsy(self, b, mock_send):
+        mock_send.return_value = None
+        assert b.dom.exists("a") is False
+
+    def test_dom_wait_for(self, b, mock_send):
         mock_send.return_value = {"selector": "#done", "found": True}
 
-        result = b.wait_for_selector("#done", timeout=2.5, visible=True, tab_id=10)
+        result = b.dom.wait_for("#done", timeout=2.5, visible=True, tab_id=10)
 
         assert result == {"selector": "#done", "found": True}
         mock_send.assert_called_once_with(
@@ -740,12 +761,78 @@ class TestDomConvenience:
             key=None,
         )
 
+    def test_dom_eval(self, b, mock_send):
+        mock_send.return_value = 42
+        assert b.dom.eval("1+41", tab_id=3) == 42
+        mock_send.assert_called_once_with("dom.eval", {"code": "1+41", "tabId": 3}, profile=None, remote=None, key=None)
+
+class TestPageStorageCookies:
+    def test_page_info(self, b, mock_send):
+        mock_send.return_value = {"title": "X"}
+        assert b.page.info() == {"title": "X"}
+        mock_send.assert_called_once_with("page.info", {}, profile=None, remote=None, key=None)
+
+    def test_storage_get(self, b, mock_send):
+        mock_send.return_value = "v"
+        assert b.storage.get("k") == "v"
+        mock_send.assert_called_once_with("storage.get", {"key": "k", "type": "local", "tabId": None}, profile=None, remote=None, key=None)
+
+    def test_storage_set(self, b, mock_send):
+        b.storage.set("k", "v", type="session")
+        mock_send.assert_called_once_with(
+            "storage.set", {"key": "k", "value": "v", "type": "session", "tabId": None}, profile=None, remote=None, key=None
+        )
+
+    def test_cookies_list(self, b, mock_send):
+        mock_send.return_value = [{"name": "c"}]
+        assert b.cookies.list(domain="example.com") == [{"name": "c"}]
+        mock_send.assert_called_once_with(
+            "cookies.list", {"url": None, "domain": "example.com", "name": None}, profile=None, remote=None, key=None
+        )
+
+class TestPerf:
+    def test_perf_status(self, b, mock_send):
+        mock_send.return_value = {"profile": "auto"}
+        assert b.perf.status() == {"profile": "auto"}
+        mock_send.assert_called_once_with("perf.status", {}, profile=None, remote=None, key=None)
+
+    def test_perf_set_profile(self, b, mock_send):
+        mock_send.return_value = {"profile": "gentle"}
+        assert b.perf.set_profile("gentle") == {"profile": "gentle"}
+        mock_send.assert_called_once_with("perf.set_profile", {"profile": "gentle"}, profile=None, remote=None, key=None)
+
+    def test_perf_job_status(self, b, mock_send):
+        mock_send.return_value = {"phase": "done"}
+        assert b.perf.job_status("j1") == {"phase": "done"}
+        mock_send.assert_called_once_with("jobs.status", {"jobId": "j1"}, profile=None, remote=None, key=None)
+
+class TestExtension:
+    def test_extension_reload(self, b, mock_send):
+        b.extension.reload()
+        mock_send.assert_called_once_with("extension.reload", {}, profile=None, remote=None, key=None)
 
 class TestSession:
+    def test_session_save(self, b, mock_send):
+        b.session.save("work")
+        mock_send.assert_called_once_with("session.save", {"name": "work"}, profile=None, remote=None, key=None)
+
+    def test_session_load(self, b, mock_send):
+        b.session.load("work")
+        mock_send.assert_called_once_with(
+            "session.load",
+            {"name": "work", "gentleMode": "auto", "discardBackgroundTabs": False, "lazy": False, "eagerTabs": 10},
+            profile=None, remote=None, key=None,
+        )
+
+    def test_session_load_background(self, b, mock_send):
+        mock_send.return_value = {"jobId": "j1"}
+        assert b.session.load_background("work") == {"jobId": "j1"}
+        assert mock_send.call_args[0][1]["__background"] is True
+
     def test_session_list(self, b, mock_send):
         mock_send.return_value = [{"name": "saved", "tabs": 3, "savedAt": 1712707200000}]
 
-        result = b.session_list()
+        result = b.session.list()
 
         assert result == [{"name": "saved", "tabs": 3, "savedAt": 1712707200000}]
         mock_send.assert_called_once_with("session.list", {}, profile=None, remote=None, key=None)
@@ -762,7 +849,7 @@ class TestSession:
                 [{"name": "first", "tabs": 2, "savedAt": 1712707200000}],
                 [{"name": "second", "tabs": 5, "savedAt": 1712707300000}],
             ]
-            result = b.session_list()
+            result = b.session.list()
 
         assert result == [
             {"name": "first", "tabs": 2, "savedAt": 1712707200000, "browser": "uuid-1"},
@@ -863,7 +950,6 @@ class TestTabModel:
         with pytest.raises(RuntimeError, match="not bound"):
             tab.close()
 
-
 # ── Group model ───────────────────────────────────────────────────────────────
 
 class TestGroupModel:
diff --git a/tests/test_cli.py b/tests/test_cli.py
index b4c585f..9c6ed3b 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -79,7 +79,6 @@ def test_install_help_lists_supported_browsers():
     assert result.exit_code == 0
     assert "[chrome|chromium|brave|edge|vivaldi]" in result.output
 
-
 def test_install_windows_registers_native_host(tmp_path):
     writes = []
 
@@ -125,7 +124,6 @@ def test_write_native_host_exe_unix(tmp_path):
     assert "from browser_cli.native_host import main" in content
     assert host.stat().st_mode & 0o111  # executable bit set
 
-
 def test_write_native_host_exe_windows(tmp_path):
     from browser_cli.cli import _write_native_host_exe
 
@@ -138,7 +136,6 @@ def test_write_native_host_exe_windows(tmp_path):
     assert "@echo off" in content
     assert "browser_cli.native_host" in content
 
-
 def test_clients_exits_cleanly_when_registry_is_missing():
     with patch("browser_cli.cli.REGISTRY_PATH", Path("/nonexistent/browser-cli-registry.json")), patch(
         "browser_cli.cli.active_browser_targets", return_value=[]
@@ -148,12 +145,11 @@ def test_clients_exits_cleanly_when_registry_is_missing():
     assert result.exit_code == 1
     assert "No browser clients found" in result.output
 
-
 def test_clients_reads_registry_with_trailing_garbage(tmp_path):
     registry_path = tmp_path / "registry.json"
     registry_path.write_text('{"main": "/tmp/.browser_cli/main.sock"}"}', encoding="utf-8")
 
-    def fake_send_command(command, args=None, profile=None):
+    def fake_send_command(command, args=None, profile=None, remote=None, key=None):
         assert command == "clients.list"
         assert profile == "main"
         return [{"profile": "main", "name": "Chrome", "version": "1", "extensionVersion": "0.8.2"}]
@@ -185,7 +181,6 @@ def test_clients_remote_uses_remote_endpoint_without_local_registry():
     assert "Chrome" in result.output
     assert "2.3.4" in result.output
 
-
 def test_clients_remote_respects_global_browser_route():
     with patch.dict(os.environ, {}, clear=True), patch("browser_cli.cli.send_command", return_value=[]) as send_command:
         result = CliRunner().invoke(main, ["--remote", "127.0.0.1:8765", "--browser", "work", "clients"])
@@ -193,7 +188,6 @@ def test_clients_remote_respects_global_browser_route():
     assert result.exit_code == 1
     send_command.assert_called_once_with("clients.list", profile="work", remote="127.0.0.1:8765", key=None)
 
-
 def test_clients_browser_alias_resolves_to_remote():
     """--browser <host> without --remote resolves the alias, fetches all targets from that remote,
     and shows only clients from that host (not local profiles)."""
@@ -225,7 +219,6 @@ def test_clients_browser_alias_resolves_to_remote():
     assert "Chrome" in result.output
     assert "0.8.5" in result.output
 
-
 def test_clients_shows_named_profile_and_uses_socket_uuid_for_default(tmp_path):
     registry_path = tmp_path / "registry.json"
     default_socket = tmp_path / "550e8400-e29b-41d4-a716-446655440000.sock"
@@ -240,7 +233,7 @@ def test_clients_shows_named_profile_and_uses_socket_uuid_for_default(tmp_path):
         "work": [{"profile": "default", "name": "Chrome", "version": "1", "extensionVersion": "2.3.4"}],
     }
 
-    def fake_send_command(command, args=None, profile=None):
+    def fake_send_command(command, args=None, profile=None, remote=None, key=None):
         assert command == "clients.list"
         return responses[profile]
 
@@ -255,19 +248,18 @@ def test_clients_shows_named_profile_and_uses_socket_uuid_for_default(tmp_path):
     assert "Extension Version" in result.output
     assert "2.3.4" in result.output
 
-
 def test_tabs_list_multi_browser_shows_browser_column():
     def fake_send_command(command, args=None, profile=None):
         assert command == "tabs.list"
         return [{"id": 1 if profile == "default" else 2, "windowId": 1, "active": True, "title": profile, "url": "https://example.com"}]
 
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "550e8400-e29b-41d4-a716-446655440000", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
-    ), patch("browser_cli.commands.send_command", side_effect=fake_send_command):
+    ), patch("browser_cli.send_command", side_effect=fake_send_command):
         result = CliRunner().invoke(main, ["tabs", "list"])
 
     assert result.exit_code == 0
@@ -275,16 +267,15 @@ def test_tabs_list_multi_browser_shows_browser_column():
     assert "550e8400-e29b-41d4-a716-446655440000" in result.output
     assert "work" in result.output
 
-
 def test_tabs_list_with_remote_uses_only_remote_targets():
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         side_effect=AssertionError("local targets should not be used for explicit remote"),
     ), patch(
-        "browser_cli.commands.remote_browser_targets",
+        "browser_cli.remote_browser_targets",
         return_value=[BrowserTarget("work", "remote-host:work", "", remote="remote-host:8765")],
     ), patch(
-        "browser_cli.commands.send_command",
+        "browser_cli.send_command",
         return_value=[{"id": 1, "windowId": 1, "active": True, "title": "Remote", "url": "https://example.com"}],
     ) as send_command:
         result = CliRunner().invoke(main, ["--remote", "remote-host:8765", "tabs", "list"])
@@ -292,26 +283,24 @@ def test_tabs_list_with_remote_uses_only_remote_targets():
     assert result.exit_code == 0
     assert "remote-host:work" in result.output
     assert "Remote" in result.output
-    send_command.assert_called_once_with("tabs.list", {}, profile="work", remote="remote-host:8765")
-
+    send_command.assert_called_once_with("tabs.list", {}, profile="work", remote="remote-host:8765", key=None)
 
 def test_tabs_list_with_explicit_browser_does_not_show_browser_column():
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
     ), patch(
-        "browser_cli.commands.send_command",
+        "browser_cli.send_command",
         return_value=[{"id": 1, "windowId": 1, "active": True, "title": "Example", "url": "https://example.com"}],
     ) as send_command:
         result = CliRunner().invoke(main, ["--browser", "work", "tabs", "list"])
 
     assert result.exit_code == 0
     assert "Browser" not in result.output
-    send_command.assert_called_once_with("tabs.list", {}, profile=None)
-
+    send_command.assert_called_once_with("tabs.list", {}, profile="work", remote=None, key=None)
 
 def test_tabs_count_multi_browser_shows_total():
     counts = {"default": 3, "work": 4}
@@ -322,12 +311,12 @@ def test_tabs_count_multi_browser_shows_total():
         return counts[profile]
 
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
-    ), patch("browser_cli.commands.send_command", side_effect=fake_send_command):
+    ), patch("browser_cli.send_command", side_effect=fake_send_command):
         result = CliRunner().invoke(main, ["tabs", "count", "github"])
 
     assert result.exit_code == 0
@@ -335,7 +324,6 @@ def test_tabs_count_multi_browser_shows_total():
     assert "Total" in result.output
     assert "7" in result.output
 
-
 def test_group_count_multi_browser_shows_total():
     counts = {"default": 1, "work": 2}
 
@@ -344,12 +332,12 @@ def test_group_count_multi_browser_shows_total():
         return counts[profile]
 
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
-    ), patch("browser_cli.commands.send_command", side_effect=fake_send_command):
+    ), patch("browser_cli.send_command", side_effect=fake_send_command):
         result = CliRunner().invoke(main, ["groups", "count"])
 
     assert result.exit_code == 0
@@ -357,10 +345,9 @@ def test_group_count_multi_browser_shows_total():
     assert "Total" in result.output
     assert "3" in result.output
 
-
 def test_group_list_leaves_unnamed_group_cell_empty():
     with patch(
-        "browser_cli.commands.send_command",
+        "browser_cli.send_command",
         return_value=[{"id": 42, "title": "", "color": "grey", "collapsed": False, "tabCount": 1}],
     ):
         result = CliRunner().invoke(main, ["groups", "list"])
@@ -370,41 +357,38 @@ def test_group_list_leaves_unnamed_group_cell_empty():
     assert "42" in result.output
     assert "grey" in result.output
 
-
 def test_tabs_move_accepts_right_short_alias():
-    with patch("browser_cli.commands.send_command") as send_command:
+    with patch("browser_cli.send_command") as send_command:
         result = CliRunner().invoke(main, ["tabs", "move", "12", "-r"])
 
     assert result.exit_code == 0
     send_command.assert_called_once_with(
         "tabs.move",
         {"tabId": 12, "forward": True, "backward": False, "groupId": None, "windowId": None, "index": None},
-        profile=None,
+        profile=None, remote=None, key=None,
     )
 
-
 def test_groups_move_accepts_left_short_alias():
-    with patch("browser_cli.commands.send_command") as send_command:
+    with patch("browser_cli.send_command") as send_command:
         result = CliRunner().invoke(main, ["groups", "move", "research", "-l"])
 
     assert result.exit_code == 0
     send_command.assert_called_once_with(
-        "group.move", {"group": "research", "forward": False, "backward": True}, profile=None
+        "group.move", {"group": "research", "forward": False, "backward": True}, profile=None, remote=None, key=None
     )
 
-
 def test_windows_list_multi_browser_shows_browser_column():
     def fake_send_command(command, args=None, profile=None):
         assert command == "windows.list"
         return [{"id": 1, "alias": profile, "focused": True, "tabCount": 2, "state": "normal"}]
 
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
-    ), patch("browser_cli.commands.send_command", side_effect=fake_send_command):
+    ), patch("browser_cli.send_command", side_effect=fake_send_command):
         result = CliRunner().invoke(main, ["windows", "list"])
 
     assert result.exit_code == 0
@@ -413,19 +397,18 @@ def test_windows_list_multi_browser_shows_browser_column():
     assert "uuid-1" in result.output
     assert "work" in result.output
 
-
 def test_session_list_multi_browser_shows_browser_column():
     def fake_send_command(command, args=None, profile=None):
         assert command == "session.list"
         return [{"name": f"{profile}-session", "tabs": 2, "savedAt": 1712707200000}]
 
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
-    ), patch("browser_cli.commands.send_command", side_effect=fake_send_command):
+    ), patch("browser_cli.send_command", side_effect=fake_send_command):
         result = CliRunner().invoke(main, ["session", "list"])
 
     assert result.exit_code == 0
@@ -435,59 +418,54 @@ def test_session_list_multi_browser_shows_browser_column():
     assert "default-session" in result.output
     assert "work-session" in result.output
 
-
 def test_session_list_with_explicit_browser_does_not_show_browser_column():
     with patch(
-        "browser_cli.commands.active_browser_targets",
+        "browser_cli.active_browser_targets",
         return_value=[
             BrowserTarget("default", "uuid-1", "/tmp/default.sock"),
             BrowserTarget("work", "work", "/tmp/work.sock"),
         ],
     ), patch(
-        "browser_cli.commands.send_command",
+        "browser_cli.send_command",
         return_value=[{"name": "work-session", "tabs": 2, "savedAt": 1712707200000}],
     ) as send_command:
         result = CliRunner().invoke(main, ["--browser", "work", "session", "list"])
 
     assert result.exit_code == 0
     assert "Browser" not in result.output
-    send_command.assert_called_once_with("session.list", {}, profile=None)
-
+    send_command.assert_called_once_with("session.list", {}, profile="work", remote=None, key=None)
 
 def test_windows_open_passes_url():
-    with patch("browser_cli.commands.send_command", return_value={"id": 7}) as send_command:
+    with patch("browser_cli.send_command", return_value={"id": 7}) as send_command:
         result = CliRunner().invoke(main, ["windows", "open", "https://example.com"])
 
     assert result.exit_code == 0
     assert "https://example.com" in result.output
-    send_command.assert_called_once_with("windows.open", {"url": "https://example.com"}, profile=None)
+    send_command.assert_called_once_with("windows.open", {"url": "https://example.com"}, profile=None, remote=None, key=None)
 
 def test_extract_markdown_command():
-    with patch("browser_cli.commands.send_command", return_value="# Title") as send_command:
+    with patch("browser_cli.send_command", return_value="# Title") as send_command:
         result = CliRunner().invoke(main, ["extract", "markdown"])
 
     assert result.exit_code == 0
     assert result.output == "# Title\n"
-    send_command.assert_called_once_with("extract.markdown", {"selector": None}, profile=None)
+    send_command.assert_called_once_with("extract.markdown", {"selector": None}, profile=None, remote=None, key=None)
 
 def test_extract_markdown_command_with_selector():
-    with patch("browser_cli.commands.send_command", return_value="## Post") as send_command:
+    with patch("browser_cli.send_command", return_value="## Post") as send_command:
         result = CliRunner().invoke(main, ["extract", "markdown", "--selector", "article"])
 
     assert result.exit_code == 0
     assert result.output == "## Post\n"
-    send_command.assert_called_once_with("extract.markdown", {"selector": "article"}, profile=None)
-
+    send_command.assert_called_once_with("extract.markdown", {"selector": "article"}, profile=None, remote=None, key=None)
 
 def test_clean_markdown_output_removes_escaped_underscores_and_dashes():
     assert _clean_markdown_output(r"hello\_world \- item") == "hello_world - item"
 
-
 def test_clean_markdown_output_trims_useless_whitespace():
     raw = "  # Title  \n\n\n  paragraph with space  \n   next line\t \n"
     assert _clean_markdown_output(raw) == "# Title\n\nparagraph with space\nnext line"
 
-
 def test_clean_markdown_output_repairs_empty_table_header_rows():
     raw = (
         "|  |  |  |\n"
@@ -501,12 +479,10 @@ def test_clean_markdown_output_repairs_empty_table_header_rows():
         "| A | B | C |"
     )
 
-
 def test_clean_markdown_output_preserves_graph_code_blocks():
     raw = "```\n\nA\n  │\n  ▼\nB\n\n```"
     assert _clean_markdown_output(raw) == "```\nA\n  │\n  ▼\nB\n```"
 
-
 def test_clean_markdown_output_renders_code_block_list_branches():
     raw = "```\nPlattformen\n- Omnifact\n- Open WebUI + Ollama\n- Le Chat\n```"
     assert _clean_markdown_output(raw) == (
@@ -518,7 +494,6 @@ def test_clean_markdown_output_renders_code_block_list_branches():
         "```"
     )
 
-
 def test_clean_markdown_output_unflattens_graph_code_blocks():
     raw = (
         "```\n"
@@ -550,7 +525,6 @@ def test_clean_markdown_output_unflattens_graph_code_blocks():
         "```"
     )
 
-
 def test_extract_markdown_command_repairs_malformed_tables_and_code_blocks():
     raw = (
         "|  |  |  |\n"
@@ -561,7 +535,7 @@ def test_extract_markdown_command_repairs_malformed_tables_and_code_blocks():
         "Golden Set   │   ▼Promptfoo(Testausführung)   │   ▼Plattformen├ Omnifact└ Le Chat\n"
         "```"
     )
-    with patch("browser_cli.commands.send_command", return_value=raw):
+    with patch("browser_cli.send_command", return_value=raw):
         result = CliRunner().invoke(main, ["extract", "markdown"])
 
     assert result.exit_code == 0
@@ -571,7 +545,6 @@ def test_extract_markdown_command_repairs_malformed_tables_and_code_blocks():
     assert "├ Omnifact" in result.output
     assert "└ Le Chat" in result.output
 
-
 def test_convert_html_to_markdown_normalizes_blank_table_header_rows():
     html = """
     <main>
@@ -586,7 +559,6 @@ def test_convert_html_to_markdown_normalizes_blank_table_header_rows():
     assert "| Risiko | Beschreibung | Auswirkung | Gegenmaßnahme |" in markdown
     assert "|  |  |  |  |" not in markdown
 
-
 def test_convert_html_to_markdown_preserves_codemirror_graph_blocks():
     html = """
     <main>
@@ -611,7 +583,6 @@ def test_convert_html_to_markdown_preserves_codemirror_graph_blocks():
     assert "├ Omnifact" in markdown
     assert "└ Le Chat" in markdown
 
-
 def test_convert_html_to_markdown_indents_multiline_list_items():
     html = """
     <main>
@@ -629,7 +600,6 @@ def test_convert_html_to_markdown_indents_multiline_list_items():
         "  Local LLMs / API Modelle / Spezialmodelle"
     ) in markdown
 
-
 def test_tabs_list_multi_browser_queries_remote_target():
     endpoint = "browser-host.example:8765"
     remote_target = BrowserTarget(
@@ -639,12 +609,12 @@ def test_tabs_list_multi_browser_queries_remote_target():
         remote=endpoint,
     )
 
-    with patch("browser_cli.commands.active_browser_targets", return_value=[remote_target, BrowserTarget("local", "local", "/tmp/local.sock")]), patch(
-        "browser_cli.commands.send_command",
+    with patch("browser_cli.active_browser_targets", return_value=[remote_target, BrowserTarget("local", "local", "/tmp/local.sock")]), patch(
+        "browser_cli.send_command",
         return_value=[{"id": 1, "windowId": 1, "active": True, "title": "Remote", "url": "https://example.com"}],
     ) as send_command:
         result = CliRunner().invoke(main, ["tabs", "list"])
 
     assert result.exit_code == 0
-    send_command.assert_any_call("tabs.list", {}, profile="work", remote=endpoint)
+    send_command.assert_any_call("tabs.list", {}, profile="work", remote=endpoint, key=None)
     assert "browser-host.example:work" in result.output
diff --git a/tests/test_commands_cli.py b/tests/test_commands_cli.py
index 11b55c2..8522e17 100644
--- a/tests/test_commands_cli.py
+++ b/tests/test_commands_cli.py
@@ -13,27 +13,16 @@ from click.testing import CliRunner
 
 def _run(group, args, return_value):
     """Invoke a Click group/command with a mocked send_command return value."""
-    with patch("browser_cli.commands.send_command", return_value=return_value):
+    with patch("browser_cli.send_command", return_value=return_value):
         result = CliRunner().invoke(group, args)
     return result
 
 def _run_error(group, args, exc):
     """Invoke a Click group/command where send_command raises exc."""
-    with patch("browser_cli.commands.send_command", side_effect=exc):
+    with patch("browser_cli.send_command", side_effect=exc):
         result = CliRunner().invoke(group, args)
     return result
 
-def _run_no_multi(group, args, return_value, module_path=None):
-    """Invoke a command patching send_command AND _multi_browser_targets → single-browser mode."""
-    ctx1 = patch("browser_cli.commands.send_command", return_value=return_value)
-    if module_path:
-        ctx2 = patch(f"{module_path}._multi_browser_targets", return_value=[])
-        with ctx1, ctx2:
-            return CliRunner().invoke(group, args)
-    else:
-        with ctx1:
-            return CliRunner().invoke(group, args)
-
 # ---------------------------------------------------------------------------
 # dom commands
 # ---------------------------------------------------------------------------
@@ -419,7 +408,7 @@ def test_cli_nav_open_wait_no_title():
     assert "Loaded" in result.output
 
 def test_cli_nav_wait():
-    result = _run(nav_group, ["wait"], {"url": "https://example.com", "title": "Example"})
+    result = _run(nav_group, ["wait"], {"id": 1, "url": "https://example.com", "title": "Example"})
     assert result.exit_code == 0
     assert "Ready" in result.output
 
@@ -451,50 +440,50 @@ _SAMPLE_TAB = {"id": 1, "windowId": 1, "active": True, "muted": False,
                "title": "Example", "url": "https://example.com", "groupId": -1}
 
 def test_cli_tabs_list_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(tabs_group, ["list"])
     assert result.exit_code == 0
     assert "No tabs found" in result.output
 
 def test_cli_tabs_list_with_tabs():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_TAB]), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_TAB]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(tabs_group, ["list"])
     assert result.exit_code == 0
     assert "example.com" in result.output
 
 def test_cli_tabs_close_by_id():
-    with patch("browser_cli.commands.send_command", return_value={"closed": 1}):
+    with patch("browser_cli.send_command", return_value={"closed": 1}):
         result = CliRunner().invoke(tabs_group, ["close", "42"])
     assert result.exit_code == 0
     assert "Closed 1" in result.output
 
 def test_cli_tabs_close_inactive():
-    with patch("browser_cli.commands.send_command", return_value={"closed": 3}):
+    with patch("browser_cli.send_command", return_value={"closed": 3}):
         result = CliRunner().invoke(tabs_group, ["close", "--inactive"])
     assert result.exit_code == 0
     assert "Closed 3" in result.output
 
 def test_cli_tabs_close_duplicates():
-    with patch("browser_cli.commands.send_command", return_value={"closed": 2}):
+    with patch("browser_cli.send_command", return_value={"closed": 2}):
         result = CliRunner().invoke(tabs_group, ["close", "--duplicates"])
     assert result.exit_code == 0
     assert "Closed 2" in result.output
 
 def test_cli_tabs_move_forward():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(tabs_group, ["move", "42", "--forward"])
     assert result.exit_code == 0
     assert "Tab moved" in result.output
 
 def test_cli_tabs_move_to_window():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(tabs_group, ["move", "42", "--window", "2"])
     assert result.exit_code == 0
 
 def test_cli_tabs_active():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(tabs_group, ["active", "42"])
     assert result.exit_code == 0
     assert "42" in result.output
@@ -502,100 +491,100 @@ def test_cli_tabs_active():
 def test_cli_tabs_status():
     tab = {"id": 5, "windowId": 1, "active": True, "muted": False,
            "title": "MyPage", "url": "https://my.page"}
-    with patch("browser_cli.commands.send_command", return_value=tab):
+    with patch("browser_cli.send_command", return_value=tab):
         result = CliRunner().invoke(tabs_group, ["status"])
     assert result.exit_code == 0
     assert "MyPage" in result.output
 
 def test_cli_tabs_filter():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_TAB]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_TAB]):
         result = CliRunner().invoke(tabs_group, ["filter", "example"])
     assert result.exit_code == 0
     assert "example.com" in result.output
 
 def test_cli_tabs_filter_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]):
         result = CliRunner().invoke(tabs_group, ["filter", "nope"])
     assert result.exit_code == 0
     assert "No tabs" in result.output
 
 def test_cli_tabs_count():
-    with patch("browser_cli.commands.send_command", return_value=7), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=7), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(tabs_group, ["count"])
     assert result.exit_code == 0
     assert "7" in result.output
 
 def test_cli_tabs_count_with_pattern():
-    with patch("browser_cli.commands.send_command", return_value=3), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=3), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(tabs_group, ["count", "http"])
     assert result.exit_code == 0
     assert "3" in result.output
     assert "http" in result.output
 
 def test_cli_tabs_query():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_TAB]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_TAB]):
         result = CliRunner().invoke(tabs_group, ["query", "example"])
     assert result.exit_code == 0
     assert "example.com" in result.output
 
 def test_cli_tabs_html():
-    with patch("browser_cli.commands.send_command", return_value="<html><body>hello</body></html>"):
+    with patch("browser_cli.send_command", return_value="<html><body>hello</body></html>"):
         result = CliRunner().invoke(tabs_group, ["html"])
     assert result.exit_code == 0
     assert "hello" in result.output
 
 def test_cli_tabs_dedupe():
-    with patch("browser_cli.commands.send_command", return_value={"closed": 4}):
+    with patch("browser_cli.send_command", return_value={"closed": 4}):
         result = CliRunner().invoke(tabs_group, ["dedupe"])
     assert result.exit_code == 0
     assert "4 duplicate" in result.output
 
 def test_cli_tabs_sort():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(tabs_group, ["sort", "--by", "title"])
     assert result.exit_code == 0
     assert "title" in result.output
 
 def test_cli_tabs_merge_windows():
-    with patch("browser_cli.commands.send_command", return_value={"moved": 2}):
+    with patch("browser_cli.send_command", return_value={"moved": 2}):
         result = CliRunner().invoke(tabs_group, ["merge-windows"])
     assert result.exit_code == 0
     assert "2" in result.output
 
 def test_cli_tabs_mute():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 5}):
+    with patch("browser_cli.send_command", return_value={"tabId": 5}):
         result = CliRunner().invoke(tabs_group, ["mute", "5"])
     assert result.exit_code == 0
     assert "Muted tab 5" in result.output
 
 def test_cli_tabs_unmute():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 5}):
+    with patch("browser_cli.send_command", return_value={"tabId": 5}):
         result = CliRunner().invoke(tabs_group, ["unmute", "5"])
     assert result.exit_code == 0
     assert "Unmuted tab 5" in result.output
 
 def test_cli_tabs_pin():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 5}):
+    with patch("browser_cli.send_command", return_value={"tabId": 5}):
         result = CliRunner().invoke(tabs_group, ["pin", "5"])
     assert result.exit_code == 0
     assert "Pinned tab 5" in result.output
 
 def test_cli_tabs_unpin():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 5}):
+    with patch("browser_cli.send_command", return_value={"tabId": 5}):
         result = CliRunner().invoke(tabs_group, ["unpin", "5"])
     assert result.exit_code == 0
     assert "Unpinned tab 5" in result.output
 
 def test_cli_tabs_watch_url():
-    with patch("browser_cli.commands.send_command", return_value={"url": "https://done.com"}):
+    with patch("browser_cli.send_command", return_value={"id": 1, "url": "https://done.com"}):
         result = CliRunner().invoke(tabs_group, ["watch-url", "done\\.com"])
     assert result.exit_code == 0
     assert "done.com" in result.output
 
 def test_cli_tabs_screenshot_stdout():
-    with patch("browser_cli.commands.send_command", return_value={"dataUrl": "data:image/png;base64,abc"}):
+    with patch("browser_cli.send_command", return_value={"dataUrl": "data:image/png;base64,abc"}):
         result = CliRunner().invoke(tabs_group, ["screenshot"])
     assert result.exit_code == 0
     assert "data:image/png" in result.output
@@ -605,7 +594,7 @@ def test_cli_tabs_screenshot_to_file(tmp_path):
     png_bytes = b"\x89PNG\r\n\x1a\n" + b"\x00" * 8  # minimal header
     data_url = "data:image/png;base64," + base64.b64encode(png_bytes).decode()
     out = tmp_path / "shot.png"
-    with patch("browser_cli.commands.send_command", return_value={"dataUrl": data_url}):
+    with patch("browser_cli.send_command", return_value={"dataUrl": data_url}):
         result = CliRunner().invoke(tabs_group, ["screenshot", str(out)])
     assert result.exit_code == 0
     assert "saved" in result.output.lower()
@@ -622,95 +611,95 @@ _GROUPS_MOD = "browser_cli.commands.groups"
 _SAMPLE_GROUP = {"id": 10, "title": "Work", "color": "blue", "collapsed": False, "tabCount": 3}
 
 def test_cli_groups_list_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]), \
-         patch(f"{_GROUPS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(group_group, ["list"])
     assert result.exit_code == 0
     assert "No groups found" in result.output
 
 def test_cli_groups_list_with_groups():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_GROUP]), \
-         patch(f"{_GROUPS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_GROUP]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(group_group, ["list"])
     assert result.exit_code == 0
     assert "Work" in result.output
 
 def test_cli_groups_tabs():
     tabs = [_SAMPLE_TAB]
-    with patch("browser_cli.commands.send_command", return_value=tabs):
+    with patch("browser_cli.send_command", return_value=tabs):
         result = CliRunner().invoke(group_group, ["tabs", "10"])
     assert result.exit_code == 0
     assert "example.com" in result.output
 
 def test_cli_groups_tabs_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]):
         result = CliRunner().invoke(group_group, ["tabs", "10"])
     assert result.exit_code == 0
     assert "No tabs" in result.output
 
 def test_cli_groups_count():
-    with patch("browser_cli.commands.send_command", return_value=5), \
-         patch(f"{_GROUPS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=5), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(group_group, ["count"])
     assert result.exit_code == 0
     assert "5" in result.output
 
 def test_cli_groups_query_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]):
         result = CliRunner().invoke(group_group, ["query", "nothing"])
     assert result.exit_code == 0
     assert "No groups" in result.output
 
 def test_cli_groups_query_found():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_GROUP]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_GROUP]):
         result = CliRunner().invoke(group_group, ["query", "Work"])
     assert result.exit_code == 0
     assert "Work" in result.output
 
 def test_cli_groups_close():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(group_group, ["close", "10"])
     assert result.exit_code == 0
     assert "10" in result.output
 
 def test_cli_groups_create():
-    with patch("browser_cli.commands.send_command", return_value={"id": 42}):
+    with patch("browser_cli.send_command", return_value={"id": 42}):
         result = CliRunner().invoke(group_group, ["create", "Research"])
     assert result.exit_code == 0
     assert "Research" in result.output
     assert "42" in result.output
 
 def test_cli_groups_add_tab_no_url():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 7}):
+    with patch("browser_cli.send_command", return_value={"tabId": 7}):
         result = CliRunner().invoke(group_group, ["add-tab", "Work"])
     assert result.exit_code == 0
     assert "Work" in result.output
 
 def test_cli_groups_add_tab_with_url():
-    with patch("browser_cli.commands.send_command", return_value={"tabId": 9}):
+    with patch("browser_cli.send_command", return_value={"tabId": 9}):
         result = CliRunner().invoke(group_group, ["add-tab", "Work", "https://docs.example.com"])
     assert result.exit_code == 0
     assert "docs.example.com" in result.output
 
 def test_cli_groups_move_forward():
-    with patch("browser_cli.commands.send_command", return_value={"moved": True}):
+    with patch("browser_cli.send_command", return_value={"moved": True}):
         result = CliRunner().invoke(group_group, ["move", "10", "--forward"])
     assert result.exit_code == 0
     assert "forward" in result.output
 
 def test_cli_groups_move_backward():
-    with patch("browser_cli.commands.send_command", return_value={"moved": True}):
+    with patch("browser_cli.send_command", return_value={"moved": True}):
         result = CliRunner().invoke(group_group, ["move", "10", "--backward"])
     assert result.exit_code == 0
     assert "backward" in result.output
 
 def test_cli_groups_move_no_direction():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(group_group, ["move", "10"])
     assert result.exit_code != 0
 
 def test_cli_groups_move_already_at_end():
-    with patch("browser_cli.commands.send_command", return_value={"moved": False}):
+    with patch("browser_cli.send_command", return_value={"moved": False}):
         result = CliRunner().invoke(group_group, ["move", "10", "--forward"])
     assert result.exit_code == 0
     assert "already at" in result.output
@@ -724,103 +713,103 @@ from browser_cli.commands.session import session_group
 _SESSION_MOD = "browser_cli.commands.session"
 
 def test_cli_session_save():
-    with patch("browser_cli.commands.send_command", return_value={"tabs": 5}):
+    with patch("browser_cli.send_command", return_value={"tabs": 5}):
         result = CliRunner().invoke(session_group, ["save", "work"])
     assert result.exit_code == 0
     assert "work" in result.output
     assert "5" in result.output
 
 def test_cli_session_load():
-    with patch("browser_cli.commands.send_command", return_value={"tabs": 8}):
+    with patch("browser_cli.send_command", return_value={"tabs": 8}):
         result = CliRunner().invoke(session_group, ["load", "work"])
     assert result.exit_code == 0
     assert "work" in result.output
     assert "8" in result.output
 
 def test_cli_session_load_background():
-    with patch("browser_cli.commands.send_command", return_value={"jobId": "j-abc", "status": "running"}):
+    with patch("browser_cli.send_command", return_value={"jobId": "j-abc", "status": "running"}):
         result = CliRunner().invoke(session_group, ["load", "work", "--background"])
     assert result.exit_code == 0
     assert "j-abc" in result.output
 
 def test_cli_session_load_lazy():
-    with patch("browser_cli.commands.send_command", return_value={"tabs": 20}):
+    with patch("browser_cli.send_command", return_value={"tabs": 20}):
         result = CliRunner().invoke(session_group, ["load", "work", "--lazy", "--eager-tabs", "5"])
     assert result.exit_code == 0
 
 def test_cli_session_diff_has_changes():
     diff = {"added": ["https://new.com"], "removed": ["https://old.com"]}
-    with patch("browser_cli.commands.send_command", return_value=diff):
+    with patch("browser_cli.send_command", return_value=diff):
         result = CliRunner().invoke(session_group, ["diff", "a", "b"])
     assert result.exit_code == 0
     assert "new.com" in result.output
     assert "old.com" in result.output
 
 def test_cli_session_diff_identical():
-    with patch("browser_cli.commands.send_command", return_value={"added": [], "removed": []}):
+    with patch("browser_cli.send_command", return_value={"added": [], "removed": []}):
         result = CliRunner().invoke(session_group, ["diff", "a", "b"])
     assert result.exit_code == 0
     assert "identical" in result.output
 
 def test_cli_session_diff_no_data():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(session_group, ["diff", "a", "b"])
     assert result.exit_code == 0
     assert "No diff" in result.output
 
 def test_cli_session_list_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]), \
-         patch(f"{_SESSION_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(session_group, ["list"])
     assert result.exit_code == 0
     assert "No saved sessions" in result.output
 
 def test_cli_session_list_with_sessions():
     sessions = [{"name": "work", "tabs": 3, "savedAt": 1700000000000}]
-    with patch("browser_cli.commands.send_command", return_value=sessions), \
-         patch(f"{_SESSION_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=sessions), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(session_group, ["list"])
     assert result.exit_code == 0
     assert "work" in result.output
 
 def test_cli_session_remove():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(session_group, ["remove", "old-session"])
     assert result.exit_code == 0
     assert "old-session" in result.output
 
 def test_cli_session_job_status_running():
-    with patch("browser_cli.commands.send_command", return_value={"status": "running", "percent": 42}):
+    with patch("browser_cli.send_command", return_value={"status": "running", "percent": 42}):
         result = CliRunner().invoke(session_group, ["job-status", "j-xyz"])
     assert result.exit_code == 0
     assert "running" in result.output
 
 def test_cli_session_job_status_with_error():
-    with patch("browser_cli.commands.send_command", return_value={"status": "failed", "error": "something broke"}):
+    with patch("browser_cli.send_command", return_value={"status": "failed", "error": "something broke"}):
         result = CliRunner().invoke(session_group, ["job-status", "j-bad"])
     assert result.exit_code == 0
     assert "something broke" in result.output
 
 def test_cli_session_job_status_with_result():
-    with patch("browser_cli.commands.send_command", return_value={"status": "done", "result": "Opened 5 tabs"}):
+    with patch("browser_cli.send_command", return_value={"status": "done", "result": "Opened 5 tabs"}):
         result = CliRunner().invoke(session_group, ["job-status", "j-done"])
     assert result.exit_code == 0
     assert "Opened 5 tabs" in result.output
 
 def test_cli_session_job_cancel():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(session_group, ["job-cancel", "j-running"])
     assert result.exit_code == 0
     assert "j-running" in result.output
 
 def test_cli_session_auto_save_on():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(session_group, ["auto-save", "on"])
     assert result.exit_code == 0
     assert "on" in result.output
 
 def test_cli_session_auto_save_off():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(session_group, ["auto-save", "off"])
     assert result.exit_code == 0
     assert "off" in result.output
@@ -829,7 +818,7 @@ def test_cli_session_auto_save_off():
 # multi-browser error paths (None targets → "Cannot resolve" exit)
 # ---------------------------------------------------------------------------
 
-from browser_cli.client import BrowserTarget
+from browser_cli.client import BrowserNotConnected, BrowserTarget
 
 def _fake_target(name="browser-a"):
     return BrowserTarget(profile=name, display_name=name, socket_path="/tmp/fake.sock")
@@ -837,45 +826,40 @@ def _fake_target(name="browser-a"):
 def test_cli_tabs_list_multi_browser_all_none():
     """If every multi-browser target returns None, show error and exit 1."""
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_TABS_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(tabs_group, ["list"])
     assert result.exit_code != 0
 
 def test_cli_tabs_count_multi_browser_all_none():
     """If every multi-browser count returns None, show error and exit 1."""
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_TABS_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_TABS_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(tabs_group, ["count"])
     assert result.exit_code != 0
 
 def test_cli_groups_list_multi_browser_all_none():
     """If every multi-browser group list returns None, exit 1."""
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_GROUPS_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_GROUPS_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(group_group, ["list"])
     assert result.exit_code != 0
 
 def test_cli_groups_count_multi_browser_all_none():
     """If every multi-browser group count returns None, exit 1."""
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_GROUPS_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_GROUPS_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(group_group, ["count"])
     assert result.exit_code != 0
 
 def test_cli_session_list_multi_browser_all_none():
     """If every multi-browser session list returns None, exit 1."""
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_SESSION_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_SESSION_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(session_group, ["list"])
     assert result.exit_code != 0
 
@@ -886,14 +870,14 @@ def test_cli_session_list_multi_browser_all_none():
 def test_cli_tabs_screenshot_bad_dataurl(tmp_path):
     """Screenshot command exits non-zero when dataUrl has wrong format."""
     out = tmp_path / "bad.png"
-    with patch("browser_cli.commands.send_command", return_value={"dataUrl": "not-a-dataurl"}):
+    with patch("browser_cli.send_command", return_value={"dataUrl": "not-a-dataurl"}):
         result = CliRunner().invoke(tabs_group, ["screenshot", str(out)])
     assert result.exit_code != 0
 
 def test_cli_tabs_screenshot_bad_base64(tmp_path):
     """Screenshot command exits non-zero when base64 data is corrupt."""
     out = tmp_path / "bad.png"
-    with patch("browser_cli.commands.send_command", return_value={"dataUrl": "data:image/png;base64,!!!NOT_VALID_BASE64!!!"}):
+    with patch("browser_cli.send_command", return_value={"dataUrl": "data:image/png;base64,!!!NOT_VALID_BASE64!!!"}):
         result = CliRunner().invoke(tabs_group, ["screenshot", str(out)])
     assert result.exit_code != 0
 
@@ -908,48 +892,47 @@ _WINDOWS_MOD = "browser_cli.commands.windows"
 _SAMPLE_WINDOW = {"id": 1, "alias": "main", "tabCount": 5, "state": "normal"}
 
 def test_cli_windows_list_empty():
-    with patch("browser_cli.commands.send_command", return_value=[]), \
-         patch(f"{_WINDOWS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(windows_group, ["list"])
     assert result.exit_code == 0
     assert "No windows found" in result.output
 
 def test_cli_windows_list_with_windows():
-    with patch("browser_cli.commands.send_command", return_value=[_SAMPLE_WINDOW]), \
-         patch(f"{_WINDOWS_MOD}._multi_browser_targets", return_value=[]):
+    with patch("browser_cli.send_command", return_value=[_SAMPLE_WINDOW]), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
         result = CliRunner().invoke(windows_group, ["list"])
     assert result.exit_code == 0
     assert "main" in result.output
 
 def test_cli_windows_list_multi_all_none():
     target = _fake_target()
-    with patch("browser_cli.commands.send_command", return_value=None), \
-         patch(f"{_WINDOWS_MOD}._multi_browser_targets", return_value=[target]), \
-         patch(f"{_WINDOWS_MOD}._handle_multi", return_value=None):
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("gone")), \
+         patch("browser_cli.active_browser_targets", return_value=[target, _fake_target("browser-b")]):
         result = CliRunner().invoke(windows_group, ["list"])
     assert result.exit_code != 0
 
 def test_cli_windows_rename():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(windows_group, ["rename", "1", "work"])
     assert result.exit_code == 0
     assert "work" in result.output
     assert "1" in result.output
 
 def test_cli_windows_close():
-    with patch("browser_cli.commands.send_command", return_value=None):
+    with patch("browser_cli.send_command", return_value=None):
         result = CliRunner().invoke(windows_group, ["close", "2"])
     assert result.exit_code == 0
     assert "2" in result.output
 
 def test_cli_windows_open_no_url():
-    with patch("browser_cli.commands.send_command", return_value={"id": 5}):
+    with patch("browser_cli.send_command", return_value={"id": 5}):
         result = CliRunner().invoke(windows_group, ["open"])
     assert result.exit_code == 0
     assert "5" in result.output
 
 def test_cli_windows_open_with_url():
-    with patch("browser_cli.commands.send_command", return_value={"id": 6}):
+    with patch("browser_cli.send_command", return_value={"id": 6}):
         result = CliRunner().invoke(windows_group, ["open", "https://example.com"])
     assert result.exit_code == 0
     assert "example.com" in result.output
@@ -958,36 +941,29 @@ def test_cli_windows_open_with_url():
 # commands/__init__.py error paths
 # ---------------------------------------------------------------------------
 
-from browser_cli.commands import _handle, _handle_multi
-from browser_cli.client import BrowserNotConnected
+from browser_cli.commands import client_from_ctx, handle_errors
 
-def test_handle_raises_system_exit_on_browser_not_connected():
-    """_handle converts BrowserNotConnected into SystemExit(1)."""
-    with patch("browser_cli.commands.send_command", side_effect=BrowserNotConnected("no socket")):
-        with pytest.raises(SystemExit):
-            _handle("tabs.list")
+def test_handle_errors_converts_browser_not_connected_to_exit():
+    """handle_errors turns BrowserNotConnected into a clean SystemExit(1)."""
+    with patch("browser_cli.send_command", side_effect=BrowserNotConnected("no socket")), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
+        result = CliRunner().invoke(tabs_group, ["list"])
+    assert result.exit_code == 1
+    assert "no socket" in result.output
 
-def test_handle_raises_system_exit_on_runtime_error():
-    """_handle converts RuntimeError into SystemExit(1)."""
-    with patch("browser_cli.commands.send_command", side_effect=RuntimeError("browser blew up")):
-        with pytest.raises(SystemExit):
-            _handle("tabs.list")
+def test_handle_errors_converts_runtime_error_to_exit():
+    """handle_errors turns a browser RuntimeError into a clean SystemExit(1)."""
+    with patch("browser_cli.send_command", side_effect=RuntimeError("browser blew up")), \
+         patch("browser_cli.active_browser_targets", return_value=[]):
+        result = CliRunner().invoke(tabs_group, ["list"])
+    assert result.exit_code == 1
+    assert "browser blew up" in result.output
 
-def test_handle_multi_returns_none_on_error():
-    """_handle_multi silently returns None on BrowserNotConnected."""
-    with patch("browser_cli.commands.send_command", side_effect=BrowserNotConnected("gone")):
-        result = _handle_multi("tabs.list")
-    assert result is None
-
-def test_handle_multi_returns_none_on_runtime_error():
-    """_handle_multi silently returns None on RuntimeError."""
-    with patch("browser_cli.commands.send_command", side_effect=RuntimeError("oops")):
-        result = _handle_multi("tabs.list")
-    assert result is None
-
-def test_handle_multi_with_remote():
-    """_handle_multi routes through remote when remote arg is set."""
-    with patch("browser_cli.commands.send_command", return_value={"ok": True}) as mock_send:
-        result = _handle_multi("tabs.list", profile="brave", remote="host:8765")
-    assert result == {"ok": True}
-    mock_send.assert_called_once_with("tabs.list", {}, profile="brave", remote="host:8765")
+def test_client_from_ctx_forwards_global_options():
+    """client_from_ctx builds a BrowserCLI from the root --browser/--remote options."""
+    from browser_cli.cli import main
+    with patch("browser_cli.send_command", return_value=[]) as mock_send, \
+         patch("browser_cli.active_browser_targets", return_value=[]):
+        result = CliRunner().invoke(main, ["--browser", "brave", "--remote", "host:8765", "tabs", "list"])
+    assert result.exit_code == 0
+    mock_send.assert_called_once_with("tabs.list", {}, profile="brave", remote="host:8765", key=None)
diff --git a/tests/test_extension_error_page_handling.py b/tests/test_extension_error_page_handling.py
index 195e4e4..dfbf9b1 100644
--- a/tests/test_extension_error_page_handling.py
+++ b/tests/test_extension_error_page_handling.py
@@ -111,7 +111,6 @@ def test_large_extension_operations_yield_between_batches():
     assert "perf.set_profile" in perf
     assert "__background" in connection
 
-
 def test_session_autosave_is_debounced_and_non_overlapping():
     # The autosave lifecycle moved out of session.ts into a dedicated
     # AutoSaveManager (autosave.ts) during the structure refactor; the shared
@@ -137,31 +136,34 @@ def test_session_autosave_is_debounced_and_non_overlapping():
     assert "setTimeout(() => this.runAutoSave(), delayMs)" in autosave
     assert "clearTimeout(this.autoSaveTimer)" in autosave
 
-
 def test_cli_and_sdk_expose_gentle_restore_controls():
     session_cli = (ROOT / "browser_cli" / "commands" / "session.py").read_text()
     tabs_cli = (ROOT / "browser_cli" / "commands" / "tabs.py").read_text()
     groups_cli = (ROOT / "browser_cli" / "commands" / "groups.py").read_text()
-    sdk = (ROOT / "browser_cli" / "__init__.py").read_text()
+    commands_init = (ROOT / "browser_cli" / "commands" / "__init__.py").read_text()
+    sdk_session = (ROOT / "browser_cli" / "sdk" / "session.py").read_text()
+    sdk_perf = (ROOT / "browser_cli" / "sdk" / "perf.py").read_text()
 
-    assert "--gentle-mode" in session_cli
+    # The --gentle-mode flag is defined once via the shared gentle_mode_option helper.
+    assert '"--gentle-mode"' in commands_init
+    assert "gentle_mode_option" in session_cli
     assert "--discard-background-tabs" in session_cli
     assert "--background" in session_cli
     assert "--lazy" in session_cli
     assert "--eager-tabs" in session_cli
     assert "job-status" in session_cli
     assert "job-cancel" in session_cli
-    assert "discardBackgroundTabs" in session_cli
-    assert "--gentle-mode" in tabs_cli
-    assert "gentleMode" in tabs_cli
-    assert "--gentle-mode" in groups_cli
-    assert "discard_background_tabs" in sdk
-    assert "discardBackgroundTabs" in sdk
-    assert "session_load_background" in sdk
-    assert "job_status" in sdk
-    assert "job_cancel" in sdk
-    assert "perf_status" in sdk
-    assert "set_performance_profile" in sdk
+    assert "discard_background_tabs" in session_cli
+    assert "gentle_mode_option" in tabs_cli
+    assert "gentle_mode" in tabs_cli
+    assert "gentle_mode_option" in groups_cli
+    assert "discard_background_tabs" in sdk_session
+    assert "discardBackgroundTabs" in sdk_session
+    assert "def load_background" in sdk_session
+    assert "def job_status" in sdk_perf
+    assert "def job_cancel" in sdk_perf
+    assert "def status" in sdk_perf
+    assert "def set_profile" in sdk_perf
 
     perf_cli = (ROOT / "browser_cli" / "commands" / "perf.py").read_text()
     root_cli = (ROOT / "browser_cli" / "cli.py").read_text()
diff --git a/tests/test_refactor_boundaries.py b/tests/test_refactor_boundaries.py
new file mode 100644
index 0000000..4287195
--- /dev/null
+++ b/tests/test_refactor_boundaries.py
@@ -0,0 +1,123 @@
+"""Guards for the module boundaries introduced by the modularity refactor.
+
+Three things must hold so the split stays invisible to callers:
+  * the new leaf modules own their logic and behave correctly,
+  * ``browser_cli.client`` still re-exports the names that moved out of it, and
+  * ``BrowserCLI`` still exposes the factory/routing helpers (now mixins).
+"""
+from unittest.mock import patch
+
+import browser_cli
+from browser_cli import BrowserCLI, BrowserCounts
+
+# ── endpoints module ────────────────────────────────────────────────────────
+
+class TestEndpoints:
+    def test_normalize_strips_default_https_port_for_domains(self):
+        from browser_cli.endpoints import _normalize_endpoint
+
+        assert _normalize_endpoint("example.com:443") == "example.com"
+        assert _normalize_endpoint("example.com:8765") == "example.com:8765"
+        assert _normalize_endpoint("192.168.1.10:443") == "192.168.1.10:443"
+
+    def test_resolve_connect_endpoint_defaults_domain_to_443(self):
+        from browser_cli.endpoints import _resolve_connect_endpoint
+
+        assert _resolve_connect_endpoint("example.com") == "example.com:443"
+        assert _resolve_connect_endpoint("host:9000") == "host:9000"
+
+    def test_resolve_connect_endpoint_rejects_bare_non_domain(self):
+        from browser_cli.errors import BrowserNotConnected
+        from browser_cli.endpoints import _resolve_connect_endpoint
+
+        try:
+            _resolve_connect_endpoint("localhost")
+        except BrowserNotConnected:
+            pass
+        else:
+            raise AssertionError("expected BrowserNotConnected for bare 'localhost'")
+
+    def test_looks_like_domain(self):
+        from browser_cli.endpoints import _looks_like_domain
+
+        assert _looks_like_domain("example.com") is True
+        assert _looks_like_domain("localhost") is False
+        assert _looks_like_domain("127.0.0.1") is False
+
+# ── markdown module ─────────────────────────────────────────────────────────
+
+class TestRenderMarkdown:
+    def test_html_payload_is_converted(self):
+        from browser_cli.markdown import render_markdown
+
+        assert render_markdown("<h1>Title</h1>") == "# Title"
+
+    def test_markdown_payload_is_cleaned_not_html_parsed(self):
+        from browser_cli.markdown import render_markdown
+
+        assert render_markdown(r"hello\_world \- item") == "hello_world - item"
+
+    def test_none_and_empty_are_safe(self):
+        from browser_cli.markdown import render_markdown
+
+        assert render_markdown(None) == ""
+        assert render_markdown("") == ""
+
+# ── backward-compatible re-exports ──────────────────────────────────────────
+
+class TestReExports:
+    def test_client_still_exposes_moved_names(self):
+        from browser_cli import client
+
+        # moved to endpoints / remote_transport / _errors but still reachable here
+        for name in (
+            "BrowserNotConnected",
+            "_normalize_endpoint",
+            "_resolve_connect_endpoint",
+            "display_browser_name",
+            "_remote_display_name",
+            "_send_remote",
+            "_recv_all",
+            "_recv_exact",
+        ):
+            assert hasattr(client, name), f"browser_cli.client.{name} missing after refactor"
+
+    def test_browsercounts_reexported_from_package(self):
+        # BrowserCounts moved to models but is still part of the public API.
+        from browser_cli.models import BrowserCounts as ModelsBrowserCounts
+
+        assert BrowserCounts is ModelsBrowserCounts
+
+    def test_patching_client_send_remote_still_intercepts(self):
+        # send_command resolves _send_remote as a browser_cli.client global, so
+        # patching there must still take effect after the move to remote_transport.
+        with patch("browser_cli.client._send_remote", return_value=None) as fake:
+            assert browser_cli.client._send_remote is fake
+
+# ── BrowserCLI mixin composition ─────────────────────────────────────────────
+
+class TestMixinComposition:
+    def test_factory_builds_bound_tab(self):
+        b = BrowserCLI()
+        tab = b._make_tab({"id": 7, "windowId": 1, "title": "t", "url": "u"})
+        assert tab.id == 7
+        assert tab._browser is b
+
+    def test_factory_tab_for_remote_target_binds_sibling_client(self):
+        b = BrowserCLI()
+
+        class _Target:
+            profile = "work"
+            display_name = "host:work"
+            remote = "host:8765"
+
+        tab = b._make_tab_for({"id": 1, "windowId": 0}, _Target())
+        assert tab.browser == "host:work"
+        assert isinstance(tab._browser, BrowserCLI)
+        assert tab._browser is not b
+        assert tab._browser.browser == "work"
+
+    def test_field_helper_handles_non_dict(self):
+        b = BrowserCLI()
+        assert b._field({"tabId": 5}, "tabId") == 5
+        assert b._field("not-a-dict", "tabId", fallback=9) == 9
diff --git a/tests/test_serve.py b/tests/test_serve.py
index 02ec127..ac6beae 100644
--- a/tests/test_serve.py
+++ b/tests/test_serve.py
@@ -6,6 +6,7 @@ import threading
 
 import pytest
 
+from browser_cli import transport
 from browser_cli.auth import generate_keypair, load_private_key, new_nonce, pq_decrypt, pq_encrypt, sign
 from browser_cli.client import BrowserNotConnected
 from browser_cli.commands.serve import _handle_client
@@ -18,7 +19,6 @@ FAKE_UA = "browser-cli/0.9.3"
 def _send_framed(sock: socket.socket, data: bytes) -> None:
     sock.sendall(struct.pack("<I", len(data)) + data)
 
-
 def _recv_framed(sock: socket.socket) -> dict:
     raw = b""
     while len(raw) < 4:
@@ -35,7 +35,6 @@ def _recv_framed(sock: socket.socket) -> dict:
         data += chunk
     return json.loads(data)
 
-
 def _spawn(server_sock: socket.socket, auth_keys_path) -> threading.Thread:
     t = threading.Thread(
         target=_handle_client,
@@ -45,15 +44,12 @@ def _spawn(server_sock: socket.socket, auth_keys_path) -> threading.Thread:
     t.start()
     return t
 
-
 def _pair():
     return socket.socketpair()
 
-
 def _mock_no_browser(*_args, **_kwargs):
     raise BrowserNotConnected("no browser")
 
-
 # ── challenge frame ────────────────────────────────────────────────────────────
 
 class TestChallenge:
@@ -89,7 +85,6 @@ class TestChallenge:
         client.close()
         t.join(timeout=2)
 
-
 # ── rejection paths ────────────────────────────────────────────────────────────
 
 class TestRejection:
@@ -199,7 +194,6 @@ class TestRejection:
         client.close()
         t.join(timeout=2)
 
-
 # ── auth success paths ─────────────────────────────────────────────────────────
 
 class TestAuthSuccess:
@@ -371,3 +365,127 @@ class TestAuthSuccess:
         assert "unauthorized" not in resp.get("error", "").lower()
         client.close()
         t.join(timeout=2)
+
+# ── response encoding (compression / msgpack) ───────────────────────────────────
+
+def _recv_framed_raw(sock: socket.socket) -> bytes:
+    raw = b""
+    while len(raw) < 4:
+        chunk = sock.recv(4 - len(raw))
+        if not chunk:
+            raise ConnectionError("socket closed before response header")
+        raw += chunk
+    n = struct.unpack("<I", raw)[0]
+    data = b""
+    while len(data) < n:
+        chunk = sock.recv(n - len(data))
+        if not chunk:
+            raise ConnectionError("socket closed mid-response")
+        data += chunk
+    return data
+
+class _FakeNativeHost:
+    """Minimal AF_UNIX server speaking the 4-byte framed protocol the proxy expects."""
+
+    def __init__(self, sock_path, response_obj):
+        self.sock_path = str(sock_path)
+        self.response = json.dumps(response_obj).encode()
+        self.srv = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.srv.bind(self.sock_path)
+        self.srv.listen(1)
+        self.thread = threading.Thread(target=self._serve, daemon=True)
+        self.thread.start()
+
+    def _serve(self):
+        try:
+            conn, _ = self.srv.accept()
+            with conn:
+                hdr = conn.recv(4)
+                n = struct.unpack("<I", hdr)[0]
+                got = b""
+                while len(got) < n:
+                    got += conn.recv(n - len(got))
+                conn.sendall(struct.pack("<I", len(self.response)) + self.response)
+        except OSError:
+            pass
+
+    def close(self):
+        self.srv.close()
+
+class TestResponseEncoding:
+    def test_client_accept_encoding_yields_decodable_tagged_response(self, tmp_path, monkeypatch):
+        if socket.AF_UNIX is None:  # pragma: no cover
+            pytest.skip("AF_UNIX unavailable")
+
+        big = {"id": "x", "success": True,
+               "data": {"items": [{"url": f"https://example.com/{i}", "title": f"Tab {i}"} for i in range(300)]}}
+        host_path = tmp_path / "native.sock"
+        host = _FakeNativeHost(host_path, big)
+        monkeypatch.setattr("browser_cli.client._resolve_socket", lambda *_a, **_k: str(host_path))
+
+        client, server = _pair()
+        t = _spawn(server, None)  # no auth
+        _recv_framed(client)  # challenge
+
+        msg = {
+            "id": "x", "command": "tabs.list", "args": {},
+            "user_agent": "browser-cli/0.9.5",
+            "accept_encoding": {"ser": ["json"], "comp": ["gzip"]},
+        }
+        _send_framed(client, json.dumps(msg).encode())
+        raw = _recv_framed_raw(client)
+
+        assert raw[:1] not in (b"{", b"[")  # tagged, not plain JSON
+        assert len(raw) < len(json.dumps(big))  # compressed
+        assert transport.decode_response(raw) == big
+        client.close()
+        host.close()
+        t.join(timeout=2)
+
+    def test_no_accept_encoding_stays_plain_json(self, tmp_path, monkeypatch):
+        big = {"id": "y", "success": True, "data": {"items": list(range(500))}}
+        host_path = tmp_path / "native2.sock"
+        host = _FakeNativeHost(host_path, big)
+        monkeypatch.setattr("browser_cli.client._resolve_socket", lambda *_a, **_k: str(host_path))
+
+        client, server = _pair()
+        t = _spawn(server, None)
+        _recv_framed(client)
+
+        msg = {"id": "y", "command": "tabs.list", "args": {}, "user_agent": "browser-cli/0.9.5"}
+        _send_framed(client, json.dumps(msg).encode())
+        raw = _recv_framed_raw(client)
+
+        assert raw[:1] in (b"{", b"[")  # old client → plain JSON
+        assert json.loads(raw) == big
+        client.close()
+        host.close()
+        t.join(timeout=2)
+
+    def test_no_compress_flag_forces_plain_json(self, tmp_path, monkeypatch):
+        big = {"id": "z", "success": True,
+               "data": {"items": [{"url": f"https://e/{i}"} for i in range(300)]}}
+        host_path = tmp_path / "native3.sock"
+        host = _FakeNativeHost(host_path, big)
+        monkeypatch.setattr("browser_cli.client._resolve_socket", lambda *_a, **_k: str(host_path))
+
+        client, server = _pair()
+        t = threading.Thread(
+            target=_handle_client,
+            args=(server, ("127.0.0.1", 9999), None, None, False),  # compress=False
+            daemon=True,
+        )
+        t.start()
+        _recv_framed(client)
+
+        msg = {"id": "z", "command": "tabs.list", "args": {},
+               "user_agent": "browser-cli/0.9.5",
+               "accept_encoding": {"ser": ["msgpack"], "comp": ["zstd"]}}
+        _send_framed(client, json.dumps(msg).encode())
+        raw = _recv_framed_raw(client)
+
+        assert raw[:1] in (b"{", b"[")  # server disabled encoding
+        assert json.loads(raw) == big
+        client.close()
+        host.close()
+        t.join(timeout=2)
diff --git a/tests/test_tabs.py b/tests/test_tabs.py
index 6e7959f..b9eb2d5 100644
--- a/tests/test_tabs.py
+++ b/tests/test_tabs.py
@@ -1,4 +1,5 @@
 """Tests for tabs.* commands."""
+import time
 import pytest
 
 def test_tabs_list(browser):
@@ -72,6 +73,16 @@ def test_tabs_dedupe(browser):
     id1, id2 = r1["id"], r2["id"]
 
     try:
+        # Dedupe keys on tab.url and intentionally skips tabs that haven't
+        # resolved a URL yet, so wait for both tabs to finish loading first.
+        for _ in range(30):
+            tabs = {t["id"]: t for t in browser("tabs.list")}
+            if all(tabs.get(tid, {}).get("url", "").startswith("http") for tid in (id1, id2)):
+                break
+            time.sleep(0.1)
+        else:
+            pytest.skip("Duplicate test tabs did not finish loading")
+
         result = browser("tabs.dedupe")
         assert isinstance(result, dict)
         assert result.get("closed", 0) >= 0
diff --git a/tests/test_transport.py b/tests/test_transport.py
new file mode 100644
index 0000000..d386354
--- /dev/null
+++ b/tests/test_transport.py
@@ -0,0 +1,117 @@
+"""Unit tests for the response transport codec (compression + msgpack)."""
+import base64
+import json
+
+import pytest
+
+from browser_cli import transport
+
+def _sample(n=200):
+    return {
+        "id": "abc",
+        "success": True,
+        "data": {"items": [{"url": f"https://example.com/{i}", "title": f"Tab {i}"} for i in range(n)]},
+    }
+
+# ── backward compatibility ──────────────────────────────────────────────────────
+
+def test_no_accept_encoding_returns_bare_json():
+    obj = _sample()
+    enc = transport.encode_response(obj, accept=None)
+    assert enc == json.dumps(obj).encode("utf-8")  # byte-identical to old wire format
+    assert enc[:1] in (b"{", b"[")
+
+def test_empty_accept_returns_bare_json():
+    obj = _sample()
+    assert transport.encode_response(obj, accept={}) == json.dumps(obj).encode("utf-8")
+
+def test_decode_plain_json_without_tag():
+    obj = _sample()
+    assert transport.decode_response(json.dumps(obj).encode("utf-8")) == obj
+
+def test_decode_none_and_empty():
+    assert transport.decode_response(None) is None
+    with pytest.raises(ValueError):
+        transport.decode_response(b"")
+
+# ── compression roundtrips ───────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("comp", ["zlib", "gzip", "zstd"])
+def test_compression_roundtrip(comp):
+    if comp == "zstd" and not transport.zstd_available():
+        pytest.skip("zstandard not installed")
+    obj = _sample()
+    enc = transport.encode_response(obj, accept={"ser": ["json"], "comp": [comp]})
+    assert enc[:1] not in (b"{", b"[")  # tagged, not plain
+    assert len(enc) < len(json.dumps(obj))  # actually smaller
+    assert transport.decode_response(enc) == obj
+
+def test_small_payload_not_compressed():
+    obj = {"id": "x", "success": True, "data": "ok"}
+    enc = transport.encode_response(obj, accept={"ser": ["json"], "comp": ["zlib"]}, threshold=512)
+    assert enc == json.dumps(obj).encode("utf-8")  # below threshold → bare json
+
+def test_unknown_compression_in_accept_falls_back_to_plain():
+    obj = _sample()
+    enc = transport.encode_response(obj, accept={"ser": ["json"], "comp": ["brotli"]})
+    assert enc == json.dumps(obj).encode("utf-8")
+
+# ── msgpack ──────────────────────────────────────────────────────────────────────
+
+def test_msgpack_roundtrip():
+    if not transport.msgpack_available():
+        pytest.skip("msgpack not installed")
+    obj = _sample()
+    enc = transport.encode_response(obj, accept={"ser": ["msgpack"], "comp": []})
+    assert enc[0] >> 4 == transport.SER_MSGPACK
+    assert transport.decode_response(enc) == obj
+
+def test_msgpack_with_compression_roundtrip():
+    if not (transport.msgpack_available() and transport.zstd_available()):
+        pytest.skip("msgpack/zstd not installed")
+    obj = _sample()
+    enc = transport.encode_response(obj, accept={"ser": ["msgpack"], "comp": ["zstd"]})
+    tag = enc[0]
+    assert tag >> 4 == transport.SER_MSGPACK
+    assert tag & 0x0F == transport.COMP_ZSTD
+    assert transport.decode_response(enc) == obj
+
+# ── raw screenshot hoisting ───────────────────────────────────────────────────────
+
+def _screenshot_obj():
+    png = bytes(range(256)) * 40
+    url = "data:image/png;base64," + base64.b64encode(png).decode("ascii")
+    return {"id": "x", "success": True, "data": {"dataUrl": url}}, url
+
+def test_screenshot_roundtrip_restores_data_url_exactly():
+    if not transport.msgpack_available():
+        pytest.skip("msgpack not installed")
+    obj, url = _screenshot_obj()
+    enc = transport.encode_response(obj, accept={"ser": ["msgpack"], "comp": []}, command="tabs.screenshot")
+    dec = transport.decode_response(enc)
+    assert dec == obj
+    assert dec["data"]["dataUrl"] == url
+
+def test_screenshot_not_hoisted_for_other_commands():
+    if not transport.msgpack_available():
+        pytest.skip("msgpack not installed")
+    import msgpack
+    obj, _ = _screenshot_obj()
+    enc = transport.encode_response(obj, accept={"ser": ["msgpack"], "comp": []}, command="extract.text")
+    body = msgpack.unpackb(enc[1:], raw=False)
+    assert isinstance(body["data"]["dataUrl"], str)  # left as base64 string
+
+def test_screenshot_json_path_leaves_base64():
+    obj, url = _screenshot_obj()
+    enc = transport.encode_response(obj, accept={"ser": ["json"], "comp": ["gzip"]}, command="tabs.screenshot")
+    assert transport.decode_response(enc)["data"]["dataUrl"] == url
+
+# ── negotiation preference ────────────────────────────────────────────────────────
+
+def test_server_prefers_strongest_mutual_codec():
+    if not transport.zstd_available():
+        pytest.skip("zstandard not installed")
+    obj = _sample()
+    # client accepts gzip and zstd; server should pick zstd (its top preference)
+    enc = transport.encode_response(obj, accept={"ser": ["json"], "comp": ["gzip", "zstd"]})
+    assert enc[0] & 0x0F == transport.COMP_ZSTD
diff --git a/uv.lock b/uv.lock
index f6f0108..b896b8b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -4,31 +4,42 @@ requires-python = ">=3.10"
 
 [[package]]
 name = "browser-cli"
-version = "0.10.3"
+version = "0.12.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
     { name = "cryptography" },
+    { name = "msgpack" },
     { name = "rich" },
 ]
 
+[package.optional-dependencies]
+fast = [
+    { name = "zstandard" },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "pytest" },
     { name = "pytest-cov" },
+    { name = "zstandard" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "click", specifier = ">=8" },
     { name = "cryptography", specifier = ">=48" },
+    { name = "msgpack", specifier = ">=1" },
     { name = "rich", specifier = ">=13" },
+    { name = "zstandard", marker = "extra == 'fast'", specifier = ">=0.22" },
 ]
+provides-extras = ["fast"]
 
 [package.metadata.requires-dev]
 dev = [
     { name = "pytest", specifier = ">=8" },
     { name = "pytest-cov", specifier = ">=7.1.0" },
+    { name = "zstandard", specifier = ">=0.22" },
 ]
 
 [[package]]
@@ -354,6 +365,79 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "msgpack"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/23/6139781ca7aadf656fa8e384fa84693ffb13f299e6931b6526427fe5e297/msgpack-1.2.0.tar.gz", hash = "sha256:8e17af38197bf58e7e819041678f6178f4491493f5b8c8580414f40f7c2c3c41", size = 183017, upload-time = "2026-06-11T04:16:10.775Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/52/fed22bca455ff3ed28c0ee0d1117398b7cb3ce440270050e85b09240fa8d/msgpack-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ed8c9495a0f12d17a2b4b69e23f895b88f26aabe40911c86594d3fbddecfff08", size = 82473, upload-time = "2026-06-11T04:14:38.484Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/09/0b54d386024a9fa2073135212c11d1e83b059d98459d943d5a82ba9dcdc9/msgpack-1.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d7384859c90b45a28a4b31aa50b49cca84504c9f27df459cea6e072627650dcb", size = 82150, upload-time = "2026-06-11T04:14:39.985Z" },
+    { url = "https://files.pythonhosted.org/packages/44/ba/c6310a6f37e9bf9279b492640ec425e6f6e68a94e4cac4782ab518b05d64/msgpack-1.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:63b35e8e65f04ff7ad5c9c70885da587c74f51e4b4eb3db624eac6d250e8cf59", size = 398355, upload-time = "2026-06-11T04:14:41.493Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/1b/f4bad0e9dea608b14d36065c44e347e4b10c0392f92cca441496cc0598ef/msgpack-1.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004c5a02acd3eca4e15e1ae7b461c32e3711105a28b1ad78be2f6facff4c523", size = 405162, upload-time = "2026-06-11T04:14:42.957Z" },
+    { url = "https://files.pythonhosted.org/packages/63/34/4653bc7f426bd6ce9803f75133aa362232639e5adb8c6b99550107c71ed5/msgpack-1.2.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7e2032dacb0a973fcbf7bd088415a369dae31c5af40e199d234806be22e86765", size = 372720, upload-time = "2026-06-11T04:14:44.532Z" },
+    { url = "https://files.pythonhosted.org/packages/13/3c/8c607e10db2225af52107ffa918280483248363819fecb4437a35a1f4ae2/msgpack-1.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c1feb100651fbe4b39826207cb20af065dfbfbfa43b1bafd7eaa2252abf7acfd", size = 390946, upload-time = "2026-06-11T04:14:46.054Z" },
+    { url = "https://files.pythonhosted.org/packages/96/05/c4cb5fb30569cff4b4c7be4574adddb0faf7faaf3049bbab000b6f07da5b/msgpack-1.2.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:82487709d4c597d252311a65370220675fb1cc859e7da9269a3060c03ac02cf6", size = 374062, upload-time = "2026-06-11T04:14:47.817Z" },
+    { url = "https://files.pythonhosted.org/packages/40/d7/b51b11e58277e6b678ba5a2f6608f88fdb0778973391a39d7f1a385f5bde/msgpack-1.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0268c67a74f5f913f545a0fdbbfaa3f6ebcf23b4c3209bb99704a2ea87e13f90", size = 405458, upload-time = "2026-06-11T04:14:49.618Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/9eca2961be302a6fc77a3fcb15faec749e325c9f0a8fe9c4c4576fc2cad5/msgpack-1.2.0-cp310-cp310-win32.whl", hash = "sha256:7df87173b0e13ddd134919731f13525dbbf75204145597decf1cb86887ebb492", size = 64010, upload-time = "2026-06-11T04:14:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/e3/55b14ae13ed056ed35364ff71144c6a12af25227c20093045a945d08273a/msgpack-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:6371edb47788fbfd8a22016f9a97b5616dd9849bc50abcbb8e82d38f71efa096", size = 69863, upload-time = "2026-06-11T04:14:52.376Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/23/35de3182a647fcc84ab304160169edfa5dac7bbd8913fbed0a505ddc0d55/msgpack-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ec35cd3f127f50806aa10c3f74bf27b749f13ddf1d2217964ada8f38042d1653", size = 82368, upload-time = "2026-06-11T04:14:53.57Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/79/8d9bfdab933b1c7a02aba9518605a81aa30d38e9efd4915ec1a6b2d55778/msgpack-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:317eb298297121bfad9173d748124a04a36af27b6ac39c2bbc1db1ce57608dcf", size = 82095, upload-time = "2026-06-11T04:14:54.784Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/e1/b5accbc1354edbcee107fb35ec247db0547e91c3f90e4fabdeaee500a5a6/msgpack-1.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50fe6434de89073273026dd032a62e8b63f8857a261d7a2df5b07c9e72f3a8f7", size = 413818, upload-time = "2026-06-11T04:14:56.1Z" },
+    { url = "https://files.pythonhosted.org/packages/82/31/1141cbbf7118d525834f20dcd614d1b85f1f2ffd33bc2a5ce710e6dd2516/msgpack-1.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106c6d333ff3d4eda075b7d4b9695d1752c5bcc635e40d0dbaf4e276c9ed80e1", size = 423790, upload-time = "2026-06-11T04:14:57.509Z" },
+    { url = "https://files.pythonhosted.org/packages/04/e7/9582f2bd4d7546139fe297740de49bd1f7ef2d195eb0bb9fa5efeee88158/msgpack-1.2.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:67055a611e871cb1bd0acb732f2e9f64ca8155ca0bba1d0a5bb362e7209e5541", size = 387521, upload-time = "2026-06-11T04:14:59.08Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/12/5aadd08ff068bfd42e2ac0be6a20aa9819965df8622e87c1f0c6119c1c22/msgpack-1.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ceec7f8e633d5a4b4a32b0416bef90ee3cd1017ea36247f705e523072e576119", size = 406324, upload-time = "2026-06-11T04:15:00.686Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ee/3041564f0cc4c2fe7c53315aec0edf3d84807fc9b9ea714e6ac07dbdb1db/msgpack-1.2.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7ec5851160a3c2c0f77d68ddec620318cd8e7d88d94f9c058190e8ce0dfa1d31", size = 384242, upload-time = "2026-06-11T04:15:02.121Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/d4/de94b3dbc266229f4c2ce84485eeb221220351b7f1931029e875995bb232/msgpack-1.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dd7140f7b09dbe1984a0dff3189375d840247e3e4cf4ac45c5a499b3b599c8d2", size = 420392, upload-time = "2026-06-11T04:15:03.692Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/5d/c4a3fde69a292eecb202caaa87c29df7728644a65118614b821bcaddc05a/msgpack-1.2.0-cp311-cp311-win32.whl", hash = "sha256:cbfd54018d386da0951c7a2be13de0f58559d251313e613b2155e52ed1cbd8f1", size = 63976, upload-time = "2026-06-11T04:15:05.355Z" },
+    { url = "https://files.pythonhosted.org/packages/18/fa/df47f83115375e7717c985265a30f3ba096c5331518e28fb647b55c46d31/msgpack-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:653373c4614c31463ba486a67776e4bb396af289921bd5353e209534b71467fa", size = 70273, upload-time = "2026-06-11T04:15:06.529Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d1/ffd02e54c064aa73b6b53aa08171f92dc406727077ff275d7050c6aca28a/msgpack-1.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:7a260aea1e5e7d6c7f1d9284c7360d29021627b61dc4dd7df144b81210810537", size = 64783, upload-time = "2026-06-11T04:15:07.677Z" },
+    { url = "https://files.pythonhosted.org/packages/44/07/dcb13f37e670257c8d0e944f116c799c34ac6968ecb48c83619f7e91d8b5/msgpack-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2d6047ccd11a12c96a69f2bfe026471abef67334c3d0494a93e5310e45140a2", size = 82888, upload-time = "2026-06-11T04:15:08.992Z" },
+    { url = "https://files.pythonhosted.org/packages/84/5f/6643b2a6a36ca4bc73c7674831be1d4d581cceecc7eb019dba1915951739/msgpack-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0347e3ac0dfee99086d3b68fe959da3f5f657c0019ddbaeaaa259a85f8603422", size = 82223, upload-time = "2026-06-11T04:15:10.182Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c8/9e1668b9897358e5ab39a18142e38be3cf15807e643757782da9f4a53cb3/msgpack-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25552ff1f2ff3dc8333e27eabb94f702da5929ed0e07969688194a3e9f12e151", size = 409700, upload-time = "2026-06-11T04:15:11.441Z" },
+    { url = "https://files.pythonhosted.org/packages/38/ed/b7728573156d70b6b094233b0f38d876fc37340826cf852347ec2c7ca8ca/msgpack-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0d94420d9d52c56568159a69200af7e45eadb29615fa9d09fada140de1c38c7", size = 420090, upload-time = "2026-06-11T04:15:12.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/f7/5ea755a89868c04f9cdf6d96d2d99da4b3d198af10e76a6082dd0fceccc0/msgpack-1.2.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d16e1f2db4a9eebc07b7cc91898d71e710f2eed8358711a605fee802caff8923", size = 378538, upload-time = "2026-06-11T04:15:14.511Z" },
+    { url = "https://files.pythonhosted.org/packages/80/2d/126e59332a439c94ffd682c38ca0102b23480e2784b3dac48d8959b0bbac/msgpack-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9cb2e700e85f1e27bbb5c9de6cc1c9a4bc5ac64d5404bdcbcb37a0dc7a947a3", size = 399468, upload-time = "2026-06-11T04:15:16.133Z" },
+    { url = "https://files.pythonhosted.org/packages/da/f9/7abcef683a0ad2e5ab3a4940344aad9f20cdf1f42057ecb0982cf55085d6/msgpack-1.2.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:717d0b166dd176a5f786aeafff081f6439680acf5af193eb63e6266c12b04d3d", size = 374212, upload-time = "2026-06-11T04:15:17.536Z" },
+    { url = "https://files.pythonhosted.org/packages/27/23/2d62cf0e971678e96f8a3cfa9bd77fb719ddb98da73790f63c53fd847ad8/msgpack-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e87c7a21654d18111eb1a89bd5c42baba42e61887365d9e89585e112b4203f9e", size = 414361, upload-time = "2026-06-11T04:15:18.99Z" },
+    { url = "https://files.pythonhosted.org/packages/32/fb/f5c153f614037aaf802d291a4653ba1bb731f56feacba886f7c21c109e56/msgpack-1.2.0-cp312-cp312-win32.whl", hash = "sha256:967e0c891f5f23ab65762f2e5dc95922759c79f1ef99ef4c7e1fdd863e0d0af9", size = 64389, upload-time = "2026-06-11T04:15:20.237Z" },
+    { url = "https://files.pythonhosted.org/packages/90/af/8aafce6e5544b43b84cb670aca40c8bea7eb5ae8f42bfcbdc7098739987a/msgpack-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:6c23e33cee28dcffa112ae205661da4636fd7b06bd9ad1559a890623b92d060b", size = 71185, upload-time = "2026-06-11T04:15:21.51Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/08/9cc94be1fc1fe3d1379d439326259aef0344274f64623a8138feb54dff68/msgpack-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:6eeb771571f63f68045433b1a35c0256b946f31ed62f006997e40b8ad8b735af", size = 64481, upload-time = "2026-06-11T04:15:22.639Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/26/2902c6946ab5c8fe1e46e40842dfc32b8824464ad5cd4725364fd83f7a58/msgpack-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3a1d30df1f302f2b7a7404afbac2ab76d510036c34cf34dffb01f704a7288e45", size = 82621, upload-time = "2026-06-11T04:15:23.844Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/59/7e6b812629d2f919e586041bffc130e1af32079f71bb20699eed54ed6d92/msgpack-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:581e317112260d8ca488d490cad9290a5682276f309c41c7de237a85ed8799c8", size = 81866, upload-time = "2026-06-11T04:15:25.032Z" },
+    { url = "https://files.pythonhosted.org/packages/31/13/8c291196e60aafdbae38f482205d79432297749ac5d412fe638154fb6f1d/msgpack-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6827d12eacc16873eba62408a1b7bbe8ecfb4a8f7ed78a631ae9bae6ad43cf2", size = 405618, upload-time = "2026-06-11T04:15:26.235Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/63/68f5d0ea81e167db5f59ddb94dc6f837667062113feff1c73fabf8907061/msgpack-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a186027e4279efa4c8bf06ce30605498d7d0d3af0fba0b9799dce85a3fd4a93c", size = 416468, upload-time = "2026-06-11T04:15:27.732Z" },
+    { url = "https://files.pythonhosted.org/packages/73/58/567dddf5c5a2790f673bcd7d80c83466d68e5ee9a9674ebca3db8101c0c8/msgpack-1.2.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a96142c14a11cf1a509e8b9aaf72858a3b742b7613e095ce646913e88ce7bd99", size = 374464, upload-time = "2026-06-11T04:15:29.286Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/30/0c2342fc9092e4498045f5f60bca6ccbe4f4d87789778c2300e6fd6efe82/msgpack-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:50c220579b68a6085b95408b2eaa486b259520f55d8e363ddc9b5d7ba5a6ac6d", size = 395879, upload-time = "2026-06-11T04:15:30.973Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/11/9565b29b58ce3c33e177b490478b7aaeb8f726ecaaeda26d815893c1db5a/msgpack-1.2.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4dcb9d12ab100ecacdfaaf37a3d72fe8392eacc7054afc1916b12d1b747c8446", size = 371749, upload-time = "2026-06-11T04:15:32.418Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/da/7bade19d60b73e2ef73fb76aaf4504c112a70cb760951b7202a0c64b5111/msgpack-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a804727188ab0ebb237fadb303b743f04925a69d8c3247292d1e33e679767c15", size = 410416, upload-time = "2026-06-11T04:15:34.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/14/c0c619571c02432208a5977a8dbdd3fc65fe1369f8226ca4b6d08cca87d8/msgpack-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1a1ac6ae1fe23298f79380e7b144c8a454e5d05616b0096584f353ba2d750114", size = 64357, upload-time = "2026-06-11T04:15:35.535Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a5/de06718460909aa965737fec4cfe8a15dedc6544a8c55feeb6956fa0d6e3/msgpack-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:1c3c80949d79578f9dc85fd9fb91edfe6694e8a729cd5744634d59d8455fdde3", size = 71057, upload-time = "2026-06-11T04:15:36.83Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/52/73446b0141c94a856e22b787c56709c0815fc34f185326577e15b26d8cfe/msgpack-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:fcf8f76fa587c2395fd0057c7232dbf071241f9ad280b235adb7ab585289989e", size = 64490, upload-time = "2026-06-11T04:15:38.001Z" },
+    { url = "https://files.pythonhosted.org/packages/35/3d/a7e3cdafa8c0cf36c81e2fa848ec4d30cf089459af45b390ad03f9ce6f49/msgpack-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f854fa1a8b55d75d82ef9a905d9cdbeffdf7897c088f6020bd221867da5e56a5", size = 83032, upload-time = "2026-06-11T04:15:39.38Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/aa/53ddfba0e347cc4b484e95f629c5850b9e800ca8390c91ffc604407acf87/msgpack-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e90df581f80f53b372d5d9d9349078d729851a3a0d0bd74f53ccb598d01e45b8", size = 82600, upload-time = "2026-06-11T04:15:40.609Z" },
+    { url = "https://files.pythonhosted.org/packages/59/fd/e64c2c776e6dbad0af3c963fe0c0dd1ee1ba09efac478b233ab1db41868f/msgpack-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b276ed50d8ac75d1f134a433ae79af8557d0fa25ee5b4737da533dfc2ce382e8", size = 404342, upload-time = "2026-06-11T04:15:41.87Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/60/fb9a08e6ccba882dfd370a5837fe3a07572938fdfe954f0f17fdf3e574b9/msgpack-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:544d972459c92aa32e63b800d07c2d9cf2734a3be29cee3a0b478a622850e9f5", size = 412351, upload-time = "2026-06-11T04:15:43.253Z" },
+    { url = "https://files.pythonhosted.org/packages/37/4d/df5c575c274fedc68ac9c6c61d045161899efad2afcdc25138efa7edde69/msgpack-1.2.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a070147cc2cf6b8a891734e0f5c8fe8f70ed8739ab30ba140b058005a6e86af4", size = 373331, upload-time = "2026-06-11T04:15:44.754Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a4/c8b98f8191e985ed2003d87664ce3c95cca41db5d0cf6bf4f54327d32ec8/msgpack-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7685e23b0f51745a751629c31713fbefdef8896b31b2bb38299dfa4ae6c0740c", size = 394654, upload-time = "2026-06-11T04:15:46.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/49/76f036720a602ea24428cfec5ec806f2487c0380b1bff0a2aa3094e15f87/msgpack-1.2.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b9204daeee8d91a7ae5acf2d2a8e3983be9a3025f38aa21bfaefbd7eea84a7dc", size = 370624, upload-time = "2026-06-11T04:15:48.062Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/38/40af3d29232833705a43b0fce0d07425cc280a7b92ab2b29932425b40df4/msgpack-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bfc057248609742ebbabf6bcd27fea4fd99c4980584e613c168c9b002318298f", size = 408038, upload-time = "2026-06-11T04:15:49.669Z" },
+    { url = "https://files.pythonhosted.org/packages/30/b2/f140ca450524dff4d8d0eb81eb9ed75f8f3e0b1f12e49c5b01617cfa0b1c/msgpack-1.2.0-cp314-cp314-win32.whl", hash = "sha256:a3faa7edf2388337ae849239878e92f0298b4dab4488e4f1834062f9d0c410c9", size = 65823, upload-time = "2026-06-11T04:15:51.062Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/13/6517bf966b841c7675ded30701a068ce141f3e698a27aaa35c702d8e078b/msgpack-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:1a3effc392a57744e4681e55d05f97d5ee7b598747d718340a9b4b8a970c40e1", size = 72484, upload-time = "2026-06-11T04:15:52.289Z" },
+    { url = "https://files.pythonhosted.org/packages/45/8c/1d948420fdaa24de4efdb8012a6a5bebe09c82ee002b8c2ca745e9917f1f/msgpack-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:56a318f7df6bec7b40928d6b0519961f20a510d8baabf6baa393a70444588f0a", size = 66657, upload-time = "2026-06-11T04:15:53.583Z" },
+    { url = "https://files.pythonhosted.org/packages/39/16/1674faa1b7bddc19e79b465fd8e88e2cf4e3f7cae90723740701e8541068/msgpack-1.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:afa4a65ab2097795e771a74a3a81ea49534aaeba874eaf426a3332268e045ae6", size = 86093, upload-time = "2026-06-11T04:15:54.98Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/24/f241bcfdd9e96b2246289357c5a5e5a496189fd41c5844bee802c116aac7/msgpack-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:409550770632bb28daa70a11d0ed5763f7db38f40b06f7db9f11dd2794d01102", size = 86372, upload-time = "2026-06-11T04:15:56.381Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c9/57f8ab98a1b21808c27b6dd6029053e0a796ffbb9b371e460dbe997011a9/msgpack-1.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf47e3cd11ce044965a9736a322afdd390b31ed602d1c1b10211d1a841f1d587", size = 428207, upload-time = "2026-06-11T04:15:57.739Z" },
+    { url = "https://files.pythonhosted.org/packages/17/6b/4fd4aa739f131ded751ca7167c8ee87d2aab32506ebbeea893b60b51d343/msgpack-1.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:204bc9f5d6e59c1718c0a4a84fc8ff71b5b4562faac257c1a68bca611ecf9b72", size = 426082, upload-time = "2026-06-11T04:15:59.356Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/00/db88e9a08fcd6513decaad06cbd5c168142bc3e662fb2f1aca3a563b7aa1/msgpack-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:610154307b27267266368bc1d1c7bb8aeb71da7be9356d403cb2442d9e6399f5", size = 378355, upload-time = "2026-06-11T04:16:00.916Z" },
+    { url = "https://files.pythonhosted.org/packages/54/84/eee4dd703d7a600cf46159d621c070b0b9468cf3dbade4ea8272bf5232a4/msgpack-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6799f157bb63e79f11e2e590cfdb28423fc18dd60c270c3914b5b4586ae36f7e", size = 410848, upload-time = "2026-06-11T04:16:02.745Z" },
+    { url = "https://files.pythonhosted.org/packages/12/0a/195e2c549fd4631eb7f157d016ff15a10c4c1cf82b6d0a9b1edaef5174b1/msgpack-1.2.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:72bd844902cf0a5ac3af2ef742f253cd0b1e5bcd184f49b4fb9a6a1f7bf305e8", size = 376152, upload-time = "2026-06-11T04:16:04.041Z" },
+    { url = "https://files.pythonhosted.org/packages/45/9b/bdd143fa79baec411dc658f5686fed680a18b36fcea5fccb6af1b8c7d832/msgpack-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3c0bd450f78d0d81722c80da6cdbf674a856967870a9db2f6c4debc4d8b3c67c", size = 417061, upload-time = "2026-06-11T04:16:05.63Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ce/011ffcd8b919f55196ec53f12ae162e21c879d95afba226894314ff62c07/msgpack-1.2.0-cp314-cp314t-win32.whl", hash = "sha256:378caf74c4c718dfc17590ce68a6d710ed398ff6fcf08237de23b77755730b55", size = 70782, upload-time = "2026-06-11T04:16:07.105Z" },
+    { url = "https://files.pythonhosted.org/packages/57/a8/9b8791ca96b1be6b9f659c718271e2cb7f99f73f58aad2dd0b30f750f6c0/msgpack-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:553b42598165c4dd3235994fd6e4b0dfb1ce5f3fd33d94ba9609442643015f38", size = 77899, upload-time = "2026-06-11T04:16:08.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/04/3fa2dffb87bf598696b86bde7cd642d0a7590520c3fa24cd19611dfebeb7/msgpack-1.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2825bb1da548d214ab8a810906b7dd69a10f3838b615a2cc46e5172d3cb44f6e", size = 71004, upload-time = "2026-06-11T04:16:09.556Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "26.2"
@@ -497,3 +581,93 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
+
+[[package]]
+name = "zstandard"
+version = "0.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },
+    { url = "https://files.pythonhosted.org/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload-time = "2025-09-14T22:15:58.177Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload-time = "2025-09-14T22:16:00.165Z" },
+    { url = "https://files.pythonhosted.org/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload-time = "2025-09-14T22:16:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload-time = "2025-09-14T22:16:04.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload-time = "2025-09-14T22:16:06.312Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload-time = "2025-09-14T22:16:08.457Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload-time = "2025-09-14T22:16:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload-time = "2025-09-14T22:16:12.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload-time = "2025-09-14T22:16:14.225Z" },
+    { url = "https://files.pythonhosted.org/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload-time = "2025-09-14T22:16:16.343Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload-time = "2025-09-14T22:16:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload-time = "2025-09-14T22:16:20.559Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload-time = "2025-09-14T22:16:22.206Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload-time = "2025-09-14T22:16:25.002Z" },
+    { url = "https://files.pythonhosted.org/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload-time = "2025-09-14T22:16:23.569Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload-time = "2025-09-14T22:16:26.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload-time = "2025-09-14T22:16:27.973Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload-time = "2025-09-14T22:16:29.523Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload-time = "2025-09-14T22:16:31.811Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload-time = "2025-09-14T22:16:33.486Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload-time = "2025-09-14T22:16:35.277Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload-time = "2025-09-14T22:16:37.141Z" },
+    { url = "https://files.pythonhosted.org/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload-time = "2025-09-14T22:16:38.807Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload-time = "2025-09-14T22:16:40.523Z" },
+    { url = "https://files.pythonhosted.org/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload-time = "2025-09-14T22:16:43.3Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload-time = "2025-09-14T22:16:45.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload-time = "2025-09-14T22:16:47.076Z" },
+    { url = "https://files.pythonhosted.org/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload-time = "2025-09-14T22:16:49.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload-time = "2025-09-14T22:16:51.328Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload-time = "2025-09-14T22:16:55.005Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload-time = "2025-09-14T22:16:52.753Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload-time = "2025-09-14T22:16:53.878Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" },
+    { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" },
+    { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" },
+    { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" },
+    { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" },
+    { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload-time = "2025-09-14T22:17:54.198Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload-time = "2025-09-14T22:17:55.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload-time = "2025-09-14T22:17:57.372Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload-time = "2025-09-14T22:17:59.498Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload-time = "2025-09-14T22:18:01.618Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload-time = "2025-09-14T22:18:03.769Z" },
+    { url = "https://files.pythonhosted.org/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload-time = "2025-09-14T22:18:05.954Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload-time = "2025-09-14T22:18:07.68Z" },
+    { url = "https://files.pythonhosted.org/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload-time = "2025-09-14T22:18:09.753Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload-time = "2025-09-14T22:18:11.966Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload-time = "2025-09-14T22:18:13.907Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload-time = "2025-09-14T22:18:16.465Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload-time = "2025-09-14T22:18:20.61Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload-time = "2025-09-14T22:18:17.849Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload-time = "2025-09-14T22:18:19.088Z" },
+]