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