captchakraken 3.0.0 → 3.2.0

package/python/src/captchakraken/page_solver.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import hashlib
+import io
 import itertools
 import json
+import math
 import os
 import random
 import re
@@ -16,21 +18,27 @@ import uuid
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, NamedTuple, Optional, Sequence, Tuple
+from typing import AbstractSet, Any, Callable, Dict, List, NamedTuple, Optional, Sequence, Set, Tuple
 
 from . import planner
 from .action_types import CaptchaAction
 from .humanize import Humanizer, resolve as resolve_humanizer
 from .kinds import (ActionKind, FrameRole, HumanizationMode, KeyframeMode, PauseKind, Phase, PromptFamily,
-                    RecaptchaBanner, RetryMode, SettleVerdict, Vendor)
+                    RecaptchaBanner, RetryMode, SettleVerdict, Vendor, Verdict)
 from .selectors import (ACCEPTED_SELECTORS, PIECE_SELECTORS, RESPONSE_SELECTORS, SELECTORS, SLIDER_HANDLE_SELECTORS,
                         SUBMIT_SELECTORS, TEXT_INPUT_SELECTORS, TEXT_INPUT_VENDOR_SELECTORS, VENDORS, WIDGET_PROBES,
                         VendorSelectors, WidgetProbe)
 from .solver import CaptchaSolver, UnsupportedCaptchaError
 from .timing import PhaseBudget, timings_enabled
+from .verdicts import RoundVerdict, VerdictLog
 
 DEBUG = os.getenv("CAPTCHA_DEBUG", "0") == "1"
 _SESSION_ENV = "CAPTCHA_KRAKEN_SESSION"
+_VENDOR_ENV = "CAPTCHA_KRAKEN_VENDOR"
+_SITE_ENV = "CAPTCHA_KRAKEN_SITE"
+_WIDGET_HOST_ENV = "CAPTCHA_KRAKEN_WIDGET_HOST"
+# How often a page that has not drawn its widget yet is looked at again.
+_DETECTION_POLL_MS = 250
 
 
 def _log(message: str) -> None:
@@ -70,6 +78,65 @@ def _sha1(path: str) -> str:
         return hashlib.sha1(fh.read()).hexdigest()
 
 
+class CaptureRect(NamedTuple):
+    """Whole CSS pixels, in viewport coordinates."""
+
+    x: int
+    y: int
+    width: int
+    height: int
+
+
+def enclosing_rect(box: Dict[str, float]) -> CaptureRect:
+    """The whole pixels a bounding box covers: the rect Playwright's element screenshot clips to."""
+    x, y = math.floor(box["x"] + 1e-3), math.floor(box["y"] + 1e-3)
+    return CaptureRect(x, y, math.ceil(box["x"] + box["width"] - 1e-3) - x,
+                       math.ceil(box["y"] + box["height"] - 1e-3) - y)
+
+
+def crop_png(png: bytes, rect: CaptureRect, css_width: float) -> bytes:
+    """Cut `rect` out of a viewport capture `css_width` CSS pixels wide, at the capture's own device pixel ratio."""
+    from PIL import Image
+
+    with Image.open(io.BytesIO(png)) as img:
+        scale = img.width / css_width
+        out = io.BytesIO()
+        img.crop((round(rect.x * scale), round(rect.y * scale), round((rect.x + rect.width) * scale),
+                  round((rect.y + rect.height) * scale))).save(out, format="PNG", compress_level=1)
+        return out.getvalue()
+
+
+_VIEWPORT_JS = "() => ({ width: window.innerWidth, height: window.innerHeight })"
+_FRAME_JS = ("() => ({ width: window.innerWidth, height: window.innerHeight,"
+             " scale: window.visualViewport ? window.visualViewport.scale : 1 })")
+
+
+def _viewport_of(page: Any) -> Dict[str, float]:
+    """`viewport_size` is None on a context launched without one (camoufox), where only the window knows."""
+    return page.viewport_size or page.evaluate(_VIEWPORT_JS)
+
+
+def _layout_is_the_viewport(page: Any, view: Dict[str, float]) -> bool:
+    """Does a viewport capture speak the bounding box's coordinates? Not on a page laid out wider than the device and zoomed out to fit, which is every mobile layout of a desktop page: there the box is in layout pixels and the capture is not."""
+    frame = page.evaluate(_FRAME_JS)
+    return abs(frame.get("scale", 1) - 1) < 1e-3 and abs(frame["width"] - view["width"]) <= 1
+
+
+def _within(rect: CaptureRect, view: Dict[str, float]) -> bool:
+    return rect.x >= 0 and rect.y >= 0 and rect.x + rect.width <= view["width"] and rect.y + rect.height <= view["height"]
+
+
+def _off_board_point(box: Dict[str, float], at: Tuple[float, float],
+                     view: Dict[str, float]) -> Optional[Tuple[float, float]]:
+    """A point just outside the board, past the edge nearest the pointer, that is still inside the viewport."""
+    x, y = at
+    gap = 24 + random.random() * 40
+    right, bottom = box["x"] + box["width"], box["y"] + box["height"]
+    exits = sorted([(x - box["x"], (box["x"] - gap, y)), (right - x, (right + gap, y)),
+                    (y - box["y"], (x, box["y"] - gap)), (bottom - y, (x, bottom + gap))])
+    return next((p for _, p in exits if 0 <= p[0] < view["width"] and 0 <= p[1] < view["height"]), None)
+
+
 class CaptchaSolveError(Exception):
     pass
 
@@ -90,16 +157,34 @@ class PageClosedError(CaptchaSolveError):
     pass
 
 
-_STALE_HANDLE_RE = re.compile(r"Timeout .*exceeded|not visible|not attached|detached", re.IGNORECASE)
+class VendorBlockedError(CaptchaSolveError):
+    """The vendor refused to serve this client at all, so no further round can succeed."""
+
+
+#: `bounding box of captcha element` is in here because the JS port has always had it
+#: (`isStaleHandleError`): a widget with no box has moved on under us — hCaptcha swapped rounds, GeeTest
+#: closed on accept — and re-detecting is right where failing the attempt is not. Without it the Python
+#: port turned an accepted board into a failed solve.
+_STALE_HANDLE_RE = re.compile(
+    r"Timeout .*exceeded|not visible|not attached|detached|bounding box of captcha element",
+    re.IGNORECASE)
 # A closed target is not a stale handle: retried as one, a dead page was re-detected three times and the
 # error that finally escaped named whichever call ran last.
 _CLOSED_TARGET_RE = re.compile(
     r"Target (?:page, context or browser )?(?:has been )?closed|Session closed", re.IGNORECASE)
 
 
-def answer_needs_element_box(actions: List[Dict[str, Any]]) -> bool:
-    """An allow-list of what needs nothing: the other direction raises instead of clicking at the origin."""
-    return any((a or {}).get("action") != ActionKind.DONE for a in actions)
+def answer_needs_element_box(actions: Sequence[Any]) -> bool:
+    """An allow-list of what needs nothing: the other direction raises instead of clicking at the origin.
+
+    Takes actions in EITHER shape. The planner returns typed actions (`ClickAction`, `TypeAction`,
+    `DoneAction`) and every other reader here goes through `_as_dict` first; this one called `.get` on
+    them. It only runs when the element has no bounding box, which is what a widget that is CLOSING
+    looks like — so a solve the vendor had just accepted ended as
+    `AttributeError: 'ClickAction' object has no attribute 'get'` instead of as a success. Tier 3 saw
+    it as a lost solve on five types.
+    """
+    return any(_as_dict(a).get("action") != ActionKind.DONE for a in actions if a is not None)
 
 
 @dataclass
@@ -108,6 +193,8 @@ class SolveResult:
     final_mouse_position: Tuple[float, float]
     token_usage: List[Dict[str, Any]] = field(default_factory=list)
     phases: Dict[str, float] = field(default_factory=dict)
+    # What the vendor's own server answered, in order, for the vendors whose answer is readable.
+    verdicts: List[RoundVerdict] = field(default_factory=list)
 
 
 @dataclass
