captchakraken 2.6.0 → 2.6.1

package/README.md

@@ -1,9 +1,20 @@
-# captchakraken
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JWriter20/CaptchaKraken/main/docs/assets/logo-card.png" alt="CaptchaKraken" width="128" height="128">
+</p>
 
-The TypeScript browser driver for [CaptchaKraken](https://github.com/JWriter20/CaptchaKraken).
-Hand it a Playwright/Puppeteer `Page`; it finds the captcha, reads the grid with
-a fine-tuned **Qwen3.5-9B** vision model on **vLLM**, clicks human-like, and
-verifies through to a token.
+<h1 align="center">captchakraken</h1>
+
+<p align="center">
+  <b>A captcha solver for browser automation.</b><br>
+  The TypeScript driver for <a href="https://github.com/JWriter20/CaptchaKraken">CaptchaKraken</a>.
+</p>
+
+Hand it a Playwright or Puppeteer `Page`. It finds the captcha, reads the whole
+puzzle with a fine-tuned **Qwen3.5-9B** vision model, and clicks, drags, slides
+or types human-like through to a token.
+
+Run the model on **your own hardware**, or point it at the **hosted API** and run
+nothing at all.
 
 > Full docs — demo videos, accuracy, self-hosting — live in the main repo
 > **[CaptchaKraken](https://github.com/JWriter20/CaptchaKraken)**.
@@ -15,9 +26,9 @@ npm install captchakraken
 ```
 
 The package bundles the Python engine (`captchakraken`) and, on `postinstall`,
-creates a local venv with its lightweight core deps so grid detection + the vLLM
-planner work out of the box. It ships **no browser** — bring your own
-Playwright-compatible launcher.
+creates a local venv with its lightweight core deps, so tile detection and the
+inference client work out of the box. It ships **no browser** — bring your own
+Playwright-compatible launcher (camoufox and patchright both work).
 
 - Skip the Python bootstrap: `CAPTCHA_KRAKEN_SKIP_PYTHON_SETUP=1`
 - To **self-host** the model, run the repo's `setup.sh` (installs vLLM + weights).
@@ -37,6 +48,22 @@ claude mcp add captchakraken -- npx -y captchakraken-mcp
 `create_api_key` writes the key and the endpoint to `~/.captchakraken/credentials`,
 which the client reads on its own — **no environment variables needed**.
 
+## What it solves
+
+| Vendor | Puzzles |
+|---|---|
+| **reCAPTCHA** | 3×3 and 4×4 image grids, including the dynamic re-deal |
+| **hCaptcha** | Image grids, click, drag, connect-the-path, tetris-fit, animated |
+| **GeeTest** v3 + v4 | Slide, icon, nine, svg, gobang, iconcrush |
+| **NetEase Yidun** | Jigsaw, picture-click, icon-click |
+| **Tencent, Lemin, Prosopo** | Slide, cropped-image and grid flows |
+| **BotDetect, MTCaptcha, Yandex** | Distorted text — read and typed, not clicked |
+| **Cloudflare Turnstile** | Via the checkbox flow (free on the hosted API) |
+
+**44 puzzle types**, driven end to end in CI against generated fixtures on both
+the TypeScript and Python ports. Animated challenges are recorded, sliced into
+keyframes and answered with the frame the action belongs to.
+
 ## Usage
 
 ```typescript
@@ -49,7 +76,7 @@ await page.goto('https://www.google.com/recaptcha/api2/demo');
 
 // Reads VLLM_BASE_URL + CAPTCHA_KRAKEN_API_KEY from the environment.
 const solver = new CaptchaKrakenSolver();
-await solver.solve(page);            // detect → solve grid → click → verify
+await solver.solve(page);            // detect → read → act → verify
 
 await browser.close();
 ```

package/dist/solver.d.ts

@@ -15,6 +15,9 @@ export declare const SOLVE_DEFAULTS: {
 };
 export declare class CaptchaKrakenSolver {
     private config;
+    /** Extra ms this solve has been granted for a recording; see recordKeyframeBurst. */
+    private videoBudgetMs;
+    private videoBudgetGranted;
     private lastMousePosition;
     private imageCounter;
     private sessionDebugDir;

package/dist/solver.js

@@ -252,6 +252,9 @@ exports.SOLVE_DEFAULTS = {
 };
 class CaptchaKrakenSolver {
     constructor(config = {}) {
+        /** Extra ms this solve has been granted for a recording; see recordKeyframeBurst. */
+        this.videoBudgetMs = 0;
+        this.videoBudgetGranted = false;
         this.imageCounter = 0; // Track images sent to CLI for debugging
         this.sessionDebugDir = null;
         // onStep instrumentation: monotonic step index + solve-start wall clock.
@@ -410,8 +413,13 @@ class CaptchaKrakenSolver {
         // solve loops" instead. Mirrors page_solver.py's max_render_waits.
         const MAX_RENDER_WAITS = Math.min(6, maxSolveLoops - 1);
         for (let attempt = 1; attempt <= maxSolveLoops; attempt++) {
-            if (Date.now() - start > overallSolveTimeoutMs) {
-                throw new Error(`Captcha solve timed out after ${overallSolveTimeoutMs}ms (attempt ${attempt}/${maxSolveLoops}).`);
+            // `videoBudgetMs` is 0 until this solve records something, so a solve
+            // that never escalates gets exactly the deadline the caller configured.
+            const budgetMs = overallSolveTimeoutMs + this.videoBudgetMs;
+            if (Date.now() - start > budgetMs) {
+                throw new Error(`Captcha solve timed out after ${budgetMs}ms (attempt ${attempt}/${maxSolveLoops})`
+                    + (this.videoBudgetMs ? `, including ${this.videoBudgetMs}ms granted for recording an animated challenge` : '')
+                    + '.');
             }
             /*
              * ASK THE VENDOR BEFORE DOING ANY MORE WORK.
@@ -929,26 +937,34 @@ class CaptchaKrakenSolver {
                         await this.emitStep(captchaElement, 'wait', `waited ${action.duration_ms}ms`, puzzleSource, frameRole, attempt, { action });
                     }
                 }
-                // `scope` when there is no vendor iframe. Eight vendors render into the
-                // HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin, Prosopo,
-                // MTCaptcha, BotDetect — so `contentFrame()` is null for all of them
-                // and the button was never even SEARCHED FOR, while the text box and
-                // the slider handle it sits beside were both found through `scope`
-                // above. Two containers for two halves of one interaction.
-                //
-                // `scope` is the widget container and getVerifyButton's xpaths are
-                // RELATIVE, so the submit of the FORM the captcha guards is out of
-                // reach by construction. The press itself is bounded by
-                // `shouldClickSubmit` below, which is where that hazard belongs.
-                const lookup = frame ?? (slid ? null : scope);
-                if (lookup) {
-                    verifyButton = await this.getVerifyButton(lookup);
-                    if (verifyButton) {
-                        await this.move(page, verifyButton);
-                    }
+            }
+            // Resolve the widget's submit control AFTER the action loop, not inside
+            // it. An empty plan — the correct answer to reCAPTCHA 3x3's
+            // `none_present` variation, where nothing matches and the control reads
+            // SKIP — never enters that loop, so the lookup never ran, the press below
+            // found `verifyButton` null, and the round aborted on 'performed no
+            // interactions'. The finder was never the problem: 'Skip' has always been
+            // in its list. It was simply never called for the one answer shape that
+            // performs no other action.
+            // `scope` when there is no vendor iframe. Eight vendors render into the
+            // HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin, Prosopo,
+            // MTCaptcha, BotDetect — so `contentFrame()` is null for all of them
+            // and the button was never even SEARCHED FOR, while the text box and
+            // the slider handle it sits beside were both found through `scope`
+            // above. Two containers for two halves of one interaction.
+            //
+            // `scope` is the widget container and getVerifyButton's xpaths are
+            // RELATIVE, so the submit of the FORM the captcha guards is out of
+            // reach by construction. The press itself is bounded by
+            // `shouldClickSubmit` below, which is where that hazard belongs.
+            const lookup = frame ?? (slid ? null : scope);
+            if (lookup) {
+                verifyButton = await this.getVerifyButton(lookup);
+                if (verifyButton) {
+                    await this.move(page, verifyButton);
                 }
-                // 'done' actions intentionally fall through to the Verify-button block below.
             }
+            // 'done' actions fall through to the submit block below, same as before.
             // Submit policy: press the widget's own submit control whenever we have
             // put an ANSWER into it — a selection, a placed piece, a typed code — or
             // when we had nothing to do and want the round to advance.
@@ -2382,6 +2398,26 @@ class CaptchaKrakenSolver {
     async recordKeyframeBurst(captchaElement) {
         const fps = Math.max(1, this.config.videoBurstFps ?? 10);
         const durationMs = this.config.videoBurstDurationMs ?? 4000;
+        /*
+         * THE ESCALATION BUYS ITS OWN BUDGET, once per solve.
+         *
+         * `overallSolveTimeoutMs` counts rounds and a recording is not a round —
+         * see `videoExtraInferenceMs` for the arithmetic and for what it cost not
+         * to have it. Recorded as an EXTENSION rather than by loosening the config,
+         * so a solve that never escalates keeps the deadline the caller asked for.
+         *
+         * Same one-shot, same total, same reason as page_solver.py's
+         * `video_budget_ms`: the ports must not disagree about how long a video
+         * solve may take, or the same fixture passes on one and times out on the
+         * other and it reads as a driver bug.
+         */
+        if (this.config.videoSolveEnabled !== false && !this.videoBudgetGranted) {
+            this.videoBudgetGranted = true;
+            this.videoBudgetMs =
+                durationMs +
+                    (this.config.keyframeWaitTimeoutMs ?? 6000) +
+                    (this.config.videoExtraInferenceMs ?? 8000);
+        }
         const total = Math.max(1, Math.round(durationMs / (1000 / fps)));
         const intervalMs = 1000 / fps;
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck_burst_'));
@@ -2568,6 +2604,10 @@ class CaptchaKrakenSolver {
         this.keyframeMode = null;
         this.lastAnswerSig = null;
         this.noProgressRounds = 0;
+        // Per SOLVE, not per process: a grant leaking into the next captcha would
+        // silently hand a still puzzle 18s it was never meant to have.
+        this.videoBudgetMs = 0;
+        this.videoBudgetGranted = false;
     }
     /**
      * A stable identity for "the answer this round is about to execute".

package/dist/types.d.ts

@@ -330,6 +330,36 @@ export interface CaptchaKrakenConfig {
      */
     keyframeWaitTimeoutMs?: number;
     keyframeWaitPollMs?: number;
+    /**
+     * Extra wall clock (ms) granted ONCE, the first time a solve escalates to a
+     * recording. NOT a looser `overallSolveTimeoutMs`.
+     *
+     * That budget counts ROUNDS — `maxSolveLoops` x ~7000ms, which
+     * no-progress.test.ts pins. A recording is not a round: it is a fixed extra
+     * stage costing the burst, the slice, one MULTI-IMAGE inference (six
+     * keyframes, several times a still's) and the wait for the widget to come
+     * back round to the chosen frame. Nothing in the 45s was set aside for it, so
+     * an escalation late in a solve simply ran the clock out and reported a
+     * timeout — which reads as a slow model rather than as a budget with no room
+     * for what the solver had just decided to do.
+     *
+     * Measured 2026-08-22, Tier 3 run 32596340560: hcaptcha_click_image_by_traits,
+     * hcaptcha_connect_path and hcaptcha_grid_3x3_property each failed this port
+     * with "Captcha solve timed out after 45000ms (attempt 6/6)" at 49-59s, and
+     * solve in 14-20s on the rounds the still path answers them.
+     *
+     * The total granted is `videoBurstDurationMs + keyframeWaitTimeoutMs + this`,
+     * derived so a longer burst carries its own budget — page_solver.py's
+     * `video_budget_ms` is the same arithmetic, since the two ports must not
+     * disagree about how long a video solve may take.
+     *
+     * Granted only when `videoSolveEnabled`: a caller who wants a hard deadline
+     * turns recording off, which already means "fail fast rather than spend the
+     * recording time".
+     *
+     * Default: 8000
+     */
+    videoExtraInferenceMs?: number;
     /**
      * After clicking Submit/Verify, the solver EXPECTS the frame to change (advance
      * to the next round, or close because it was accepted). This is how long (ms)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "captchakraken",
-  "version": "2.6.0",
-  "description": "Browser-agnostic Playwright/Puppeteer captcha solver. Detects the captcha, reads the grid with a fine-tuned Qwen3.5-9B vision model on vLLM, and clicks through to a token.",
+  "version": "2.6.1",
+  "description": "Captcha solver for Playwright and Puppeteer. Finds the captcha, reads the puzzle with a fine-tuned Qwen3.5-9B vision model, and clicks, drags, slides or types through to a token — reCAPTCHA, hCaptcha, GeeTest, NetEase Yidun, Tencent, Lemin, Prosopo, Turnstile and distorted text. Hosted API or self-hosted.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -25,11 +25,19 @@
   },
   "keywords": [
     "captcha",
+    "captcha-solver",
     "recaptcha",
     "hcaptcha",
+    "geetest",
+    "turnstile",
+    "yidun",
+    "tencent-captcha",
     "playwright",
     "puppeteer",
-    "automation",
+    "camoufox",
+    "browser-automation",
+    "scraping",
+    "anti-bot",
     "vllm",
     "qwen"
   ],

package/python/README.md

@@ -1,14 +1,42 @@
-# captchakraken
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JWriter20/CaptchaKraken/main/docs/assets/logo-card.png" alt="CaptchaKraken" width="128" height="128">
+</p>
 
-The Python engine + CLI behind [CaptchaKraken](https://github.com/JWriter20/CaptchaKraken):
-OpenCV grid detection + a fine-tuned **Qwen3.5-9B** vision LoRA served on
-**vLLM**. Given a screenshot of a captcha grid, it locates the tiles and returns
-the click plan. Ships the `captchakraken` command.
+<h1 align="center">captchakraken</h1>
+
+<p align="center">
+  <b>A captcha solver for browser automation.</b><br>
+  The Python engine and CLI behind <a href="https://github.com/JWriter20/CaptchaKraken">CaptchaKraken</a>.
+</p>
+
+OpenCV tile detection plus a fine-tuned **Qwen3.5-9B** vision model. Give it a
+screenshot of a captcha and it returns the plan to solve it — which tiles to
+select, where to click, what to drag, how far to slide, or what text to type.
+Ships the `captchakraken` command.
+
+Run the model on **your own hardware**, or point it at the **hosted API** and run
+nothing at all.
 
 > For demo videos, accuracy numbers, the browser driver, and the full
 > self-hosting guide, see the main repo
 > **[CaptchaKraken](https://github.com/JWriter20/CaptchaKraken)**.
 
+## What it solves
+
+| Vendor | Puzzles |
+|---|---|
+| **reCAPTCHA** | 3×3 and 4×4 image grids, including the dynamic re-deal |
+| **hCaptcha** | Image grids, click, drag, connect-the-path, tetris-fit, animated |
+| **GeeTest** v3 + v4 | Slide, icon, nine, svg, gobang, iconcrush |
+| **NetEase Yidun** | Jigsaw, picture-click, icon-click |
+| **Tencent, Lemin, Prosopo** | Slide, cropped-image and grid flows |
+| **BotDetect, MTCaptcha, Yandex** | Distorted text — read and typed, not clicked |
+| **Cloudflare Turnstile** | Via the checkbox flow (free on the hosted API) |
+
+**44 puzzle types**, driven end to end in CI against generated fixtures on both
+the TypeScript and Python ports. Animated challenges are recorded, sliced into
+keyframes and answered with the frame the action belongs to.
+
 ## Install
 
 ```bash

package/python/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "captchakraken"
-version = "2.6.0"
-description = "Self-hosted captcha solver: OpenCV grid detection + a fine-tuned Qwen3.5-9B vision LoRA served on vLLM."
+version = "2.6.1"
+description = "Captcha-solving engine and CLI: OpenCV grid detection plus a fine-tuned Qwen3.5-9B vision model, for image grids, click and drag puzzles, sliders, distorted text and animated challenges. Hosted API or self-hosted on vLLM."
 readme = "README.md"
 requires-python = ">=3.10"
 # Source-available, NOT GPL. The CaptchaKraken Source-Available License permits
@@ -14,12 +14,26 @@ requires-python = ">=3.10"
 # — see LICENSE. (GPL-3.0 would wrongly permit all three.)
 license = { file = "LICENSE" }
 authors = [{ name = "Jake Writer" }]
-keywords = ["captcha", "recaptcha", "hcaptcha", "vllm", "qwen", "computer-vision", "automation"]
+keywords = [
+  "captcha", "captcha-solver", "recaptcha", "hcaptcha", "geetest", "turnstile",
+  "yidun", "tencent-captcha", "playwright", "browser-automation", "scraping",
+  "anti-bot", "vllm", "qwen", "computer-vision", "ocr",
+]
 classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
   "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Operating System :: OS Independent",
   "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Scientific/Engineering :: Image Recognition",
+  "Topic :: Internet :: WWW/HTTP :: Browsers",
+  "Topic :: Software Development :: Testing",
   "License :: Other/Proprietary License",
+  "Typing :: Typed",
 ]
 
 # Core = the lightweight CLIENT: OpenCV grid detection + the HTTP planner that
@@ -55,8 +69,11 @@ dev = [
 captchakraken = "captchakraken.cli:main"
 
 [project.urls]
-Homepage = "https://github.com/JWriter20/CaptchaKraken"
+Homepage = "https://captchakraken.com"
+Documentation = "https://github.com/JWriter20/CaptchaKraken#readme"
+Source = "https://github.com/JWriter20/CaptchaKraken"
 Issues = "https://github.com/JWriter20/CaptchaKraken/issues"
+Changelog = "https://github.com/JWriter20/CaptchaKraken/blob/main/CHANGELOG.md"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/captchakraken"]

package/python/src/captchakraken/page_solver.py

@@ -317,6 +317,38 @@ class PageSolverConfig:
     # still a better use of the remaining budget than a timeout.
     keyframe_wait_timeout_ms: int = 6_000
     keyframe_wait_poll_ms: int = 120
+    #: Extra wall clock granted ONCE, the first time a solve escalates to a
+    #: recording. NOT a looser `overall_solve_timeout_ms`.
+    #:
+    #: That budget is sized for ROUNDS — "a round costs ~4-7s, so six is the
+    #: budget". The recording path is not a round. It is a fixed extra stage
+    #: costing the burst, the slice, one MULTI-IMAGE inference (six keyframes,
+    #: several times a still's) and the wait for the widget to come back round
+    #: to the frame the model chose. Nothing in the 45s was ever set aside for
+    #: it, so an escalation started at ~35s ran the clock out mid-burst and
+    #: reported a TIMEOUT — which reads as a slow model rather than as a budget
+    #: with no room for the thing the solver had just decided to do.
+    #:
+    #: Measured 2026-08-22, Tier 3 run 32596340560: EVERY python-port failure on
+    #: hcaptcha_fish_swim_different, hcaptcha_number_with_highest_value_video and
+    #: hcaptcha_tile_flip_video was "exceeded overall_solve_timeout_ms during
+    #: recording the animated challenge", at 45.7-52.7s elapsed. The same three
+    #: fixtures solve in 11-20s on the rounds where the still path happens to
+    #: answer them, so it is the escalation that does not fit, not the puzzle.
+    #:
+    #: Granted only when `video_solve_enabled` — a caller who wants a hard
+    #: deadline turns recording off, which is the switch that already means
+    #: "fail fast rather than spend the recording time".
+    video_extra_inference_ms: int = 8_000
+
+    def video_budget_ms(self) -> int:
+        """What one escalation to recording is allowed to cost, on top.
+
+        DERIVED, so a longer burst or a longer keyframe wait carries its own
+        budget instead of quietly reintroducing the timeout this exists to fix.
+        """
+        return (self.video_burst_duration_ms + self.keyframe_wait_timeout_ms
+                + self.video_extra_inference_ms)
 
     # Grid load / dynamic-refresh timing.
     # How long to wait for hCaptcha's task images to paint before screenshotting
@@ -493,6 +525,9 @@ class PageSolver:
         self._known_animated = False
         self._animated_probe_armed = False
         self._animated_probe_done = False
+        # One-shot: the recording path buys its own budget the first time it is
+        # entered, and never again in the same solve. See video_budget_ms.
+        self._video_budget_granted = False
         self._keyframe_mode: Optional[str] = None
         # Repeat detection; see `max_no_progress_rounds`.
         self._last_answer_sig: Optional[str] = None
@@ -562,6 +597,7 @@ class PageSolver:
         self._known_animated = False
         self._animated_probe_armed = False
         self._animated_probe_done = False
+        self._video_budget_granted = False
         self._keyframe_mode = None
         self._last_answer_sig: Optional[str] = None
         self._no_progress_rounds = 0
@@ -1603,13 +1639,59 @@ class PageSolver:
         total = max(1, round(cfg.video_burst_duration_ms / (1000.0 / fps)))
         interval = 1.0 / fps
 
+        # THE ESCALATION BUYS ITS OWN BUDGET, once per solve.
+        #
+        # `overall_solve_timeout_ms` counts rounds, and this is not a round —
+        # see `video_budget_ms` for the arithmetic and for what it cost not to
+        # have it. Granted here rather than where the probe arms because this is
+        # the one place every path into a recording goes through.
+        if cfg.video_solve_enabled and not self._video_budget_granted:
+            self._video_budget_granted = True
+            if self._deadline_ms is not None:
+                self._deadline_ms += cfg.video_budget_ms()
+                _log(f"[animated] +{cfg.video_budget_ms()}ms for the recording path")
+
+        # Checked ONCE, before the first frame — never per frame.
+        #
+        # A HALF-RECORDED BURST IS WORTHLESS: the slicer reads a clip's temporal
+        # structure, so stopping at frame 27 of 40 does not produce a shorter
+        # answer, it produces a recording that may not contain the screen the
+        # answer is on. Aborting mid-way therefore threw away the whole burst
+        # AND the ~3s already spent making it, to report a timeout. The burst is
+        # also fixed-length and short, so it is not one of the places that "can
+        # legitimately spin for a long time" that `_check_deadline` is for.
+        #
+        # If the budget cannot fit one, say THAT — a caller who has tightened
+        # `overall_solve_timeout_ms` below what a recording costs has asked for
+        # something impossible, and should hear it rather than watch a burst die
+        # partway through every time.
+        if self._deadline_ms is not None:
+            left = self._deadline_ms - time.monotonic() * 1000.0
+            if left < cfg.video_burst_duration_ms:
+                raise CaptchaSolveError(
+                    f"only {left:.0f}ms of the {cfg.overall_solve_timeout_ms}ms solve "
+                    f"budget is left and an animated recording needs "
+                    f"{cfg.video_burst_duration_ms}ms — not starting one that would "
+                    f"be cut off mid-way. Raise overall_solve_timeout_ms or "
+                    f"video_extra_inference_ms, or set video_solve_enabled=False."
+                )
+
         frames: List[Any] = []
 
         remaining = max(0, total - len(frames))
         shot = _tmp_png("burst")
+        # A burst that runs far past its own length is a hung screenshot, not a
+        # tight budget — bounded separately so the two cannot be confused.
+        burst_deadline = (time.monotonic() * 1000.0
+                          + 3 * cfg.video_burst_duration_ms + 5_000)
         try:
             for i in range(remaining):
-                self._check_deadline("recording the animated challenge")
+                if time.monotonic() * 1000.0 > burst_deadline:
+                    raise CaptchaSolveError(
+                        f"the animated recording stalled: {i} of {remaining} frames "
+                        f"in {3 * cfg.video_burst_duration_ms + 5000}ms. The widget "
+                        f"is not screenshotting."
+                    )
                 start = time.monotonic()
                 try:
                     # animations ALLOWED — see `_screenshot`. The JS port has
@@ -2446,28 +2528,37 @@ class PageSolver:
                         _delay(duration)
                         performed_action = True
 
-                # `scope` when there is no vendor iframe. Eight vendors render
-                # into the HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin,
-                # Prosopo, MTCaptcha, BotDetect — so `content_frame()` is None
-                # for all of them and the button was never even SEARCHED FOR,
-                # while the text box and the slider handle it sits beside were
-                # both found through `scope` a few lines above. Two containers
-                # for two halves of one interaction.
-                #
-                # This used to be gated on `typed`, for fear of turning up the
-                # submit of the FORM the captcha guards. `scope` is the widget
-                # container and the xpaths are RELATIVE, so that button is out
-                # of reach by construction; what the gate actually did was make
-                # every non-typed inline puzzle unsubmittable. Measured on the
-                # Tier 3 fixtures: 4 pairs aborting outright and 11 more types
-                # burning all ten solve loops on a puzzle they had answered on
-                # the first one. The press itself is still bounded by
-                # `should_submit` below, which is where the hazard belongs.
-                lookup = frame or (scope if not slid else None)
-                if lookup is not None:
-                    verify_button = self._get_verify_button(lookup)
-                    if verify_button:
-                        self._move_to_element(page, verify_button)
+
+            # Resolve the widget's submit control AFTER the action loop, not
+            # inside it. An empty plan — the correct answer to reCAPTCHA 3x3's
+            # `none_present` variation, where nothing matches and the control
+            # reads SKIP — never enters that loop, so the lookup never ran, the
+            # press below found `verify_button` None, and the round aborted on
+            # 'performed no interactions'. The finder was never the problem:
+            # 'Skip' has always been in its list. It was simply never called for
+            # the one answer shape that performs no other action.
+            # `scope` when there is no vendor iframe. Eight vendors render
+            # into the HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin,
+            # Prosopo, MTCaptcha, BotDetect — so `content_frame()` is None
+            # for all of them and the button was never even SEARCHED FOR,
+            # while the text box and the slider handle it sits beside were
+            # both found through `scope` a few lines above. Two containers
+            # for two halves of one interaction.
+            #
+            # This used to be gated on `typed`, for fear of turning up the
+            # submit of the FORM the captcha guards. `scope` is the widget
+            # container and the xpaths are RELATIVE, so that button is out
+            # of reach by construction; what the gate actually did was make
+            # every non-typed inline puzzle unsubmittable. Measured on the
+            # Tier 3 fixtures: 4 pairs aborting outright and 11 more types
+            # burning all ten solve loops on a puzzle they had answered on
+            # the first one. The press itself is still bounded by
+            # `should_submit` below, which is where the hazard belongs.
+            lookup = frame or (scope if not slid else None)
+            if lookup is not None:
+                verify_button = self._get_verify_button(lookup)
+                if verify_button:
+                    self._move_to_element(page, verify_button)
 
             # Submit policy: press the widget's own submit control whenever we
             # have put an ANSWER into it — a selection, a placed piece, a typed