dropbear 0.1.0a1__py3-none-any.whl

dropbear/__init__.py

@@ -0,0 +1,41 @@
+"""Dropbear - fast serverless inference for your robots."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING
+
+try:
+    __version__ = version("dropbear")
+except PackageNotFoundError:  # Direct source import outside an installed environment.
+    __version__ = "0+unknown"
+
+from dropbear import franka, libero, so101
+from dropbear.policy import RegionPreference, RunHooks, RunStrategy, aconnect, connect
+
+if TYPE_CHECKING:
+    from dropbear.arm import Arm
+
+
+def connect_so101(*, region: RegionPreference = "nearest") -> Arm:
+    """Connect to the legacy physical SO-101 control path.
+
+    Prefer dropbear.connect(model="molmoact2-so101", ...) for new cloud-policy work.
+    """
+    from dropbear.arm import connect_so101 as _connect
+
+    return _connect(region=region)
+
+
+__all__ = [
+    "RunHooks",
+    "RunStrategy",
+    "RegionPreference",
+    "aconnect",
+    "connect",
+    "connect_so101",
+    "franka",
+    "libero",
+    "so101",
+    "__version__",
+]

dropbear/arm.py

@@ -0,0 +1,431 @@
+"""connect_so101() and the Arm handle (spec §8).
+
+Zero args: ~/.dropbear/config.toml supplies everything. Owns session acquisition
+(reusing quickstart's pre-warm), UDP preflight, pinned QUIC connect, the LeRobot
+hardware adapter, the 30 Hz safety loop, heartbeats, and reconnect-on-freeze.
+Dependency-injection and tuning knobs live behind _connect_so101_internal().
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import threading
+from collections.abc import Callable
+from contextlib import suppress
+from typing import Any
+
+import httpx
+import numpy as np
+
+from dropbear import errors, wire
+from dropbear.config import Config, load_config
+from dropbear.constants import FIRST_ACTION_TIMEOUT_S, MODEL_SO101
+from dropbear.control import ControlPlaneClient, Session
+from dropbear.motion.loop import ControlLoop, LoopResult
+from dropbear.motion.safety import EStop, SpacebarEStop, install_sigint_estop
+from dropbear.policy.lifecycle import _LoopRunner
+from dropbear.policy.types import RegionPreference
+from dropbear.sessions import Heartbeat, acquire_session, stop_session
+from dropbear.state import load_state
+from dropbear.transport_selection import connect_selected_transport
+
+
+def _default_transport_connect(addr: str, port: int, *, cert_fingerprint: str,
+                               session_id: str, session_token: str):
+    from dropbear_transport import QuicClient
+
+    return QuicClient.connect(addr, port, cert_fingerprint=cert_fingerprint,
+                              session_id=session_id, session_token=session_token)
+
+
+def _default_confirm_retry() -> bool:
+    answer = input("AWS is out of GPU capacity. Auto-retry with backoff? [Y/n] ")
+    return answer.strip().lower() != "n"
+
+
+def _default_doctor_runner() -> None:
+    from dropbear.doctor import assert_motion_ready
+
+    assert_motion_ready()
+
+
+def connect_so101(
+    *,
+    region: RegionPreference = "nearest",
+) -> Arm:
+    """Connect to the physical SO-101 compatibility control loop."""
+    return _connect_so101_internal(region=region)
+
+
+def _connect_so101_internal(
+    *,
+    client_factory: Callable[..., Any] = ControlPlaneClient,
+    transport_connect: Callable[..., Any] = _default_transport_connect,
+    robot_factory: Callable[[], Any] | None = None,
+    preflight_fn: Callable[..., Any] | None = None,
+    allow_fallback: bool = True,
+    relay_connect: Callable[..., Any] | None = None,
+    doctor_runner: Callable[[], None] = _default_doctor_runner,
+    on_line: Callable[[str], None] = print,
+    confirm_retry: Callable[[], bool] = _default_confirm_retry,
+    duration_default_s: float = 60.0,
+    first_action_timeout_s: float = FIRST_ACTION_TIMEOUT_S,
+    region: RegionPreference = "nearest",
+    idle_timeout: int | None = None,
+) -> Arm:
+    """Internal SO-101 connector with dependency-injection hooks for tests/tools."""
+    config = load_config()
+    if not config.api_key:
+        raise errors.catalog("not_configured")
+    if robot_factory is None:
+        robot_factory = _make_default_robot_factory(config)
+    if preflight_fn is None:
+        from dropbear_transport import diagnose_udp as preflight_fn
+    preflight_fn = _compatible_diagnose_udp(preflight_fn)
+
+    runner = _LoopRunner()
+    try:
+        return runner.run(_connect_async(
+            runner=runner, config=config, client_factory=client_factory,
+            transport_connect=transport_connect, robot_factory=robot_factory,
+            preflight_fn=preflight_fn, allow_fallback=allow_fallback,
+            relay_connect=relay_connect, doctor_runner=doctor_runner, on_line=on_line,
+            confirm_retry=confirm_retry, duration_default_s=duration_default_s,
+            first_action_timeout_s=first_action_timeout_s,
+            region=region, idle_timeout=idle_timeout,
+        ))
+    except BaseException:
+        runner.shutdown()
+        raise
+
+
+def _make_default_robot_factory(config: Config) -> Callable[[], Any]:
+    def factory():
+        from dropbear.hardware.lerobot_so101 import create_so101
+        from dropbear.optional import require_so101_extra
+
+        require_so101_extra()
+        if config.robot_port is None:
+            raise errors.catalog("robot_port_not_found", port="(none configured)")
+        if config.camera_index is None or config.wrist_camera_index is None:
+            raise errors.catalog("camera_pair_not_configured")
+        return create_so101(port=config.robot_port,
+                            side_camera_index=config.camera_index,
+                            wrist_camera_index=config.wrist_camera_index,
+                            calibration_path=config.calibration_path)
+
+    return factory
+
+
+async def _connect_async(*, runner, config, client_factory, transport_connect,
+                         robot_factory, preflight_fn, allow_fallback,
+                         relay_connect, doctor_runner, on_line, confirm_retry,
+                         duration_default_s, first_action_timeout_s,
+                         region="nearest", idle_timeout=None) -> Arm:
+    client = None
+    session: Session | None = None
+    transport = None
+    robot = None
+    robot_connect_attempted = False
+    heartbeat: Heartbeat | None = None
+    try:
+        client = client_factory(config.control_plane_url, config.api_key)
+        session = await acquire_session(client, MODEL_SO101, on_progress=on_line,
+                                        region=region, idle_timeout=idle_timeout,
+                                        confirm_retry=confirm_retry)
+
+        async def quic_connect(ready_session: Session):
+            return await _pin_connect(transport_connect, ready_session)
+
+        async def relay_connect_for_session(ready_session: Session):
+            connect = relay_connect or getattr(client, "connect_relay", None)
+            if connect is None:
+                raise errors.catalog(
+                    "relay_unavailable",
+                    retry_command="dropbear run pick-place",
+                )
+            return await connect(ready_session)
+
+        transport = await connect_selected_transport(
+            session,
+            diagnose_udp_fn=preflight_fn,
+            quic_connect=quic_connect,
+            relay_connect=relay_connect_for_session,
+            allow_fallback=allow_fallback,
+            on_line=on_line,
+            report_transport_fn=getattr(client, "report_transport", None),
+        )
+        robot = robot_factory()
+        robot_connect_attempted = True
+        await asyncio.to_thread(robot.connect)
+        # Pre-warm the JPEG encoder: wire.encode_jpeg lazily imports cv2, whose
+        # first call costs ~200-700 ms cold. Python's import lock holds the GIL
+        # through the dlopen, so asyncio.to_thread cannot keep that one-time cost
+        # off the event loop — it would starve the 30 Hz executor on the first
+        # do(). Pay it here, before any timed loop exists.
+        await asyncio.to_thread(wire.encode_jpeg, np.zeros((8, 8, 3), dtype=np.uint8))
+        heartbeat = Heartbeat(client, session.session_id)
+        heartbeat.start()
+
+        try:
+            status = await client.status()
+            active = int(status.get(MODEL_SO101, {}).get("active_sessions", 0))
+            if active >= 2:
+                on_line(f"{active - 1} other session(s) are sharing this GPU — "
+                        "motion will be slower than usual")
+        except (errors.DropbearError, httpx.HTTPError):
+            pass
+
+        return Arm(runner=runner, client=client, session=session, transport=transport,
+                   transport_connect=transport_connect, diagnose_udp_fn=preflight_fn,
+                   allow_fallback=allow_fallback, relay_connect=relay_connect,
+                   robot=robot, heartbeat=heartbeat, on_line=on_line,
+                   doctor_runner=doctor_runner, duration_default_s=duration_default_s,
+                   first_action_timeout_s=first_action_timeout_s)
+    except BaseException:
+        await _cleanup_connect_failure(
+            client=client,
+            session=session,
+            transport=transport,
+            robot=robot,
+            robot_connect_attempted=robot_connect_attempted,
+            heartbeat=heartbeat,
+        )
+        raise
+
+
+def _compatible_diagnose_udp(preflight_fn: Callable[..., Any]) -> Callable[..., Any]:
+    async def diagnose(addr: str, port: int, **kwargs):
+        call_kwargs = _accepted_preflight_kwargs(preflight_fn, kwargs)
+        result = preflight_fn(addr, port, **call_kwargs)
+        if inspect.isawaitable(result):
+            result = await result
+        return _as_udp_reachability_report(result)
+
+    return diagnose
+
+
+def _accepted_preflight_kwargs(preflight_fn: Callable[..., Any],
+                               kwargs: dict[str, Any]) -> dict[str, Any]:
+    try:
+        params = inspect.signature(preflight_fn).parameters
+    except (TypeError, ValueError):
+        return kwargs
+    if any(param.kind == inspect.Parameter.VAR_KEYWORD for param in params.values()):
+        return kwargs
+    return {key: value for key, value in kwargs.items() if key in params}
+
+
+def _as_udp_reachability_report(result: Any) -> Any:
+    if hasattr(result, "ok") and hasattr(result, "worker"):
+        return result
+    if not hasattr(result, "status"):
+        return result
+    from dropbear_transport import PreflightResult, UdpReachabilityReport
+
+    status = result.status
+    remediation = getattr(result, "remediation", "")
+    reason = "ok"
+    if status == "udp_blocked":
+        reason = "udp_refused"
+    elif status != "ok":
+        reason = "data_plane_unreachable"
+    return UdpReachabilityReport(
+        worker=PreflightResult(status=status, remediation=remediation),
+        diagnostic=None,
+        reason=reason,
+        remediation="" if status == "ok" else remediation,
+    )
+
+
+async def _cleanup_connect_failure(*, client, session, transport, robot,
+                                   robot_connect_attempted: bool,
+                                   heartbeat: Heartbeat | None) -> None:
+    if heartbeat is not None:
+        with suppress(Exception):
+            await heartbeat.stop()
+    if transport is not None:
+        with suppress(Exception):
+            await transport.close()
+    if robot is not None and robot_connect_attempted:
+        with suppress(Exception):
+            await asyncio.to_thread(robot.disconnect)
+    if client is not None and session is not None:
+        with suppress(Exception):
+            await stop_session(client, session.session_id, clear_prewarm_state=True)
+    if client is not None:
+        with suppress(Exception):
+            await client.close()
+
+
+async def _pin_connect(transport_connect, session: Session):
+    try:
+        return await transport_connect(
+            session.worker_addr, session.port,
+            cert_fingerprint=session.cert_fingerprint,
+            session_id=session.session_id,
+            session_token=session.session_token,
+        )
+    except errors.DropbearError:
+        raise
+    except Exception as exc:
+        text = str(exc).lower()
+        if "fingerprint" in text or "pin" in text:
+            raise errors.catalog("cert_fingerprint_mismatch") from exc
+        raise
+
+
+class Arm:
+    """Live handle: arm.do(instruction), arm.estop(), arm.close(), context manager."""
+
+    def __init__(self, *, runner, client, session, transport, transport_connect,
+                 diagnose_udp_fn, allow_fallback, relay_connect, robot, heartbeat,
+                 on_line, doctor_runner, duration_default_s, first_action_timeout_s) -> None:
+        self._runner = runner
+        self._client = client
+        self._session = session
+        self._transport = transport
+        self._transport_connect = transport_connect
+        self._diagnose_udp_fn = diagnose_udp_fn
+        self._allow_fallback = allow_fallback
+        self._relay_connect = relay_connect
+        self._robot = robot
+        self._heartbeat = heartbeat
+        self._on_line = on_line
+        self._doctor_runner = doctor_runner
+        self._duration_default_s = duration_default_s
+        self._first_action_timeout_s = first_action_timeout_s
+        self._active_estop: EStop | None = None
+        self._closed = False
+
+    def do(self, instruction: str, duration_s: float | None = None) -> LoopResult:
+        config = load_config()
+        if config.motion_enabled:
+            self._ensure_doctor()
+        estop = EStop()
+        self._active_estop = estop
+        # signal handlers may only be installed from the main thread
+        if threading.current_thread() is threading.main_thread():
+            restore = install_sigint_estop(estop)
+        else:
+            def restore() -> None:
+                return None
+        keys = SpacebarEStop(estop)
+        keys.start()
+        mode = "LIVE" if config.motion_enabled else "DRY RUN (no motion until you enable it)"
+        self._on_line(f"{mode} — press SPACE or Ctrl-C to e-stop.")
+        try:
+            return self._runner.run(self._do_async(
+                instruction, duration_s or self._duration_default_s, estop,
+                config.motion_enabled,
+            ))
+        finally:
+            keys.stop()
+            restore()
+            self._active_estop = None
+
+    def _ensure_doctor(self) -> None:
+        if load_state().doctor_last_pass is None:
+            self._on_line("First motion run — running checks (dropbear doctor)…")
+            self._doctor_runner()  # raises DropbearError on failure
+
+    async def _do_async(self, instruction: str, duration_s: float, estop: EStop,
+                        motion_enabled: bool) -> LoopResult:
+        reconnects = 0
+        while True:
+            loop = ControlLoop(
+                transport=self._transport, robot=self._robot,
+                session_id=self._session.session_id, instruction=instruction,
+                motion_enabled=motion_enabled, estop=estop, duration_s=duration_s,
+                on_line=self._on_line,
+                first_action_timeout_s=self._first_action_timeout_s,
+            )
+            result = await loop.run()
+            if not result.froze:
+                return result
+            self._on_line(errors.catalog("connection_lost").render())
+            if reconnects >= 1:
+                raise errors.catalog("connection_lost")
+            reconnects += 1
+            prefer_relay = (
+                self._allow_fallback
+                and getattr(self._transport, "mode", None) == "quic"
+                and result.freeze_reason in {"transport_lost", "first_action_timeout"}
+            )
+            await self._reconnect(prefer_relay=prefer_relay)
+
+    async def _reconnect(self, *, prefer_relay: bool = False) -> None:
+        try:
+            await self._transport.close()
+        except Exception:  # noqa: BLE001 — best-effort close of a dead transport
+            pass
+        refreshed = await self._client.get_session(self._session.session_id)
+        if refreshed.status not in ("ready", "active"):
+            raise errors.catalog("session_expired")
+        if refreshed.session_token:
+            self._session = refreshed
+
+        async def quic_connect(ready_session: Session):
+            return await _pin_connect(self._transport_connect, ready_session)
+
+        async def relay_connect_for_session(ready_session: Session):
+            connect = self._relay_connect or getattr(self._client, "connect_relay", None)
+            if connect is None:
+                raise errors.catalog(
+                    "relay_unavailable",
+                    retry_command="dropbear run pick-place",
+                )
+            return await connect(ready_session)
+
+        if prefer_relay:
+            self._on_line("QUIC/UDP stopped delivering actions; using HTTPS fallback.")
+            self._on_line("Motion may feel less responsive while using fallback.")
+            self._transport = await relay_connect_for_session(self._session)
+            self._transport.mode = getattr(self._transport, "mode", "relay")
+            self._transport.fallback_reason = "quic_runtime_lost"
+            self._transport.primary_preflight_status = None
+            self._transport.diagnostic_preflight_status = None
+        else:
+            self._transport = await connect_selected_transport(
+                self._session,
+                diagnose_udp_fn=self._diagnose_udp_fn,
+                quic_connect=quic_connect,
+                relay_connect=relay_connect_for_session,
+                allow_fallback=self._allow_fallback,
+                on_line=self._on_line,
+                report_transport_fn=getattr(self._client, "report_transport", None),
+            )
+        self._on_line("Reconnected.")
+
+    def estop(self) -> None:
+        if self._active_estop is not None:
+            self._active_estop.trigger("api")
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            self._runner.run_cleanup(self._close_async())
+        finally:
+            self._runner.shutdown()
+
+    async def _close_async(self) -> None:
+        with suppress(Exception):
+            await self._heartbeat.stop()
+        with suppress(Exception):
+            await self._transport.close()
+        with suppress(Exception):
+            await stop_session(self._client, self._session.session_id,
+                               clear_prewarm_state=True)
+        with suppress(Exception):
+            await self._client.close()
+        with suppress(Exception):
+            await asyncio.to_thread(self._robot.disconnect)
+
+    def __enter__(self) -> Arm:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()

dropbear/assets/camera_reference.svg

@@ -0,0 +1,82 @@
+<svg viewBox="0 0 960 540" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="Dropbear golden-path camera setup reference">
+  <title>Dropbear camera setup: third-person side webcam for the SO-101 golden path</title>
+  <rect width="960" height="540" fill="#FAF7F2"/>
+  <text x="32" y="44" font-family="sans-serif" font-size="24" font-weight="700" fill="#1F2933">Camera setup — third-person side view</text>
+  <text x="32" y="68" font-family="sans-serif" font-size="14" fill="#52606D">Match this layout, then check your live preview against the framing guide on the right.</text>
+
+  <!-- ============ LEFT PANEL: top view geometry ============ -->
+  <text x="32" y="108" font-family="sans-serif" font-size="15" font-weight="700" fill="#1F2933">Top view</text>
+  <rect x="32" y="120" width="420" height="270" rx="8" fill="#FFFFFF" stroke="#CBD2D9"/>
+  <!-- table -->
+  <rect x="72" y="150" width="340" height="150" rx="4" fill="#F1EDE6" stroke="#9AA5B1"/>
+  <text x="242" y="316" font-family="sans-serif" font-size="12" fill="#52606D" text-anchor="middle">table</text>
+  <!-- arm base -->
+  <rect x="340" y="195" width="44" height="60" rx="4" fill="#3E4C59"/>
+  <text x="362" y="186" font-family="sans-serif" font-size="12" font-weight="700" fill="#1F2933" text-anchor="middle">SO-101 base</text>
+  <!-- workspace -->
+  <rect x="120" y="185" width="170" height="80" rx="4" fill="none" stroke="#7B8794" stroke-dasharray="6 4"/>
+  <text x="205" y="230" font-family="sans-serif" font-size="12" fill="#52606D" text-anchor="middle">Workspace (props)</text>
+  <!-- reach arrow arm->workspace -->
+  <line x1="340" y1="225" x2="296" y2="225" stroke="#7B8794" stroke-width="2"/>
+  <text x="318" y="216" font-family="sans-serif" font-size="11" fill="#52606D" text-anchor="middle">~25 cm</text>
+  <!-- webcam -->
+  <g>
+    <rect x="190" y="430" width="48" height="26" rx="6" fill="#3E4C59"/>
+    <circle cx="214" cy="443" r="7" fill="#FAF7F2"/>
+    <circle cx="214" cy="443" r="3.5" fill="#1F2933"/>
+    <text x="214" y="478" font-family="sans-serif" font-size="13" font-weight="700" fill="#1F2933" text-anchor="middle">Webcam</text>
+  </g>
+  <!-- distance webcam->table, side-on angle -->
+  <line x1="214" y1="430" x2="214" y2="300" stroke="#7B8794" stroke-width="2" stroke-dasharray="4 4"/>
+  <text x="226" y="372" font-family="sans-serif" font-size="12" fill="#52606D">60–80 cm</text>
+  <text x="226" y="390" font-family="sans-serif" font-size="12" fill="#52606D">side-on (90° to arm)</text>
+
+  <!-- ============ MIDDLE PANEL: side view ============ -->
+  <text x="492" y="108" font-family="sans-serif" font-size="15" font-weight="700" fill="#1F2933">Side view</text>
+  <rect x="492" y="120" width="200" height="270" rx="8" fill="#FFFFFF" stroke="#CBD2D9"/>
+  <!-- table line -->
+  <line x1="512" y1="330" x2="672" y2="330" stroke="#9AA5B1" stroke-width="3"/>
+  <!-- arm silhouette -->
+  <rect x="618" y="296" width="22" height="34" fill="#3E4C59"/>
+  <line x1="629" y1="296" x2="600" y2="250" stroke="#3E4C59" stroke-width="7" stroke-linecap="round"/>
+  <line x1="600" y1="250" x2="566" y2="276" stroke="#3E4C59" stroke-width="6" stroke-linecap="round"/>
+  <!-- props -->
+  <rect x="540" y="318" width="12" height="12" fill="#7B8794"/>
+  <!-- camera at lens height -->
+  <rect x="500" y="266" width="26" height="16" rx="4" fill="#3E4C59"/>
+  <line x1="526" y1="274" x2="556" y2="296" stroke="#7B8794" stroke-width="1.5" stroke-dasharray="3 3"/>
+  <!-- lens height above table -->
+  <line x1="513" y1="282" x2="513" y2="330" stroke="#7B8794" stroke-width="2" stroke-dasharray="4 4"/>
+  <text x="521" y="312" font-family="sans-serif" font-size="11" fill="#52606D">20–30 cm</text>
+  <text x="592" y="368" font-family="sans-serif" font-size="11" fill="#52606D" text-anchor="middle">lens just above prop height, slight downward tilt</text>
+
+  <!-- ============ RIGHT PANEL: framing guide ============ -->
+  <text x="732" y="108" font-family="sans-serif" font-size="15" font-weight="700" fill="#1F2933">Your frame should look like this</text>
+  <rect x="732" y="120" width="196" height="146" rx="8" fill="#FFFFFF" stroke="#CBD2D9"/>
+  <rect x="740" y="128" width="180" height="130" fill="#F1EDE6"/>
+  <!-- rule-of-thirds guides -->
+  <line x1="800" y1="128" x2="800" y2="258" stroke="#CBD2D9" stroke-width="1"/>
+  <line x1="860" y1="128" x2="860" y2="258" stroke="#CBD2D9" stroke-width="1"/>
+  <!-- arm in the right third -->
+  <rect x="872" y="206" width="16" height="32" fill="#3E4C59"/>
+  <line x1="880" y1="206" x2="852" y2="172" stroke="#3E4C59" stroke-width="5" stroke-linecap="round"/>
+  <line x1="852" y1="172" x2="824" y2="192" stroke="#3E4C59" stroke-width="4" stroke-linecap="round"/>
+  <!-- props middle third -->
+  <rect x="806" y="226" width="10" height="10" fill="#7B8794"/>
+  <rect x="826" y="228" width="10" height="8" fill="#9AA5B1"/>
+  <!-- table edge -->
+  <line x1="740" y1="238" x2="920" y2="238" stroke="#9AA5B1" stroke-width="2"/>
+  <text x="830" y="282" font-family="sans-serif" font-size="11" fill="#52606D" text-anchor="middle">whole arm + whole workspace visible,</text>
+  <text x="830" y="297" font-family="sans-serif" font-size="11" fill="#52606D" text-anchor="middle">nothing important on the frame edge</text>
+
+  <!-- ============ CHECKLIST ============ -->
+  <text x="732" y="336" font-family="sans-serif" font-size="14" font-weight="700" fill="#1F2933">Checklist</text>
+  <text x="732" y="358" font-family="sans-serif" font-size="12" fill="#3E4C59">• even, diffuse light — no backlight</text>
+  <text x="732" y="377" font-family="sans-serif" font-size="12" fill="#3E4C59">• plain background, no clutter</text>
+  <text x="732" y="396" font-family="sans-serif" font-size="12" fill="#3E4C59">• camera on a stable mount</text>
+  <text x="732" y="415" font-family="sans-serif" font-size="12" fill="#3E4C59">• 1080p, 16:9, landscape</text>
+  <text x="732" y="441" font-family="sans-serif" font-size="13" font-weight="700" fill="#B7410E">• Lock white balance + exposure</text>
+  <text x="744" y="459" font-family="sans-serif" font-size="11" fill="#B7410E">auto-WB drift mid-task confuses the model</text>
+
+  <text x="32" y="512" font-family="sans-serif" font-size="11" fill="#7B8794">dropbear/assets/camera_reference.svg — ships with the dropbear SDK; full recipe at /docs/golden-path</text>
+</svg>