@@ -160,6 +247,9 @@ def measured_fps(frames: int, elapsed_ms: float, nominal_fps: float) -> float:
 _MOVED_DURING_INFERENCE_DIFF = 0.002
 _NOT_THIS_BOARD_DIFF = 0.5
 _NOT_THIS_BOARD_POLLS = 3
+# How long a control we hovered, pressed or typed into takes to stop repainting in reaction. A board read
+# inside this window is wearing our own feedback, which is not a screen it ever showed by itself.
+INPUT_SETTLE_MS = 400
 
 
 @dataclass
@@ -172,13 +262,20 @@ class PageSolverConfig:
     expert: Optional[PromptFamily] = None
     max_solve_loops: int = 6
     overall_solve_timeout_ms: int = 45_000
+    # A page just navigated has often not drawn its widget; this long is spent looking before "no captcha" is
+    # believed. It is not charged to overall_solve_timeout_ms, which starts when there is something to solve.
+    detection_timeout_ms: int = 15_000
+    # Repeats of one answer on one board before the solve ends; the first repeats are re-asked at a fresh sample.
     max_no_progress_rounds: int = 2
+    # Deprecated and ignored since 3.2.0: a round that performed nothing goes straight on to the next.
     post_solve_delay_ms: int = 1_200
     post_solve_outcome_timeout_ms: int = 1_000
     post_solve_outcome_poll_ms: int = 75
     element_screenshot_timeout_ms: int = 8_000
+    # Deprecated and ignored since 3.2.0: each of these failures now counts against max_solve_loops.
     max_unsupported_resolves: int = 3
     max_stale_element_retries: int = 3
+    # The pause before a failed round is tried again.
     stale_element_backoff_ms: int = 900
     stale_frame_resolve_enabled: bool = True
     stale_frame_diff_threshold: float = 0.02
@@ -194,6 +291,9 @@ class PageSolverConfig:
     animated_probe_enabled: bool = True
     video_burst_duration_ms: int = 4_000
     video_burst_max_ms: int = 12_000
+    # Safety ceiling on the film an animated board accumulates across rounds. It is meant to end with the
+    # solve, not on this clock; frames are decoded images, so this bounds memory rather than the recording.
+    video_film_max_ms: int = 120_000
     speculative_burst_enabled: bool = True
     video_burst_fps: int = 10
     # GeeTest svg dwells up to 2.7s a screen, so a 3-screen cycle is 8.1s; 6s gave up one screen short.
@@ -320,6 +420,19 @@ class PageSolver:
         self._deadline_ms: Optional[float] = None
         self._budget: Optional[PhaseBudget] = None
         self._animated_plan: Optional[Tuple[List[str], str, Any, Any]] = None
+        self._film_frames: List[Any] = []
+        self._film_ms: float = 0.0
+        # The digests of every screen the film holds: what a later burst is checked against to answer
+        # "is this still the same board?" — see `_record_keyframes`.
+        self._film_digests: Set[str] = set()
+        # Has this board EVER shown the same screen twice? A board that has not cannot prove it was replaced
+        # and has no cycle left to find, so a re-ask neither re-films it at length nor throws its film away.
+        self._film_cycled: bool = False
+        self._verdicts: Optional[VerdictLog] = None
+        # The page being solved: every capture is taken of its viewport. Set by `solve`.
+        self._page: Any = None
+        # When our last gesture ended; the board's reaction to it is never read as the board's own motion.
+        self._last_input_ms: float = -math.inf
         self._reset_animated_state()
 
     @property
@@ -338,6 +451,15 @@ class PageSolver:
         with self._budget.phase(name):
             yield
 
+    @contextmanager
+    def _gesture(self):
+        """A pointer gesture, timed as MOUSE and remembered: see `INPUT_SETTLE_MS`."""
+        try:
+            with self._phase(Phase.MOUSE):
+                yield
+        finally:
+            self._last_input_ms = _now()
+
     # ── per-solve state ──────────────────────────────────────────────────
 
     def _reset_animated_state(self) -> None:
@@ -346,7 +468,7 @@ class PageSolver:
         self._animated_probe_armed = False
         self._animated_probe_done = False
         self._video_budget_granted = False
-        self._discard_animated_plan()
+        self._stop_animated_film()
         self._keyframe_mode: Optional[KeyframeMode] = None
         self._keyframe_steady_screens = 0
         self._last_answer_sig: Optional[str] = None
@@ -371,8 +493,7 @@ class PageSolver:
         sig = self._answer_signature(actions, retry_mode)
         if sig is not None and sig == self._last_answer_sig:
             self._no_progress_rounds += 1
-            _log(f"[no-progress] the model returned the same answer again "
-                 f"({self._no_progress_rounds}/{self.config.max_no_progress_rounds})")
+            _log(f"[no-progress] the model returned the same answer again ({self._no_progress_rounds} in a row)")
             self._resample_level += 1
             self._apply_sampling()
             self._invalidate_animated_answer()
@@ -382,6 +503,20 @@ class PageSolver:
         self._last_answer_sig = sig
         return False
 
+    def _bound_ask_to_the_budget(self) -> None:
+        """Give the planner what is LEFT of the solve, so one ask cannot outlive the whole thing.
+
+        A request in flight cannot be cancelled — `_check_deadline` is only read between steps — so the
+        only thing that bounds it is the timeout it was sent with. Measured on the hosted endpoint: one
+        ask hung and gave up after ~124s inside a 45s budget, and the attempt ran 143s.
+        """
+        target = getattr(self._solver, "planner", None)
+        if target is None or self._deadline_ms is None:
+            return
+        left_s = (self._deadline_ms - _now()) / 1000.0
+        target.request_timeout_s = max(planner.MIN_REQUEST_TIMEOUT_S,
+                                       min(planner.DEFAULT_REQUEST_TIMEOUT_S, left_s))
+
     def _apply_sampling(self) -> None:
         target = getattr(self._solver, "planner", None)
         if target is None:
@@ -391,6 +526,15 @@ class PageSolver:
             _log(f"[resample] temperature {sampling['temperature']}, seed {sampling['seed']}")
 
     def _fresh_board(self) -> None:
+        # ONE FILM, ONE BOARD — enforced where the board actually changes. The recorded answer describes the
+        # board it was cut from, so replaying it here presses that board's coordinates onto this one: live, a
+        # keyframe answer from an earlier board landed on hCaptcha's reference photo and then pressed Skip,
+        # six rounds running.
+        self._stop_animated_film()
+        self._known_animated = False
+        # Its own second look, but only once IT fails: an arm set on the previous board is evidence about that one.
+        self._animated_probe_armed = False
+        self._animated_probe_done = False
         self._resample_level = 0
         self._acted_on_board = False
         self._apply_sampling()
@@ -469,7 +613,7 @@ class PageSolver:
     # ── gestures ─────────────────────────────────────────────────────────
 
     def _smooth_move(self, page: Any, x: float, y: float) -> None:
-        with self._phase(Phase.MOUSE):
+        with self._gesture():
             self._human.move(page, (x, y))
 
     def _move_to_element(self, page: Any, element: Any, padding_percentage: float = 25.0) -> None:
@@ -494,7 +638,7 @@ class PageSolver:
 
     def _move_and_click(self, page: Any, element: Any) -> None:
         self._move_to_element(page, element)
-        with self._phase(Phase.MOUSE):
+        with self._gesture():
             self._human.click(page, self._last_mouse)
 
     @staticmethod
@@ -524,11 +668,11 @@ class PageSolver:
         at = (element_box["x"] + rel[0], element_box["y"] + rel[1])
         if await_keyframe:
             # Park on the target first, so only a mouse-down separates the right screen from the click.
-            with self._phase(Phase.MOUSE):
+            with self._gesture():
                 self._human.move(page, at)
             self._wait_for_keyframe(element, await_keyframe,
                                     (rel[0] / element_box["width"], rel[1] / element_box["height"]))
