refactor(api): namespaced SDK + dedicated transport layer

Restructure the Python API and internals around composable namespaces and
a standalone transport/endpoint layer. Bump to 0.12.0.

Python API:
- Replace flat methods (b.tabs_list(), b.group_list()) with namespaces:
  b.nav, b.tabs, b.groups, b.windows, b.dom, b.extract, b.page, b.storage,
  b.cookies, b.session, b.perf, b.extension.
- Shrink browser_cli/__init__.py to a thin composition root; move all
  behaviour into browser_cli/sdk/ (one module per namespace + factories,
  base, routing).

Internals:
- Add browser_cli/transport.py and remote_transport.py to isolate IPC from
  command logic; client.py now delegates instead of owning transport.
- Add browser_cli/endpoints.py for endpoint resolution and
  browser_cli/errors.py for shared error types.
- Extract markdown rendering into browser_cli/markdown.py (out of extract).
- Add USER_AGENT to version_manager.

Tooling & tests:
- Add justfile with common dev tasks.
- Update CLI commands and demo to the namespaced API.
- Rework tests for the new layout; add test_transport.py and
  test_refactor_boundaries.py to lock in module boundaries.

BREAKING CHANGE: flat API methods are removed in favour of namespaces
(e.g. b.tabs_list() -> b.tabs.list(), b.group_list() -> b.groups.list()).

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):