-        with self._phase(Phase.MOUSE):
+        with self._gesture():
             self._human.click(page, at)
 
     def _click_when_frame_matches(self, page: Any, element: Any, action: Dict[str, Any],
@@ -542,7 +686,7 @@ class PageSolver:
             return (element_box["x"] + (float(bbox[0]) + float(bbox[2])) / 2 * element_box["width"],
                     element_box["y"] + (float(bbox[1]) + float(bbox[3])) / 2 * element_box["height"])
 
-        with self._phase(Phase.MOUSE):
+        with self._gesture():
             self._human.drag(page, center(action["source_bounding_box"]), center(action["target_bounding_box"]))
 
     def _find_control(self, scope: Any, selectors: Sequence[str]) -> Optional[Any]:
@@ -585,7 +729,9 @@ class PageSolver:
             _log("type action, but no text box in the widget; skipping")
             return False
         self._move_and_click(page, field_el)
-        if not self._human.type_text(page, field_el, text):
+        typed = self._human.type_text(page, field_el, text)
+        self._last_input_ms = _now()
+        if not typed:
             return False
         _log(f"typed {len(text)} character(s) into the captcha field")
         return True
@@ -624,7 +770,7 @@ class PageSolver:
                 _log("slide action, but the widget has neither a slider nor a draggable piece")
                 return False
             target_y = (float(tb[1]) + float(tb[3])) / 2 * element_box["height"]
-            with self._phase(Phase.MOUSE):
+            with self._gesture():
                 self._human.drag(page, (box["x"] + box["width"] / 2, box["y"] + box["height"] / 2),
                                  (element_box["x"] + target_x, element_box["y"] + target_y))
             return True
@@ -688,6 +834,7 @@ class PageSolver:
                 self._human.release(page)
             except Exception:
                 pass
+            self._last_input_ms = _now()
             for shot in shots:
                 _unlink(shot)
         return True
@@ -772,15 +919,55 @@ class PageSolver:
         blob = " ".join(str(n) for n in (names or []))
         return [vendor for vendor, s in VENDORS if any(h in blob for h in s.hosts)]
 
+    def _unmatched_vendor_frames(self, page: Any) -> List[Vendor]:
+        """Vendors showing a frame no selector names. Only asked once detection has found nothing, and a passive frame
+        (an invisible badge) is not a widget, so what is left is markup the table no longer matches."""
+        return [vendor for vendor, s in VENDORS if s.hosts and len(_visible(page, [f'iframe[src*="{h}"]' for h in s.hosts]))
+                > len(_visible(page, s.passive))]
+
     def _no_widget_message(self, page: Any) -> str:
-        base = "no interactive captcha widget detected"
+        base = f"no interactive captcha widget detected within {self.config.detection_timeout_ms}ms"
         loaded = self.vendors_on_the_wire(page)
         if not loaded:
             return (f"{base} (no vendor captcha code loaded on this page — likely reCAPTCHA v3 / "
                     "invisible, or a click-triggered challenge that has not been triggered)")
-        return (f"{base}, BUT {'/'.join(loaded)} code IS loaded and running on this page. The "
-                "vendor's markup no longer matches anything in SELECTORS — the table needs "
-                "re-measuring against the vendor's current markup, in both solver ports")
+        framed = self._unmatched_vendor_frames(page)
+        if framed:
+            return (f"{base}, BUT {'/'.join(framed)} is showing a frame that matches nothing in SELECTORS. The "
+                    "vendor's markup has changed — the table needs re-measuring against the vendor's current "
+                    "markup, in both solver ports")
+        return (f"{base}; {'/'.join(loaded)} code is loaded but drew no widget — the challenge may be invisible "
+                "or not triggered yet, or an in-page widget's markup has changed")
+
+    def _await_widget(self, page: Any) -> Tuple[Optional[Widget], float]:
+        """A page that has not drawn its widget yet is looked at again until `detection_timeout_ms`, and the time
+        spent is returned so the solve budget can start after it. Solving straight after `domcontentloaded` failed
+        3/3 on a demo page whose frames arrived a moment later."""
+        started = _now()
+        widget = None
+        with self._phase(Phase.DETECT):
+            while (widget is None and _now() - started < self.config.detection_timeout_ms
+                   and not self.is_captcha_solved(page)):
+                _delay(_DETECTION_POLL_MS)
+                widget = self.detect_captcha(page)
+        return widget, _now() - started
+
+    def _is_blocked(self, page: Any) -> bool:
+        """The vendor showing its refusal screen: rate-limited or flagged, with no board to answer."""
+        for probe in WIDGET_PROBES:
+            blocked = SELECTORS[probe.vendor].blocked
+            if probe.role != FrameRole.CHALLENGE or not blocked:
+                continue
+            at = next(iter(_visible(page, (probe.selector,))), None)
+            frame = _frame_of(at) if at is not None else None
+            if frame and any(self._visible_with_text(frame, selector) for selector in blocked):
+                return True
+        return False
+
+    def _vendor_verdict(self) -> Optional[Verdict]:
+        """What the vendor's server said since the last look: BLOCKED outranks everything, else the latest answer."""
+        fresh = [v.verdict for v in (self._verdicts.fresh() if self._verdicts else ()) if v.verdict != Verdict.NEW_CHALLENGE]
+        return Verdict.BLOCKED if Verdict.BLOCKED in fresh else (fresh[-1] if fresh else None)
 
     def is_captcha_solved(self, page: Any) -> bool:
         """The vendor's own done signal: a response token, a painted success state, or a checked box."""
@@ -840,6 +1027,69 @@ class PageSolver:
             pass
         return None
 
+    def _click_checkbox(self, page: Any, widget: Widget, frame: Any) -> None:
+        """Tick the box and wait for what it opens. A checkbox is not a board: it is never polled, filmed or asked about.
+
+        Treated as a board it cost 70 screenshots and three model calls in one measured solve, two of them answering
+        the checkbox picture with a drag.
+        """
+        box = self._checkbox_box(frame, widget.vendor)
+        if box is not None:
+            self._move_to_element(page, box)
+        else:
+            self._smooth_move(page, *self._find_checkbox_on_screen(widget.element))
+        self._human.pause(PauseKind.BETWEEN)
+        with self._gesture():
+            self._human.click(page, self._last_mouse)
+        self._await_what_the_checkbox_opened(page)
+
+    def _checkbox_box(self, frame: Any, vendor: Vendor) -> Optional[Any]:
+        """The box in a checkbox frame once the frame has drawn it; None when the DOM cannot reach it.
+
+        Turnstile's box is in a closed shadow root, and a frame can refuse access; both are found on screen instead.
+        """
+        box = SELECTORS[vendor].box
+        if frame is None or not box:
+            return None
+        try:
+            return frame.wait_for_selector(", ".join(box), state="visible", timeout=self.config.detection_timeout_ms)
+        except Exception as exc:
+            _log(f"[checkbox] the box is out of the DOM's reach ({str(exc).splitlines()[0]}); finding it on screen")
+            return None
+
+    def _find_checkbox_on_screen(self, element: Any) -> Tuple[float, float]:
+        """One capture and OpenCV: a point inside the tick box, in page coordinates. No model is asked."""
+        from .tool_calls.find_checkbox import find_checkbox
+
+        box = element.bounding_box()
+        if not box:
+            raise CaptchaSolveError("could not get bounding box of captcha element")
+        shot = _tmp_png("checkbox")
+        try:
+            with self._phase(Phase.SCREENSHOT):
+                self._screenshot(element, shot, timeout_ms=self.config.element_screenshot_timeout_ms)
+            found = find_checkbox(shot)
+            scale = self._shot_scale(shot, box["width"])
+        finally:
+            _unlink(shot)
+        if found is None:
+            raise UnsupportedCaptchaError("the checkbox widget shows no tick box to click")
+        x, y, w, h = (v / scale for v in found)
+        return box["x"] + x + w * (0.3 + random.random() * 0.4), box["y"] + y + h * (0.3 + random.random() * 0.4)
+
+    def _await_what_the_checkbox_opened(self, page: Any) -> None:
+        """A clicked checkbox passes or opens a challenge, and both show in the DOM.
+
+        Without this wait the next round found the same checkbox still up and clicked it again.
+        """
+        deadline = _now() + self.config.post_submit_change_timeout_ms
+        with self._phase(Phase.AWAIT_NEXT_ROUND):
+            while _now() < deadline and not self.is_captcha_solved(page):
+                widget = self.detect_captcha(page)
+                if widget is None or widget.role != FrameRole.CHECKBOX:
+                    return
+                _delay(self.config.post_solve_outcome_poll_ms)
+
     def _get_verify_button(self, scope: Any) -> Optional[Any]:
         return self._find_control(scope, SUBMIT_SELECTORS)
 
@@ -847,9 +1097,61 @@ class PageSolver:
 
     def _screenshot(self, element: Any, path: str, timeout_ms: Optional[int] = None,
                     animations: str = "disabled") -> None:
-        """Short timeout; `disabled` freezes CSS animation, so bursts and the keyframe gate pass `allow`."""
-        element.screenshot(path=path, timeout=2_500 if timeout_ms is None else timeout_ms,
-                           animations=animations)
+        """Every capture the driver takes: the whole viewport, cropped here to the element.
+
+        Never a clipped capture. An element screenshot, or any `clip`, makes a headed Chromium repaint the page at
+        the clip's size for that frame, which the user watches as the page flashing and jumping; a viewport
+        capture repaints nothing, and measured twice as fast. Short timeout; `disabled` freezes CSS animation,
+        so bursts and the keyframe gate pass `allow`.
+        """
+        timeout = 2_500 if timeout_ms is None else timeout_ms
+        page = self._page
+        view = _viewport_of(page)
+        rect = self._rect_in_view(element, view) if _layout_is_the_viewport(page, view) else None
+        if rect is None:
+            # Bigger than the viewport, or a zoomed-out mobile layout: no viewport capture holds it in its own
+            # coordinates, so the element photographs itself.
+            element.screenshot(path=path, timeout=timeout, animations=animations)
+            return
+        png = crop_png(page.screenshot(timeout=timeout, animations=animations), rect, view["width"])
+        with open(path, "wb") as fh:
+            fh.write(png)
+
+    @staticmethod
+    def _rect_of(element: Any) -> CaptureRect:
+        box = element.bounding_box()
+        rect = enclosing_rect(box) if box else None
+        if rect is None or rect.width <= 0 or rect.height <= 0:
+            raise CaptchaSolveError("the element is not visible: it has no bounding box to photograph")
+        return rect
+
+    def _rect_in_view(self, element: Any, view: Dict[str, float]) -> Optional[CaptureRect]:
+        """Where the element sits in the viewport, scrolled in when it is merely off screen; None when it cannot fit."""
+        rect = self._rect_of(element)
+        if rect.width > view["width"] or rect.height > view["height"]:
+            return None
+        if not _within(rect, view):
+            element.scroll_into_view_if_needed(timeout=2_000)
+            rect = self._rect_of(element)
+        return rect if _within(rect, view) else None
+
+    def _step_off_the_board(self, page: Any, element: Any) -> None:
+        """Take the pointer off the board and let our own feedback fade before the board is judged still or animated.
+
+        A hovered or pressed control repaints, and a board wearing our highlight read as motion: a still board
+        was filmed as animated because of the Verify button under the cursor.
+        """
+        # Only a board we pointed at wears our feedback. One the vendor dealt under a resting pointer has
+        # nothing of ours to fade, and stepping off it cost every round its own gesture and settle window.
+        if not self._acted_on_board:
+            return
+        box = element.bounding_box()
+        x, y = self._last_mouse
+        if box and self._human.hovers and box["x"] <= x <= box["x"] + box["width"] and box["y"] <= y <= box["y"] + box["height"]:
+            spot = _off_board_point(box, (x, y), _viewport_of(page))
+            if spot is not None:
+                self._smooth_move(page, *spot)
+        _delay(self._last_input_ms + INPUT_SETTLE_MS - _now())
 
     def _element_frame_hash(self, element: Any) -> Optional[str]:
         path = _tmp_png("fh")
@@ -1026,16 +1328,19 @@ class PageSolver:
             return True
         with self._phase(Phase.SETTLE):
             verdict = self._wait_for_element_settled(element)
-        if verdict != SettleVerdict.ANIMATED:
-            # 'settled' is not proof of static; a repeated answer arms one recording to find out.
+        animated = verdict == SettleVerdict.ANIMATED
+        if not animated:
+            # 'settled' is not proof of static; a repeated answer arms one recording to find out. The clip
+            # that recording brings back is what decides — `_known_animated` is set from it, not from here.
             if not self._animated_probe_armed or self._animated_probe_done:
                 return False
             self._animated_probe_done, self._animated_probe_armed = True, False
             _log("[animated] a second look at a board that did not solve as a still — recording it")
-        self._known_animated = True
+        self._known_animated = animated
         if not self.config.video_solve_enabled:
             raise AnimatedChallengeError("the challenge never settles and video_solve_enabled is off")
-        _log("[animated] challenge is animated — solving it from keyframes")
+        if animated:
+            _log("[animated] challenge is animated — solving it from keyframes")
         return True
 
     def _arm_animated_probe(self) -> None:
@@ -1049,10 +1354,15 @@ class PageSolver:
         return (cfg.video_solve_enabled and cfg.speculative_burst_enabled and not self._acted_on_board
                 and puzzle_source != Vendor.RECAPTCHA and not text_mode)
 
-    def _burst(self, element: Any) -> Tuple[List[Any], List[str], bool, float]:
+    def _burst(self, element: Any, known: AbstractSet[str] = frozenset(),
+               max_ms: Optional[float] = None) -> Tuple[List[Any], List[str], bool, float, bool]:
         """Film the widget until a screen comes back (a cycle) or nothing new appears for a floor window.
 
-        Returns `(frames, distinct_digests, moved, elapsed_ms)`. `moved` is a closed cycle OR a board still
+        `known` is the screens an earlier burst of this solve already holds. One of them coming back proves
+        the board was not replaced, and the film in hand already describes it, so there is nothing left to
+        film — that exit is the difference between a re-ask costing a frame and costing a whole window.
+
+        Returns `(frames, distinct_digests, moved, elapsed_ms, cycle_closed)`. `moved` is a closed cycle OR a board still
         producing new screens past the floor with more than BURST_ANIMATED_SCREENS seen: a continuous animation
         never repeats and never settles, so without that verdict it read as a still and was clicked as one.
         Both bounds are wall-clock. There is no "enough screens, stop" exit: both spellings were measured on
@@ -1062,7 +1372,7 @@ class PageSolver:
 
         cfg = self.config
         floor_ms = float(cfg.video_burst_duration_ms)
-        max_ms = max(floor_ms, float(cfg.video_burst_max_ms))
+        max_ms = max(floor_ms, float(cfg.video_burst_max_ms if max_ms is None else max_ms))
         interval = 1.0 / max(1, int(cfg.video_burst_fps))
         frames: List[Any] = []
         order: List[str] = []
@@ -1079,15 +1389,23 @@ class PageSolver:
                     raise CaptchaSolveError(
                         f"the animated recording stalled: {len(frames)} frames in "
                         f"{burst_hang_deadline_ms(cfg):.0f}ms. The widget is not screenshotting.")
-                try:
-                    self._screenshot(element, shot, animations="allow")
-                    img = cv2.imread(shot)
-                except Exception as exc:
-                    _debug(f"burst frame failed: {exc}")
-                    img = None
+                img = None
+                # A frame taken while the board still wears our last gesture is not a screen it showed by itself.
+                if _now() - self._last_input_ms >= INPUT_SETTLE_MS:
+                    try:
+                        self._screenshot(element, shot, animations="allow")
+                        img = cv2.imread(shot)
+                    except Exception as exc:
+                        _debug(f"burst frame failed: {exc}")
                 if img is not None:
                     frames.append(img)
                     d = _sha1(shot)
+                    if d in known:
+                        _log("[animated] a screen the film already holds came back — the board is unchanged")
+                        cycle_closed = True
+                        if d not in order:
+                            order.append(d)
+                        break
                     if d != last_digest:
                         if d in order and len(order) >= 2:
                             cycle_closed = True
@@ -1105,8 +1423,14 @@ class PageSolver:
                 # Sleep to a fixed grid, not `interval - work`: per-frame overshoot would otherwise accumulate and a
                 # loaded runner films fewer frames than the floor window holds. A stalled frame skips, not bunches.
                 next_at = max(next_at + interval, time.monotonic())
+                # END on the frame that would land past the ceiling rather than declining to sleep for it:
+                # declining left the loop spinning at whatever rate the screenshots came back, which on a
+                # ceiling that is not a whole number of intervals filmed thousands of junk frames into the
+                # tail of the clip (measured: 2487 frames in a 150ms window).
+                if (next_at - t0) * 1000.0 >= max_ms:
+                    break
                 wait = next_at - time.monotonic()
-                if wait > 0 and (next_at - t0) * 1000.0 < max_ms:
+                if wait > 0:
                     time.sleep(wait)
         finally:
             _unlink(shot)
@@ -1120,7 +1444,7 @@ class PageSolver:
             why = "no new screen for a full floor window — it moved once and settled"
         _log(f"[animated] burst verdict after {elapsed_ms / 1000:.1f}s: "
              f"{'ANIMATED' if cycle_closed or animating else 'still'} ({len(order)} screens; {why})")
-        return frames, order, cycle_closed or animating, elapsed_ms
+        return frames, order, cycle_closed or animating, elapsed_ms, cycle_closed
 
     def _slice(self, frames: List[Any], burst_ms: float) -> Tuple[List[str], str]:
         """Cut a burst with the training-side slicer; the model answers with a frame number into it."""
@@ -1134,10 +1458,31 @@ class PageSolver:
         _log(f"[animated] sliced to {len(paths)} keyframe(s) (mode={kfset.mode})")
         return paths, temp_dir
 
-    def _record_keyframes(self, element: Any) -> Tuple[List[str], str]:
-        """Record the widget and return `(keyframe_paths, temp_dir)`; the caller removes the dir.
+    def _record_keyframes(self, element: Any) -> Tuple[List[str], str, bool]:
+        """Record the widget and return `(keyframe_paths, temp_dir, moved)`; the caller removes the dir.
 
         Frames stay in memory: the intermediate mp4 this used to write was mp4v, which the serving side may not decode.
+
+        THE FILM IS NEVER THROWN AWAY MID-SOLVE. One burst can only show the model the screens that fell
+        inside its window — measured, a 4s burst against a 5.3s cycle showed two screens of three — and the
+        answer it produces is identical next round by construction, because sampling is greedy over the same
+        frames. So a refused answer used to be re-pressed until the no-progress fence tripped. Every round
+        now films ANOTHER chunk and slices the whole accumulation, so the next ask is a strictly better
+        question: more repetitions for `_detect_cycle` to confirm, and, on a board that never repeats, the
+        slicer's even picks spread across the whole solve rather than across four seconds.
+
+        WHAT IT IS NOT IS A FILM OF TWO BOARDS. Accumulating across a board the vendor replaced is worse
+        than not accumulating at all — six keyframes cut across both states describe neither, `_detect_cycle`
+        gives up on the extra screens, and the frame the model names is one the widget will never show
+        again. A screen coming back is the proof the board is the same one; nothing coming back restarts
+        the film below.
+
+        THE JS PORT FILMS CONTINUOUSLY AND THIS ONE CANNOT. There the recorder is an async loop on the same
+        event loop, so it keeps filming through inference and through the verdict wait. Sync Playwright is
+        thread-affine — `_speculate` says so where it hands only the HTTP call to a worker — so a background
+        camera here would be a second thread touching the page, which Playwright forbids. Accumulating
+        per-round chunks is the same contract with a sparser film: both ports re-ask a refused animated
+        answer against strictly more of the board than the last ask saw.
         """
         cfg = self.config
         self._grant_video_budget()
@@ -1147,12 +1492,42 @@ class PageSolver:
                 f"budget is left and an animated recording needs {cfg.video_burst_duration_ms}ms — not "
                 "starting one that would be cut off mid-way. Raise overall_solve_timeout_ms or "
                 "video_extra_inference_ms, or set video_solve_enabled=False.")
-        frames, _order, _closed, burst_ms = self._burst(element)
+        # A board that has never repeated a screen has nothing further to show: another ceiling-long window
+        # is more of the same animation, and three of them is most of the solve budget. Measured on the gate:
+        # boards at 54.6s and 59.1s against a 49s ceiling, all of them boards that never repeat.
+        reask = bool(self._film_frames)
+        frames, order, moved, burst_ms, cycled = self._burst(
+            element, known=self._film_digests,
+            max_ms=float(cfg.video_burst_duration_ms) if reask and not self._film_cycled else None)
         if not frames:
+            # Not a verdict about the board — a still photographs fine. A widget that would not screenshot for a
+            # whole window is usually closing because the answer was accepted, so the loop asks before it counts
+            # the round. A board proven animated keeps that verdict, and is filmed again rather than read as a still.
             raise AnimatedChallengeError("could not record the animated challenge (no frame screenshotted)")
         _log(f"[animated] recorded {len(frames)} frames in {burst_ms / 1000:.1f}s "
              f"({measured_fps(len(frames), burst_ms, cfg.video_burst_fps):.1f}fps)")
-        return self._slice(frames, burst_ms)
+        # ONE FILM, ONE BOARD. A vendor that deals a fresh puzzle on a miss has replaced everything the film
+        # holds, and keyframes cut across both name screens that no longer exist: the model answers with one
+        # and the click waits out `keyframe_wait_timeout_ms` for a picture that is gone. Nothing coming back
+        # is what says so, and the film restarts on the board that is actually there.
+        # Cut ONLY on proof of a replacement: this burst repeated a screen, and none of what it repeated was
+        # in the film. A board that never repeats cannot produce that proof either way and has not been
+        # replaced — it has simply never repeated, and its film is the only record of it.
+        if reask and cycled and not (self._film_digests & set(order)):
+            _log("[animated] nothing the film holds came back — the board was replaced; the film restarts here")
+            self._film_frames, self._film_ms, self._film_digests = [], 0.0, set()
+        # The cap is a safety net on memory, not the working limit: frames are decoded images, and a board
+        # that never settles would otherwise film for the whole solve budget.
+        if self._film_ms < cfg.video_film_max_ms:
+            self._film_frames.extend(frames)
+            self._film_ms += burst_ms
+            self._film_digests.update(order)
+        self._film_cycled = self._film_cycled or cycled
+        if len(self._film_frames) > len(frames):
+            _log(f"[animated] slicing {len(self._film_frames)} frames filmed over "
+                 f"{self._film_ms / 1000:.1f}s — every round of this board, not just this one")
+        paths, temp_dir = self._slice(self._film_frames or frames, self._film_ms or burst_ms)
+        return paths, temp_dir, moved
 
     def _speculate(self, element: Any, shot: str, puzzle_source: Vendor, retry_mode: Optional[RetryMode],
                    text_mode: bool) -> Tuple[List[CaptchaAction], List[Dict[str, Any]], Optional[str]]:
@@ -1164,7 +1539,7 @@ class PageSolver:
         try:
             fut = pool.submit(self._get_solution, shot, puzzle_source, retry_mode, text_mode)
             with self._phase(Phase.BURST):
-                frames, order, moved, burst_ms = self._burst(element)
+                frames, order, moved, burst_ms, _cycled = self._burst(element)
             if not moved:
                 with self._phase(Phase.INFERENCE):
                     actions, usage = fut.result()
@@ -1178,6 +1553,7 @@ class PageSolver:
                         _debug(f"settled re-read failed: {exc}")
                 return actions, usage, None
             _log("[animated] the widget moved while the model was reading it — finishing the recording")
+            self._known_animated = True
             fut.result()
             self._grant_video_budget()
             paths, keyframe_dir = self._slice(frames, burst_ms)
@@ -1200,11 +1576,25 @@ class PageSolver:
         self._animated_plan = (plan[0], plan[1], None, None)
 
     def _discard_animated_plan(self) -> None:
+        """Drop the ANSWER, keep the film.
+
+        An answer the widget refused is spent: reusing it presses the same wrong thing until the fence trips
+        three rounds in, with half the budget unspent. The frames are the opposite — every chunk added makes
+        the next ask a better question — so only a board that is GONE clears them, via `_stop_animated_film`.
+        """
         plan = self._animated_plan
         self._animated_plan = None
         if plan and plan[1]:
             shutil.rmtree(plan[1], ignore_errors=True)
 
+    def _stop_animated_film(self) -> None:
+        """The board is gone: its film can never describe the next one."""
+        self._discard_animated_plan()
+        self._film_frames = []
+        self._film_ms = 0.0
+        self._film_digests = set()
+        self._film_cycled = False
+
     def _answer_region_recurs(self, keyframe_path: str, ref: Any, box: Any) -> bool:
         """Does the chosen keyframe's answer area appear in a sibling keyframe of the same clip?"""
         import cv2
@@ -1262,12 +1652,12 @@ class PageSolver:
                     polls += 1
                     if polls >= _NOT_THIS_BOARD_POLLS and best > _NOT_THIS_BOARD_DIFF:
                         _log("[animated] the widget no longer resembles the recorded board")
-                        self._discard_animated_plan()
+                        self._stop_animated_film()
                         return False
                 _delay(cfg.keyframe_wait_poll_ms)
         finally:
             _unlink(probe)
-        self._discard_animated_plan()
+        self._stop_animated_film()
         _log(f"[animated] widget never matched the chosen keyframe within {wait_ms}ms (closest diff={best:.4f})")
         return False
 
@@ -1439,12 +1829,19 @@ class PageSolver:
 
     def _solve_single(self, page: Any, widget: Widget, retry_mode: Optional[RetryMode]) -> Tuple[bool, List[Dict[str, Any]]]:
         element, puzzle_source, role = widget.element, widget.vendor, widget.role
+        os.environ[_VENDOR_ENV] = puzzle_source.value
         frame = element.content_frame()
+        # The widget's own host comes from its iframe; an inline widget has none to report.
+        widget_host = _hostname(frame) if frame else ""
+        if widget_host:
+            os.environ[_WIDGET_HOST_ENV] = widget_host
+        else:
+            os.environ.pop(_WIDGET_HOST_ENV, None)
         scope = frame or widget.at
-        # Only the DOM can tell a typed captcha from a click puzzle; hCaptcha and reCAPTCHA never type.
-        text_mode = puzzle_source not in VENDORS_WITH_BESPOKE_HANDLING and self._answer_box(scope, widget.at) is not None
-        if text_mode:
-            _log("widget has a text box; solving as a distorted-text captcha")
+
+        if role == FrameRole.CHECKBOX:
+            self._click_checkbox(page, widget, frame)
+            return True, []
 
         if frame and role == FrameRole.CHALLENGE and SELECTORS[puzzle_source].images:
             if self._last_submit_frame_hash:
@@ -1454,8 +1851,26 @@ class PageSolver:
             with self._phase(Phase.HCAPTCHA_IMAGES):
                 self._wait_for_board_images(frame, SELECTORS[puzzle_source])
 
-        # A checkbox is clicked, not filmed, and a reCAPTCHA board is read by its grid below.
-        filmable = role != FrameRole.CHECKBOX and puzzle_source != Vendor.RECAPTCHA and not text_mode
+        # THE TWO QUESTIONS BELOW ARE PUT TO A PAINTED BOARD. Which expert answers the round is read out of
+        # the DOM and whether the board cycles is read off its motion, and a widget that has not drawn yet
+        # has no text box to find and no motion but its own arrival.
+        #
+        # A reCAPTCHA board is asked NEITHER — it is never typed and never filmed — and it waits for its
+        # board at the grid gate below, on the cells themselves. Waiting here as well put 0.8-1.8s in front
+        # of that gate on every dynamic round, on the family with the tightest per-board budget.
+        if puzzle_source != Vendor.RECAPTCHA:
+            with self._phase(Phase.BOARD_PAINT):
+                self._wait_for_board_painted(element)
+
+        # Only the DOM can tell a typed captcha from a click puzzle; hCaptcha and reCAPTCHA never type.
+        text_mode = puzzle_source not in VENDORS_WITH_BESPOKE_HANDLING and self._answer_box(scope, widget.at) is not None
+        if text_mode:
+            _log("widget has a text box; solving as a distorted-text captcha")
+
+        # A reCAPTCHA board is read by its grid below, not filmed.
+        filmable = puzzle_source != Vendor.RECAPTCHA and not text_mode
+        if filmable and not self._known_animated:
+            self._step_off_the_board(page, element)
         is_animated = filmable and self._settle_or_animated(element)
         # hCaptcha keeps its challenge iframe visible ~2s after the final submit; read as a fresh puzzle it burned ~18s.
         if role == FrameRole.CHALLENGE and self.is_captcha_solved(page):
@@ -1471,8 +1886,10 @@ class PageSolver:
                 if element_box:
                     return self._solve_recaptcha_grid(page, element, retry_mode, grid, element_box)
 
-        with self._phase(Phase.BOARD_PAINT):
-            self._wait_for_board_painted(element)
+        # The board a reCAPTCHA round photographs, for the rounds that do not take the grid path above.
+        if puzzle_source == Vendor.RECAPTCHA:
+            with self._phase(Phase.BOARD_PAINT):
+                self._wait_for_board_painted(element)
 
         shot = _tmp_png("captcha")
         performed = slid = answered = have_shot = False
@@ -1483,18 +1900,30 @@ class PageSolver:
                 if self._animated_plan is not None:
                     keyframes, keyframe_dir, actions, all_usage = self._animated_plan
                     reused = actions is not None
+                    if not reused:
+                        # Drop the ANSWER, keep the FRAMES — and the frames grow. Filming another chunk and
+                        # re-slicing the accumulation puts a better question up; re-asking the same frames
+                        # puts the same question up and gets the same answer back.
+                        with self._phase(Phase.BURST):
+                            keyframes, new_dir, moved = self._record_keyframes(element)
+                        shutil.rmtree(keyframe_dir, ignore_errors=True)
+                        keyframe_dir = new_dir
+                        self._known_animated = self._known_animated or moved
                     _log("[animated] reusing the recorded answer" if reused
-                         else "[animated] re-asking on the frames already recorded")
+                         else "[animated] re-asking on a film a round longer")
                 else:
                     reused = False
                     with self._phase(Phase.BURST):
-                        keyframes, keyframe_dir = self._record_keyframes(element)
-                if len(keyframes) < 2:
-                    _log("[animated] the recording shows one picture; solving it as a still")
+                        keyframes, keyframe_dir, moved = self._record_keyframes(element)
+                    self._known_animated = self._known_animated or moved
+                # The clip answers the question the probe asked: a board that never moved is a still, and the
+                # video expert can only answer a still with a frame number the widget will not take.
+                if len(keyframes) < 2 or not self._known_animated:
+                    _log("[animated] the recording shows a still board; solving it as a still")
                     is_animated = False
-                    shutil.copyfile(keyframes[0], shot)
+                    shutil.copyfile(keyframes[-1], shot)
                     have_shot = True
-                    self._discard_animated_plan()
+                    self._stop_animated_film()
                     shutil.rmtree(keyframe_dir, ignore_errors=True)
                     keyframe_dir = None
                 elif not reused:
@@ -1517,11 +1946,19 @@ class PageSolver:
 
             element_box = element.bounding_box()
             if not element_box and answer_needs_element_box(actions):
+                # A WIDGET WITH NO BOX IS USUALLY A WIDGET THAT IS CLOSING, and it closes because the
+                # answer was accepted. Asking costs one call; not asking cost the solve — measured on
+                # 2026-09-17, five types graded `solved: true` on the board and then ended the attempt
+                # here, which Tier 3 reports as an answer the board would have taken, reported failed.
+                if self.is_captcha_solved(page):
+                    _log("the widget has no box because it is closing on a solved board; finishing.")
+                    return False, all_usage
                 raise CaptchaSolveError("could not get bounding box of captcha element")
 
             _log("[answer] " + json.dumps({"actions": [_as_dict(a) for a in actions]}, default=str))
             # A repeated answer is not re-performed: the widget already refused it, and every extra press is
             # behaviour a vendor scores. Re-asking with a fresh sample or a recording is the round's only move.
+            # `_note_answer` drops the refused animated answer on its way through, so the next round re-asks.
             if self._note_answer(actions, retry_mode):
                 return False, all_usage
             _log(f"executing {len(actions)} action(s)")
@@ -1588,12 +2025,21 @@ class PageSolver:
         usage: List[Dict[str, Any]] = []
         self._last_submit_frame_hash = None
         self._deadline_ms = start + self.config.overall_solve_timeout_ms
+        self._page = page
         self._human.reset(page)
         self._reset_animated_state()
         self._budget = PhaseBudget()
-        # One session id per solve groups its inference rounds into one billable attempt.
-        previous_session = os.environ.get(_SESSION_ENV)
+        self._verdicts = None
+        # One session id per solve groups its inference rounds into one billable attempt; vendor and site say
+        # where it was, and are set as they become known.
+        previous = {name: os.environ.get(name) for name in (_SESSION_ENV, _VENDOR_ENV, _SITE_ENV, _WIDGET_HOST_ENV)}
         session_id = os.environ[_SESSION_ENV] = str(uuid.uuid4())
+        os.environ.pop(_VENDOR_ENV, None)
+        os.environ.pop(_SITE_ENV, None)
+        os.environ.pop(_WIDGET_HOST_ENV, None)
+        site = _hostname(page)
+        if site:
+            os.environ[_SITE_ENV] = site
         solved = False
         try:
             result = self._solve_impl(page, start, usage)
@@ -1604,34 +2050,69 @@ class PageSolver:
             if timings_enabled():
                 print(self._budget.report(), file=sys.stderr)
             self._deadline_ms = None
+            if self._verdicts is not None:
+                self._verdicts.close()
+            # The vendor's own verdict when it was readable; the DOM's done-signal only when it was not.
+            said = self._verdicts.decisive() if self._verdicts is not None else None
             try:
                 # On by default: it is the only way a hosted account's failures can be found at all.
-                self._solver.planner.report_outcome(session_id, solved)
+                self._solver.planner.report_outcome(session_id, solved if said is None else said == Verdict.ACCEPTED)
             except Exception as exc:
                 _log(f"[outcome] could not report: {exc}")
-            if previous_session is None:
-                os.environ.pop(_SESSION_ENV, None)
-            else:
-                os.environ[_SESSION_ENV] = previous_session
+            for name, value in previous.items():
+                if value is None:
+                    os.environ.pop(name, None)
+                else:
+                    os.environ[name] = value
 
     def _solve_impl(self, page: Any, start: float, usage: List[Dict[str, Any]]) -> SolveResult:
+        """Give up only when the vendor refuses to serve us, or when every one of `max_solve_loops` has been spent.
+
+        Any other failed round — a stale handle, an unusable or repeated answer, a board that would not film —
+        counts one loop, pauses, and goes again.
+        """
         cfg = self.config
         pending_retry_mode: Optional[RetryMode] = None
-        retried_underselect = False
-        unsupported_retries = stale_retries = render_waits = 0
         has_interacted = False
-        # Strictly fewer than the loops, else the no-widget branch for invisible reCAPTCHA never fires.
-        max_render_waits = min(6, cfg.max_solve_loops - 1)
+        last_failure: Optional[CaptchaSolveError] = None
+        verdicts = self._verdicts = VerdictLog(page)
 
         def done() -> SolveResult:
-            return SolveResult(True, self._last_mouse, _aggregate(usage))
+            return SolveResult(True, self._last_mouse, _aggregate(usage), verdicts=list(verdicts.verdicts))
+
+        def blocked(how: str) -> VendorBlockedError:
+            return VendorBlockedError(f"the vendor refused to serve this client ({how}); no further round can succeed")
+
+        def again(failure: CaptchaSolveError, *, in_transition: bool = False) -> None:
+            """Count the loop. Only a widget caught mid-transition is worth waiting out; a refused or repeated
+            answer changed nothing on the page, and pausing after it only spends the solve's budget."""
+            nonlocal last_failure
+            last_failure = failure
+            _log(f"{failure}; counting this loop and going again")
+            if in_transition:
+                _delay(cfg.stale_element_backoff_ms)
 
         for attempt in range(1, cfg.max_solve_loops + 1):
-            if attempt >= 2:
+            # A round that failed arms the second look only while its board is still up. A board the vendor has
+            # replaced (`_fresh_board` clears `_acted_on_board`) has failed nothing yet, and arming it anyway
+            # filmed every still board after a solve's first miss: 4-8s each, a 41.8s session became 49s.
+            if attempt >= 2 and self._acted_on_board:
                 self._arm_animated_probe()
-            if _now() - start > cfg.overall_solve_timeout_ms:
+            self._bound_ask_to_the_budget()
+            # The deadline, not the bare config: a recording extends it once per solve (`_grant_video_budget`), and
+            # a loop head reading only overall_solve_timeout_ms quit video solves at 45s with 29s still granted.
+            deadline = self._deadline_ms if self._deadline_ms is not None else start + cfg.overall_solve_timeout_ms
+            if _now() > deadline:
+                granted = deadline - start - cfg.overall_solve_timeout_ms
                 raise CaptchaSolveError(
-                    f"captcha solve timed out after {cfg.overall_solve_timeout_ms}ms (attempt {attempt}/{cfg.max_solve_loops})")
+                    f"captcha solve timed out after {deadline - start:.0f}ms (attempt {attempt}/{cfg.max_solve_loops})"
+                    + (f", including {granted:.0f}ms granted for recording an animated challenge" if granted > 0 else ""))
+            said = self._vendor_verdict()
+            if said == Verdict.ACCEPTED:
+                _log("[verdict] the vendor accepted the answer; finishing.")
+                return done()
+            if said == Verdict.BLOCKED:
+                raise blocked("its server answered 429")
             if has_interacted and self.is_captcha_solved(page):
                 _log("captcha reports solved; finishing.")
                 return done()
@@ -1639,81 +2120,88 @@ class PageSolver:
             with self._phase(Phase.DETECT):
                 widget = self.detect_captcha(page)
             if not widget:
-                if has_interacted:
+                # A widget that vanished right after the vendor refused the answer was not solved.
+                if has_interacted and verdicts.decisive() != Verdict.REJECTED:
                     _log("no supported captcha remains after interaction; considering solved.")
                     return done()
-                if self.is_captcha_solved(page):
-                    _log("captcha already satisfied; nothing to solve.")
-                    return done()
-                if self.has_interactive_widget_in_dom(page) and render_waits < max_render_waits:
-                    render_waits += 1
-                    _log(f"widget in DOM but not yet rendered; waiting ({render_waits}/{max_render_waits}).")
-                    _delay(800 + random.random() * 300)
-                    continue
-                raise NoCaptchaFoundError(self._no_widget_message(page))
+                widget, waited = self._await_widget(page)
+                # The budget is for solving; the page drawing its widget is not charged to it.
+                start += waited
+                if self._deadline_ms is not None:
+                    self._deadline_ms += waited
+                if widget is None:
+                    if self.is_captcha_solved(page):
+                        _log("captcha already satisfied; nothing to solve.")
+                        return done()
+                    if has_interacted:
+                        raise CaptchaSolveError(f"the vendor rejected the last answer and its widget did not come "
+                                                f"back within {cfg.detection_timeout_ms}ms")
+                    raise NoCaptchaFoundError(self._no_widget_message(page))
 
             _log(f"--- captcha solve loop {attempt}/{cfg.max_solve_loops} ---")
             retry_mode, pending_retry_mode = pending_retry_mode, None
             try:
                 did_interact, round_usage = self._solve_single(page, widget, retry_mode)
-            except AnimatedChallengeError:
-                raise
             except UnsupportedCaptchaError as unsupported:
-                # Mid-solve, a transitional blank frame reads as unsupported; settle and retry.
-                if has_interacted and unsupported_retries < cfg.max_unsupported_resolves:
-                    unsupported_retries += 1
-                    again = self.detect_captcha(page)
-                    with self._phase(Phase.SETTLE):
-                        settled = again and self._wait_for_element_settled(again.element)
-                    if settled == SettleVerdict.ANIMATED and not cfg.video_solve_enabled:
-                        raise AnimatedChallengeError("the challenge never settles and video_solve_enabled is off")
-                    _log(f'"unsupported" mid-solve; retrying ({unsupported_retries}/{cfg.max_unsupported_resolves}).')
-                    continue
-                raise UnsupportedChallengeError(f"cannot solve this kind of captcha — {unsupported}") from unsupported
+                # The model had nothing usable for this board. The next round re-asks, often of a board the
+                # vendor has replaced.
+                again(UnsupportedChallengeError(f"cannot solve this kind of captcha — {unsupported}"))
+                continue
+            except AnimatedChallengeError as animated:
+                if not cfg.video_solve_enabled:
+                    raise
+                # A widget that will not screenshot is usually one that is closing, because the answer was
+                # accepted: measured, a vendor that deals several boards lost four attempts to exactly this, each
+                # after its first board came back graded solved.
+                if has_interacted and self.is_captcha_solved(page):
+                    _log("nothing left to film because the board was accepted; finishing.")
+                    return done()
+                again(animated, in_transition=True)
+                continue
             except Exception as exc:
                 message = str(exc)
                 closed = bool(_CLOSED_TARGET_RE.search(message))
-                if has_interacted and (closed or _STALE_HANDLE_RE.search(message)):
-                    # The handle most often went stale because the answer was accepted.
-                    try:
-                        if self.is_captcha_solved(page):
-                            _log("captcha reports solved; finishing.")
-                            return done()
-                    except Exception:
-                        pass
-                    if closed:
-                        raise PageClosedError(
-                            "the page, context or browser closed mid-solve, after the answer had been "
-                            "submitted but before the vendor's verdict could be read — the solve may in "
-                            "fact have succeeded") from exc
-                    if stale_retries < cfg.max_stale_element_retries:
-                        stale_retries += 1
-                        _log(f"stale challenge handle after submit; re-detecting ({stale_retries}/{cfg.max_stale_element_retries}).")
-                        _delay(cfg.stale_element_backoff_ms)
-                        continue
-                raise
+                if not (closed or _STALE_HANDLE_RE.search(message)):
+                    raise
+                # The handle most often went stale because the answer was accepted.
+                try:
+                    if has_interacted and self.is_captcha_solved(page):
+                        _log("captcha reports solved; finishing.")
+                        return done()
+                except Exception:
+                    pass
+                if closed:
+                    raise PageClosedError(
+                        "the page, context or browser closed mid-solve"
+                        + (", after the answer had been submitted but before the vendor's verdict could be read — "
+                           "the solve may in fact have succeeded" if has_interacted else "")) from exc
+                again(CaptchaSolveError(f"the challenge handle went stale ({message.splitlines()[0]})"), in_transition=True)
+                continue
 
             has_interacted = has_interacted or did_interact
-            if self._no_progress_rounds >= cfg.max_no_progress_rounds:
-                raise CaptchaSolveError(
-                    f"no progress: the model returned the same answer {self._no_progress_rounds + 1} times "
-                    f"running and the challenge is still up (attempt {attempt}/{cfg.max_solve_loops})")
-            render_waits = 0
             usage.extend(round_usage)
 
             # One polled wait per round: the vendor's verdict, the widget going away, or a fresh board. The flat
-            # sleep it replaced observed nothing and cost 1200-1500ms per finished round.
-            window_ms = (cfg.post_solve_outcome_timeout_ms if did_interact
-                         else cfg.post_solve_delay_ms + random.random() * 300)
+            # sleep it replaced observed nothing and cost 1200-1500ms per finished round. A round that performed
+            # nothing gave the page nothing to react to, so it looks once and goes on: waiting there cost every
+            # refused or repeated answer the full window.
+            window_ms = cfg.post_solve_outcome_timeout_ms if did_interact else 0
             deadline = _now() + window_ms
             t0 = time.perf_counter()
             solved = False
+            said = None
             widget_gone = 0
-            while _now() < deadline:
+            looked = False
+            while not looked or _now() < deadline:
+                looked = True
+                said = self._vendor_verdict() or said
+                if said in (Verdict.ACCEPTED, Verdict.BLOCKED):
+                    solved = said == Verdict.ACCEPTED
+                    break
                 if self.is_captcha_solved(page):
                     solved = True
                     break
-                widget_gone = widget_gone + 1 if self.detect_captcha(page) is None else 0
+                widget_gone = widget_gone + 1 if said != Verdict.REJECTED and self.detect_captcha(page) is None else 0
                 if widget_gone >= 2:
                     solved = True
                     break
@@ -1727,22 +2215,48 @@ class PageSolver:
             if solved:
                 _log(f"[verdict] success signal arrived after {verdict_ms:.0f}ms")
                 return done()
+            if said == Verdict.BLOCKED:
+                raise blocked("its server answered 429")
+            if self._is_blocked(page):
+                raise blocked("it is showing its try-again-later screen")
+            if said == Verdict.REJECTED:
+                _log(f"[verdict] the vendor rejected the answer after {verdict_ms:.0f}ms")
 
             if self._banner_is_fatal_after_retry(self._banner_kind(page)):
-                if retried_underselect:
-                    raise CaptchaSolveError(
-                        "reCAPTCHA still showing the under-selection error after retry; aborting "
-                        "(model unable to identify the missed tile)")
-                _log("reCAPTCHA under-selection error; retrying with missed-tiles prompt.")
-                pending_retry_mode, retried_underselect = RetryMode.MISSED_TILES, True
+                _log("reCAPTCHA under-selection error; the next round asks for the missed tiles.")
+                pending_retry_mode = RetryMode.MISSED_TILES
 
-            if not self.detect_captcha(page):
+            if said != Verdict.REJECTED and not self.detect_captcha(page):
                 return done()
-            if not did_interact and not self._no_progress_rounds:
-                raise CaptchaSolveError(
-                    "captcha still detected but the solver performed no interactions; aborting to avoid an infinite loop")
+            if self._no_progress_rounds:
+                stuck = CaptchaSolveError(f"no progress: the model returned the same answer "
+                                          f"{self._no_progress_rounds + 1} times running")
+                # A board answered the same way after every resample is one the model cannot read: measured, no
+                # solve ever followed a third identical answer, and each further round cost the board 3-7s.
+                if self._no_progress_rounds >= cfg.max_no_progress_rounds:
+                    raise stuck
+                again(stuck)
+            elif not did_interact:
+                # An answer with nothing to execute is not proof the page is stuck; on an animated board it is
+                # what a still expert returns when the board is not a still, so the next round takes a second look.
+                if cfg.video_solve_enabled:
+                    self._arm_animated_probe()
+                again(CaptchaSolveError("the solver performed no interactions this round"))
+
+        if isinstance(last_failure, UnsupportedChallengeError):
+            raise UnsupportedChallengeError(f"{last_failure} (after {cfg.max_solve_loops} solve loops)")
+        raise CaptchaSolveError(f"captcha still detected after {cfg.max_solve_loops} solve loops"
+                                + (f"; the last failed round: {last_failure}" if last_failure else ""))
+
 
-        raise CaptchaSolveError(f"captcha still detected after {cfg.max_solve_loops} solve loops")
+def _hostname(page: Any) -> str:
+    """The page's host alone: a path or query can carry a user's own data."""
+    from urllib.parse import urlparse
+
+    try:
+        return (urlparse(page.url).hostname or "").lower()
+    except Exception:
+        return ""
 
 
 def _bbox_center(bbox: Sequence[float]) -> Tuple[float, float]: