captchakraken 2.6.1 → 2.8.0

package/dist/solver.js

@@ -35,13 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CaptchaKrakenSolver = exports.SOLVE_DEFAULTS = void 0;
 const watcher_1 = require("./watcher");
-const trajectory_js_1 = require("./trajectory.js");
+const humanize_js_1 = require("./humanize.js");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const crypto_1 = require("crypto");
+const timing_1 = require("./timing");
 const token_usage_1 = require("./token-usage");
 const errors_1 = require("./errors");
 const limits_1 = require("./limits");
@@ -138,14 +139,84 @@ var CaptchaState;
  */
 const VENDOR_WIDGET_LOCATORS = [
     { puzzleSource: 'geetest', selectors: ['.geetest_box', '.geetest_panel_box', '.geetest_popup_window', '.geetest_widget'] },
-    { puzzleSource: 'tencent', selectors: ['iframe#tcaptcha_iframe_dy', 'iframe[id*="tcaptcha"]', 'iframe[src*="captcha.gtimg.com"]', 'iframe[src*="captcha.qq.com"]'] },
+    // Tencent renders IN THE HOST DOCUMENT since 2026-08-11; before that it was
+    // `iframe#tcaptcha_iframe_dy`. Both shapes are listed, in-page first, because
+    // the iframe build is still deployed on sites pinning an older widget and
+    // costs nothing to keep. Dropping the in-page selectors is what made the
+    // client blind to every live Tencent captcha for twelve days.
+    //
+    // `iframe[id^="tcaptcha"]`, NOT `[id*=...]`. The substring form also matched
+    // MTCaptcha's `mtcaptcha-iframe-1` — "mtcaptcha" contains "tcaptcha" — so
+    // Tencent's entry was silently the only thing detecting MTCaptcha at all,
+    // which is why `.mtcap` matching nothing went unnoticed. Anchored, it still
+    // matches the real `tcaptcha_iframe_dy` and claims nobody else's widget.
+    { puzzleSource: 'tencent', selectors: ['#tcaptcha_transform_dy', '#tCaptchaDyContent', '.tencent-captcha-dy__content', 'iframe#tcaptcha_iframe_dy', 'iframe[id^="tcaptcha"]', 'iframe[src*="captcha.gtimg.com"]', 'iframe[src*="captcha.qq.com"]'] },
     { puzzleSource: 'yidun', selectors: ['.yidun_panel', '.yidun'] },
-    { puzzleSource: 'yandex', selectors: ['.CheckboxCaptcha'] },
+    // Yandex SmartCaptcha is IFRAMED, and `.CheckboxCaptcha` is a class inside
+    // that frame's document — querySelector does not cross a frame boundary, so
+    // the host page never carried it and this entry matched nothing, ever.
+    // Challenge frame first, anchor second, exactly like reCAPTCHA above.
+    // `.CheckboxCaptcha` stays for an inline embed that renders it directly.
+    { puzzleSource: 'yandex', selectors: ['iframe[src*="smartcaptcha.yandexcloud.net/advanced"]', 'iframe[src*="smartcaptcha.yandexcloud.net"]', '.CheckboxCaptcha'] },
     { puzzleSource: 'lemin', selectors: ['#lemin-cropped-captcha', '.lemin-captcha-popup'] },
     { puzzleSource: 'prosopo', selectors: ['.prosopo-modalInner', '.procaptcha-checkbox'] },
-    { puzzleSource: 'mtcaptcha', selectors: ['.mtcap'] },
+    // MTCaptcha is IFRAMED too: `<div class="mtcaptcha"><iframe
+    // id="mtcaptcha-iframe-1" src="https://service.mtcaptcha.com/...">`. `.mtcap`
+    // is the class prefix used INSIDE that frame (`mtcap-inputtext`), and a CSS
+    // class selector matches whole tokens, so it never matched the host page's
+    // `class="mtcaptcha"` either. Kept last for an inline embed.
+    { puzzleSource: 'mtcaptcha', selectors: ['iframe[src*="service.mtcaptcha.com"]', 'iframe[id^="mtcaptcha-iframe"]', '.mtcaptcha', '.mtcap'] },
     { puzzleSource: 'botdetect', selectors: ['.BDC_CaptchaDiv'] },
 ];
+/**
+ * Which vendor's code the page LOADED, as opposed to what it rendered.
+ * Mirrors VENDOR_URL_MARKERS in page_solver.py — CLAUDE.md 1c.
+ *
+ * A selector is a claim about markup, and markup is the half of a captcha the
+ * vendor is free to rewrite overnight — it is an anti-bot surface, so churn is
+ * the point. The REQUEST is far more stable: Tencent moved its widget out of an
+ * iframe and renamed every class on 2026-08-11, and went on fetching from
+ * `turing.captcha.gtimg.com` and `turing.captcha.qcloud.com` throughout. The
+ * substring `captcha.gtimg.com` — already in the table above, on a selector
+ * that stopped matching — never left the wire.
+ *
+ * This is a TRIPWIRE, not a detection path. A URL says which vendor is on the
+ * page; it cannot say where the widget is, and the solver needs an ELEMENT to
+ * screenshot, to scope its controls against, and to drag. What it buys is
+ * telling apart the two things a null detection can mean: no captcha here, or
+ * the vendor's code is loaded and running and nothing we look for matches.
+ *
+ * Hosts measured 2026-08-24 from each vendor's demo page.
+ */
+/**
+ * The two vendors with bespoke handling in this file. EVERYTHING else shares the
+ * generic path, and the two behaviours below are gated on "not one of these" —
+ * spelled as this set rather than as `=== 'unknown'`, which is what they used to
+ * say. The two were identical only while `unknown` was the sole third value, so
+ * the day anyone reports a vendor by name — to constrain which grid shapes it may
+ * be solved as, say — `=== 'unknown'` silently turns OFF typed-challenge detection
+ * for MTCaptcha, Yandex and BotDetect (all three ARE typed captchas) and the
+ * animated settle probe for GeeTest and Tencent. Neither failure throws; the text
+ * captcha just becomes unsolvable and the animated board gets answered from one
+ * arbitrary frame. Mirrors VENDORS_WITH_BESPOKE_HANDLING in page_solver.py.
+ */
+const VENDORS_WITH_BESPOKE_HANDLING = new Set(['hcaptcha', 'recaptcha']);
+const VENDOR_URL_MARKERS = [
+    { puzzleSource: 'hcaptcha', hosts: ['hcaptcha.com'] },
+    { puzzleSource: 'recaptcha', hosts: ['google.com/recaptcha', 'recaptcha.net'] },
+    { puzzleSource: 'turnstile', hosts: ['challenges.cloudflare.com'] },
+    { puzzleSource: 'geetest', hosts: ['geetest.com'] },
+    { puzzleSource: 'tencent', hosts: ['captcha.gtimg.com', 'captcha.qcloud.com'] },
+    { puzzleSource: 'yidun', hosts: ['dun.163.com', 'cstaticdun.126.net', 'necaptcha.nosdn.127.net'] },
+    { puzzleSource: 'yandex', hosts: ['smartcaptcha.yandexcloud.net'] },
+    { puzzleSource: 'lemin', hosts: ['leminnow.com'] },
+    { puzzleSource: 'prosopo', hosts: ['prosopo.io'] },
+    { puzzleSource: 'mtcaptcha', hosts: ['mtcaptcha.com'] },
+    // BotDetect is deliberately absent and must stay absent: it is a SELF-HOSTED
+    // library, so the image comes from the application's own origin and there is
+    // no vendor host to see. An empty result for a BotDetect page means "this
+    // check does not apply", not "no captcha".
+];
 /**
  * Where the answer goes, when it is not a click. Mirrors TEXT_INPUT_SELECTORS /
  * SLIDER_HANDLE_SELECTORS / DRAGGABLE_PIECE_SELECTORS in page_solver.py — keep
@@ -161,7 +232,12 @@ const VENDOR_WIDGET_LOCATORS = [
  * pages. Vendors rename these classes without notice, and our own Tier 3
  * fixtures render neither vendor's DOM.
  */
-const TEXT_INPUT_SELECTORS = [
+// Split in two because the two halves are safe in different places. The NAMED
+// half identifies a captcha's answer box wherever it sits; the GENERIC half only
+// means "the text box in this widget" and is trustworthy only when the scope
+// already is the widget. `answerBox` widens past the widget for BotDetect and
+// may take the named half with it, never the generic one.
+const TEXT_INPUT_VENDOR_SELECTORS = [
     // BotDetect — the input is application-defined, so match the id fragment its
     // own docs and samples use (the three the nightly collector already drives).
     'input[id*=captchaCode]',
@@ -175,6 +251,8 @@ const TEXT_INPUT_SELECTORS = [
     '.AdvancedCaptcha-Input input',
     'input.Textinput-Control',
     'input[name="rep"]',
+];
+const TEXT_INPUT_GENERIC_SELECTORS = [
     // Generic — an input the page itself labels as the captcha answer.
     'input[name*="captcha" i]',
     'input[id*="captcha" i]',
@@ -188,6 +266,9 @@ const TEXT_INPUT_SELECTORS = [
     'input[type=tel]',
     'textarea',
 ];
+const TEXT_INPUT_SELECTORS = [
+    ...TEXT_INPUT_VENDOR_SELECTORS, ...TEXT_INPUT_GENERIC_SELECTORS,
+];
 /**
  * The handle you drag on a puzzle-piece slider. NOT the piece: on every one of
  * these vendors the piece is inert decoration that the handle carries, so a
@@ -198,7 +279,10 @@ const SLIDER_HANDLE_SELECTORS = [
     '.geetest_slider_button',
     '.geetest_btn',
     '.geetest_slider .geetest_arrow',
-    // Tencent
+    // Tencent. The post-2026-08-11 knob is a bare div — no id, no role=slider,
+    // no aria-valuenow — so every generic fallback below misses it and it has to
+    // be named. The three after it are the pre-redesign widget.
+    '.tencent-captcha-dy__slider-block',
     '#tcaptcha_drag_thumb',
     '.tc-slider-normal',
     '[id*=slideBlock]',
@@ -251,6 +335,15 @@ exports.SOLVE_DEFAULTS = {
     overallSolveTimeoutMs: 45000,
 };
 class CaptchaKrakenSolver {
+    /**
+     * Attribute the enclosed wall-clock to `name` for this solve's budget.
+     *
+     * A no-op outside a solve, so every helper stays callable from tests and from
+     * the watcher without a budget having been opened.
+     */
+    ph(name, fn) {
+        return this.budget ? this.budget.phase(name, fn) : fn();
+    }
     constructor(config = {}) {
         /** Extra ms this solve has been granted for a recording; see recordKeyframeBurst. */
         this.videoBudgetMs = 0;
@@ -317,24 +410,108 @@ class CaptchaKrakenSolver {
         // session id lets the gateway bill them as one capped attempt rather than N
         // independent ones. Null outside a solve; ignored entirely when self-hosting.
         this.solveSessionId = null;
+        /** Interpreter + CLI root, resolved once. See resolveCli. */
+        this.cliCache = null;
+        /** The LoRA name models.json calls `latest`, read once. See askModel. */
+        this.loraNameCache = null;
+        /**
+         * Phase accounting for the CURRENT or MOST RECENT solve; see timing.ts.
+         * Null before the first solve, and readable after a failed one.
+         */
+        this.budget = null;
         this.config = config;
-        this.lastMousePosition = config.startingMousePosition ?? { x: 100, y: 100 };
+        this.human = (0, humanize_js_1.resolveHumanizer)({
+            ...config,
+            startingMousePosition: config.startingMousePosition ?? { x: 100, y: 100 },
+        });
+    }
+    /**
+     * Where the pointer is. Owned by the humanizer, because a mode that
+     * dispatches no motion (mobile, between taps) still has to answer this.
+     */
+    get lastMousePosition() {
+        return { x: this.human.at[0], y: this.human.at[1] };
+    }
+    set lastMousePosition(v) {
+        this.human.at = [v.x, v.y];
     }
     async solve(page) {
         this.solveSessionId = (0, crypto_1.randomUUID)();
+        this.budget = new timing_1.PhaseBudget();
+        // FALSE unless the solve returns a solved result. A solve that throws never
+        // sets it, which is the right default: the widget did not accept, and the
+        // boards that made it throw are exactly the ones worth keeping.
+        let solvedForReport = false;
         try {
-            return await this.solveImpl(page);
+            const result = await this.solveImpl(page);
+            // Attached HERE rather than at each of the four `isSolved:` sites, so a
+            // new early exit cannot forget it.
+            if (result)
+                result.phases = this.budget.toObject();
+            solvedForReport = result?.isSolved === true;
+            return result;
         }
         finally {
+            // Printed on the way out of every solve, success or failure — a solve
+            // that FAILED is exactly the one whose time you want itemised.
+            if ((0, timing_1.timingsEnabled)())
+                console.error(this.budget.report());
+            // NOT cleared. A solve that FAILED is exactly the one whose time you want
+            // itemised, and by the time the caller catches the error the result — the
+            // only thing `phases` rides on — does not exist. `solve()` replaces it on
+            // entry, so the next solve cannot read the last one's. Same lifetime as
+            // page_solver.py's `_budget`.
             // Always shut the persistent CV worker down when a solve ends (success,
             // failure, or timeout) so we never leak a python process between solves.
             this.teardownCvWorker();
             this.cvWorkerReady = null;
+            // BEFORE the id is cleared, so the report names this solve.
+            this.reportOutcome(this.solveSessionId, solvedForReport);
             // Clear last: a stale id leaking into the NEXT solve would merge two
             // separate captchas into one billable attempt.
             this.solveSessionId = null;
         }
     }
+    /**
+     * Tell the hosted API whether the widget accepted — the one fact the server
+     * cannot see for itself, since a wrong answer reaches it as a 200 with
+     * well-formed JSON in it.
+     *
+     * THROUGH THE PYTHON CLI, not a `fetch` here. The endpoint, the credential,
+     * the extra-header handling and the "one 404 and stop asking" rule all live
+     * in `planner.report_outcome`; a second copy in TypeScript would agree with
+     * it until one of them was edited. That is the drift `model-name.ts` exists
+     * to prevent, on the same seam, and this port already crosses that subprocess
+     * boundary for every model call.
+     *
+     * NOT AWAITED, and detached. The solve is over and its result is decided, so
+     * nothing here may add latency to what the caller gets back or keep the
+     * process alive past it. `unref()` is what makes the second true.
+     */
+    reportOutcome(sessionId, solved) {
+        if (!sessionId)
+            return;
+        // CHECKED HERE, NOT ONLY IN PYTHON. The Python side honours the same
+        // variable, but this port spawns a PROCESS to ask it — and against an
+        // endpoint with no such route (a local vLLM, every fixture run) that
+        // process exists only to be told 404. Python's "one 404 and stop asking"
+        // latch cannot help here either, because each solve is a fresh process.
+        // Tier 3 sets this, and drives ~100 solves per run on one box.
+        if (process.env.CAPTCHA_REPORT_OUTCOME === '0')
+            return;
+        try {
+            const { cliRoot, py } = this.resolveCli();
+            const child = (0, child_process_1.spawn)(py, ['-m', 'captchakraken.cli', 'report-outcome', sessionId, solved ? 'solved' : 'failed'], { cwd: cliRoot, env: cliEnv(cliRoot), detached: true, stdio: 'ignore' });
+            // A report that cannot be sent is not the caller's problem, and an
+            // unhandled 'error' event on a spawn is an uncaught exception in Node.
+            child.on('error', () => { });
+            child.unref();
+        }
+        catch {
+            // resolveCli throws when the bundled engine is missing, which is already
+            // a loud failure everywhere it matters. Not here.
+        }
+    }
     /**
      * Install an auto-solver: probe `page` on a timer and solve any captcha that
      * becomes visible, until `stop()`.
@@ -365,6 +542,7 @@ class CaptchaKrakenSolver {
         this.imageCounter = 0;
         this.stepIndex = 0;
         this.solveStartMs = start;
+        await this.human.reset(page);
         this.resetSolveState();
         this.setState(CaptchaState.Detecting);
         // Initialize session debug directory if debugging is enabled
@@ -444,7 +622,7 @@ class CaptchaKrakenSolver {
                     tokenUsage: (0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage),
                 };
             }
-            const captchaElement = await this.detectCaptcha(page);
+            const captchaElement = await this.ph('detect', () => this.detectCaptcha(page));
             if (!captchaElement) {
                 // Two-stage detection. detectCaptcha() returns null when there's no
                 // VISIBLE, unsolved widget — but that splits into two cases:
@@ -470,8 +648,7 @@ class CaptchaKrakenSolver {
                 // No interactive widget in the DOM (reCAPTCHA v3 / invisible, or an
                 // hCaptcha that only triggers on user action), or it never rendered.
                 // Fail fast rather than burning the whole loop budget.
-                throw new Error('No interactive captcha widget detected (likely reCAPTCHA v3 / '
-                    + 'invisible or a click-triggered challenge). Failing fast.');
+                throw new Error(await this.noWidgetMessage(page));
             }
             console.log(`\n--- Captcha Solve Loop ${attempt}/${maxSolveLoops} ---`);
             const retryModeThisLoop = pendingRetryMode;
@@ -503,7 +680,7 @@ class CaptchaKrakenSolver {
                         // it to settle before retrying; if it never settles it's animated.
                         const el = await this.detectCaptcha(page);
                         if (el) {
-                            const s = await this.waitForElementSettled(el);
+                            const s = await this.ph('settle', () => this.waitForElementSettled(el));
                             if (s === 'animated') {
                                 // Used to be terminal. Now it just means the next round is an
                                 // animated puzzle: retry the loop and solveSingle takes the
@@ -561,32 +738,72 @@ class CaptchaKrakenSolver {
             }
             renderWaits = 0;
             cumulativeTokenUsage.push(...tokenUsage);
-            // After acting, poll for the vendor's SOLVED signal (anchor checkbox
-            // checked / response token) for a short window before falling back to the
-            // normal re-detect. hCaptcha keeps the challenge iframe visible for a
-            // couple seconds while it verifies the final answer; without this, the
-            // loop re-entered the pipeline on that closing frame and burned ~18s
-            // (waitForHcaptchaChallengeImages timing out on a prompt-less frame).
-            // This ONLY early-returns on a definitive solved signal — it never
-            // re-solves, so it can't loop. If not solved in the window, the original
-            // detectCaptcha path below handles a genuine next round exactly as before.
+            // ONE wait after a round, polled, whichever kind of round it was.
+            //
+            // There used to be two: this poll when the round interacted, and a flat
+            // `delay(postSolveDelayMs + jitter)` when it did not. The flat sleep
+            // observed NOTHING — it ran to the end and only then asked whether the
+            // widget was still there — so a round that had in fact finished the
+            // captcha paid 1200-1500ms to find that out. The poll below already asks
+            // exactly that question and answers it the moment it becomes true.
+            //
+            // The two windows keep different LENGTHS, because different things size
+            // them: postSolveOutcomeTimeoutMs covers how late a vendor's success
+            // signal can arrive (measured — see types.ts), while postSolveDelayMs is
+            // the dwell a round that answered nothing takes before deciding the page
+            // has settled. Mirrors page_solver.py; the ports must not disagree about
+            // how long a round costs.
+            //
+            // hCaptcha keeps the challenge iframe visible for a couple of seconds
+            // while it verifies the final answer; without this window the loop
+            // re-entered the pipeline on that closing frame and burned ~18s. It ONLY
+            // early-returns on a definitive signal, so it cannot loop.
             const settleMs = didInteract
                 ? (this.config.postSolveOutcomeTimeoutMs ?? 1000)
                 : postSolveDelayMs + Math.random() * 300;
-            if (didInteract) {
+            {
                 const deadline = Date.now() + settleMs;
+                const verdictT0 = Date.now();
                 let solved = false;
+                let widgetGone = 0;
                 while (Date.now() < deadline) {
                     if (await this.isCaptchaSolved(page)) {
                         solved = true;
                         break;
                     }
+                    // The eight inline vendors have NO response token, so
+                    // `isCaptchaSolved` — which reads only the hCaptcha and reCAPTCHA
+                    // anchors — can never fire for them, and this loop ran out its whole
+                    // window on EVERY round waiting for a signal that cannot arrive.
+                    // "The widget is gone" is their completion signal and is already the
+                    // authority immediately after this loop, so this only reaches the
+                    // same verdict sooner — confirmed over two polls so a frame caught
+                    // mid-swap between rounds cannot read as a solve. page_solver.py has
+                    // had this since the geetest_v4_slide measurement (5.2s of a 12.3s
+                    // solve, spent after the puzzle was already answered); this port had
+                    // not, which is most of why it measured slower on those vendors.
+                    if (!(await this.detectCaptcha(page))) {
+                        widgetGone += 1;
+                        if (widgetGone >= 2) {
+                            solved = true;
+                            break;
+                        }
+                    }
+                    else {
+                        widgetGone = 0;
+                    }
                     // A fresh next round has rendered → stop waiting, go solve it now
                     // (keeps multi-round solves fast instead of burning the full window).
                     if (await this.isChallengeFreshlyRendered(page))
                         break;
                     await delay(this.config.postSolveOutcomePollMs ?? 75);
                 }
+                this.budget?.add(didInteract ? 'await-verdict' : 'post-submit-delay', Date.now() - verdictT0);
+                // How long a SUCCESS actually took to show itself — the only number
+                // that can size postSolveOutcomeTimeoutMs. A round that ends any other
+                // way spends the whole window by construction.
+                if (solved)
+                    console.log(`[verdict] success signal arrived after ${Date.now() - verdictT0}ms`);
                 if (solved) {
                     return {
                         isSolved: true,
@@ -595,9 +812,6 @@ class CaptchaKrakenSolver {
                     };
                 }
             }
-            else {
-                await delay(settleMs);
-            }
             // Detect reCAPTCHA's under-selection error banner. If present, the
             // vendor rejected our last submission because the model missed at
             // least one matching tile. Set the retry flag for the next loop so
@@ -645,9 +859,17 @@ class CaptchaKrakenSolver {
         this.stepIndex++;
         let screenshotPath = path.join(os.tmpdir(), `step_${this.stepIndex}_${Date.now()}_${Math.floor(Math.random() * 1e9)}.png`);
         try {
+            // ITS OWN, SHORT TIMEOUT — not `elementScreenshotTimeoutMs`, which is
+            // sized for the picture the MODEL reads and is 8s. This one is an
+            // observability snapshot, and `animations: 'disabled'` makes Playwright
+            // wait for the element to stop moving before it will take it. On a widget
+            // that is still animating that wait ran to the full 8s, per step:
+            // measured 8.0s of a 12.0s mtcaptcha_text solve, spent photographing a
+            // text box for a trace. An observer must never cost more than the action
+            // it is observing, and a missed frame in a trace costs nothing.
             await captchaElement.screenshot({
                 path: screenshotPath,
-                timeout: this.config.elementScreenshotTimeoutMs ?? 8000,
+                timeout: this.config.stepScreenshotTimeoutMs ?? 2000,
                 animations: 'disabled',
             });
         }
@@ -672,9 +894,13 @@ class CaptchaKrakenSolver {
         }
     }
     async solveSingle(page, captchaElement, attempt, retryMode = null) {
-        // Vendor hint helps the CLI route to the right pipeline (hCaptcha click
-        // puzzles must never go through grid detection — find_grid false-positives
-        // on the header+footer bands).
+        // Vendor hint constrains which grid SHAPES the CLI may solve a detection as.
+        // find_grid false-positives on the header+footer bands of hCaptcha's click
+        // puzzles, and hCaptcha ships only a 3x3 — so a 16-cell lattice on one is a
+        // contradiction and is dropped back to the click path. It is not a blanket
+        // skip: hcaptcha_grid_3x3_property is a real grid and still solves as one.
+        // Anything that is not hCaptcha or reCAPTCHA reports 'unknown' and is
+        // allowed every shape (GeeTest and Prosopo both ship real 3x3 grids).
         const src = await captchaElement.getAttribute('src').catch(() => null);
         const puzzleSource = src && src.includes('hcaptcha.com')
             ? 'hcaptcha'
@@ -705,8 +931,8 @@ class CaptchaKrakenSolver {
         // opposite answers. Restricted to `unknown` because neither hCaptcha nor
         // reCAPTCHA has ever served a typed challenge, so a match inside one of
         // their frames would be a false positive by definition.
-        const textMode = puzzleSource === 'unknown'
-            && (await this.findControl(scope, TEXT_INPUT_SELECTORS)) !== null;
+        const textMode = !VENDORS_WITH_BESPOKE_HANDLING.has(puzzleSource)
+            && (await this.answerBox(scope, captchaElement)) !== null;
         if (textMode) {
             console.log('Widget has a text box; solving as a distorted-text captcha.');
         }
@@ -725,12 +951,12 @@ class CaptchaKrakenSolver {
         if (puzzleSource === 'hcaptcha' && src && src.includes('frame=challenge')) {
             if (this.lastSubmitFrameHash) {
                 this.setState(CaptchaState.Transitioning);
-                await this.waitForChangeSince(captchaElement, this.lastSubmitFrameHash);
+                await this.ph('await-next-round', () => this.waitForChangeSince(captchaElement, this.lastSubmitFrameHash));
                 this.lastSubmitFrameHash = null;
             }
             this.setState(CaptchaState.Loading);
-            await this.waitForHcaptchaChallengeImages(captchaElement);
-            const settle = await this.waitForElementSettled(captchaElement);
+            await this.ph('hcaptcha-images', () => this.waitForHcaptchaChallengeImages(captchaElement));
+            const settle = await this.ph('settle', () => this.waitForElementSettled(captchaElement));
             if (settle === 'animated') {
                 // A challenge that never settles is animated BY DESIGN — hCaptcha's
                 // "select the odd animal" fades its sprites on independent cycles, and
@@ -754,14 +980,15 @@ class CaptchaKrakenSolver {
             }
             this.setState(CaptchaState.Ready);
         }
-        else if (puzzleSource === 'unknown' && this.config.videoSolveEnabled !== false) {
+        else if (!VENDORS_WITH_BESPOKE_HANDLING.has(puzzleSource)
+            && this.config.videoSolveEnabled !== false) {
             // Non-hCaptcha, non-reCAPTCHA widgets (GeeTest, Tencent, …). The settle probe
             // was never run for these, so an animated one — GeeTest's svg board cycles its
             // glyph set — was screenshotted mid-cycle and answered from whatever single
             // moment we happened to catch. reCAPTCHA is excluded on purpose: it has its own
             // readiness gate below, its grids are never animated, and a second probe would
             // only add latency to a path that already works.
-            if (await this.waitForElementSettled(captchaElement) === 'animated') {
+            if (await this.ph('settle', () => this.waitForElementSettled(captchaElement)) === 'animated') {
                 console.log('[animated] challenge never settles — recording it');
                 isAnimated = true;
             }
@@ -794,7 +1021,7 @@ class CaptchaKrakenSolver {
         // reCAPTCHA attempts into 3x3 vs 4x4 without scraping debug logs.
         let establishedGridSize = null;
         if (isRecaptchaChallenge) {
-            await this.waitForGridCellsLoaded(captchaElement);
+            await this.ph('grid-load', () => this.waitForGridCellsLoaded(captchaElement));
             // Only a 3x3 reCAPTCHA ever refreshes its tiles in place (blank/fade →
             // new image), so only a 3x3 can need the multi-round driver: click →
             // hover/wait for fades → re-solve. Whether THIS one does is decided inside
@@ -815,11 +1042,11 @@ class CaptchaKrakenSolver {
         }
         // 1. Take Screenshot
         const screenshotPath = path.join(os.tmpdir(), `captcha_${Date.now()}_${Math.floor(Math.random() * 1e9)}.png`);
-        await captchaElement.screenshot({
+        await this.ph('screenshot', () => captchaElement.screenshot({
             path: screenshotPath,
             timeout: this.config.elementScreenshotTimeoutMs ?? 8000,
             animations: 'disabled',
-        });
+        }));
         // Save image to debug directory if debugging is enabled
         this.saveImageForDebug(screenshotPath);
         // Baseline screenshot before any action is taken. Emitted once per solve
@@ -843,11 +1070,11 @@ class CaptchaKrakenSolver {
             //    a stale frame, so we re-screenshot and re-solve on the developed one.
             let response;
             if (isAnimated) {
-                burstDir = await this.recordKeyframeBurst(captchaElement);
-                response = await this.withIdleWander(page, captchaElement, () => this.getAnimatedSolution(burstDir));
+                burstDir = await this.ph('burst', () => this.recordKeyframeBurst(captchaElement));
+                response = await this.ph('inference', () => this.withIdleWander(page, captchaElement, () => this.getAnimatedSolution(burstDir)));
             }
             else {
-                response = await this.solveFrameFreshnessGuarded(captchaElement, screenshotPath, (imagePath) => this.withIdleWander(page, captchaElement, () => this.getSolution(imagePath, puzzleSource, retryMode, textMode)));
+                response = await this.ph('inference', () => this.solveFrameFreshnessGuarded(captchaElement, screenshotPath, (imagePath) => this.withIdleWander(page, captchaElement, () => this.getSolution(imagePath, puzzleSource, retryMode, textMode))));
             }
             const actions = response.actions;
             allTokenUsage = response.token_usage;
@@ -888,7 +1115,7 @@ class CaptchaKrakenSolver {
                                 await this.waitForKeyframe(captchaElement, c.await_keyframe, ...bboxCenter(bbox));
                             }
                             await this.executeClick(page, captchaElement, { ...c, target_bounding_box: bbox }, elementBox);
-                            await delay(Math.random() * 80 + 80);
+                            await this.human.pause('between');
                         }
                     }
                     else {
@@ -923,7 +1150,7 @@ class CaptchaKrakenSolver {
                     await this.emitStep(captchaElement, 'drag', 'drag', puzzleSource, frameRole, attempt, { action });
                 }
                 else if (action.action === 'type') {
-                    if (await this.executeType(page, scope, action)) {
+                    if (await this.executeType(page, scope, action, captchaElement)) {
                         performedAction = true;
                         typed = true;
                         await this.emitStep(captchaElement, 'type', 'typed the code', puzzleSource, frameRole, attempt, { action });
@@ -958,12 +1185,15 @@ class CaptchaKrakenSolver {
             // 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) {
+            if (lookup)
                 verifyButton = await this.getVerifyButton(lookup);
-                if (verifyButton) {
-                    await this.move(page, verifyButton);
-                }
-            }
+            // RESOLVED, not travelled to. `moveAndClick` below moves to the button
+            // itself, and it picks its own random point inside it — so moving here
+            // first bought a second humanised trajectory that ended a few dozen
+            // pixels from where the first one stopped, plus a second bounded
+            // scroll-into-view. Two hops to one button is slower AND is not
+            // something a hand does. A round that decides not to submit no longer
+            // walks to the control either.
             // '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
@@ -1349,6 +1579,64 @@ class CaptchaKrakenSolver {
      * `size=invisible` in the src, and never an `api2/bframe` challenge frame, so
      * we exclude the invisible variant here.
      */
+    /**
+     * Which vendors' code this page actually loaded.
+     *
+     * Read out of the page's own resource timing plus the `src`/`href` of
+     * everything it linked, so it works whenever it is called — a request
+     * listener would have to have been attached before navigation, and by the
+     * time a solve fails that ship has sailed.
+     *
+     * Best-effort by construction: the resource-timing buffer is finite and a
+     * page may have cleared it. An empty answer is "nothing seen", never "no
+     * captcha here". Mirrors `vendors_on_the_wire` in page_solver.py.
+     */
+    async vendorsOnTheWire(page) {
+        let names = [];
+        try {
+            // `$eval('html', ...)` rather than `evaluate`: PlaywrightPage is a
+            // structural subset carrying exactly the members the solver uses, and
+            // widening it would oblige every adapter (puppeteer-adapter.ts) to grow a
+            // member for one diagnostic. The callback runs in the page either way.
+            names = await page.$eval('html', () => {
+                const out = [];
+                try {
+                    for (const e of performance.getEntriesByType('resource'))
+                        out.push(e.name);
+                }
+                catch (err) { /* buffer unavailable */ }
+                for (const el of Array.from(document.querySelectorAll('script[src],iframe[src],link[href],img[src]'))) {
+                    out.push(el.getAttribute('src') || el.getAttribute('href') || '');
+                }
+                return out;
+            });
+        }
+        catch {
+            return [];
+        }
+        const blob = (names ?? []).join(' ');
+        return VENDOR_URL_MARKERS
+            .filter(({ hosts }) => hosts.some((h) => blob.includes(h)))
+            .map(({ puzzleSource }) => puzzleSource);
+    }
+    /**
+     * Why nothing was found — the two cases told apart. The old text guessed
+     * "reCAPTCHA v3 / invisible" every time, including the times a vendor had
+     * simply moved its DOM. See VENDOR_URL_MARKERS.
+     */
+    async noWidgetMessage(page) {
+        const base = 'No interactive captcha widget detected';
+        const loaded = await this.vendorsOnTheWire(page);
+        if (!loaded.length) {
+            return `${base} (no vendor captcha code loaded on this page — likely `
+                + 'reCAPTCHA v3 / invisible, or a click-triggered challenge that has '
+                + 'not been triggered). Failing fast.';
+        }
+        return `${base}, BUT ${loaded.join('/')} code IS loaded and running on this `
+            + 'page. The vendor\'s markup no longer matches anything in '
+            + 'VENDOR_WIDGET_LOCATORS — re-measure with '
+            + 'scripts/check_vendor_selectors.py and update BOTH solver ports.';
+    }
     async hasInteractiveWidgetInDom(page) {
         // reCAPTCHA v2 anchor, but NOT the invisible (v3 / invisible-v2) variant.
         const recaptchaAnchors = await page.$$('iframe[src*="recaptcha/api2/anchor"]');
@@ -1559,7 +1847,28 @@ class CaptchaKrakenSolver {
      * falling back to the configured/`python` command. Throws if the CLI folder
      * is missing — callers that must not throw (e.g. runCliTool) wrap this.
      */
+    /**
+     * The adapter name models.json calls `latest`, resolved once per solver.
+     *
+     * `resolveLoraName` reads models.json (and pinned_model.json) off disk
+     * SYNCHRONOUSLY, and it was doing that on every inference for a file that
+     * cannot change inside one process.
+     */
+    loraName(cliRoot) {
+        if (this.loraNameCache === null)
+            this.loraNameCache = (0, model_name_1.resolveLoraName)({ cliRoot });
+        return this.loraNameCache;
+    }
     resolveCli() {
+        // MEMOISED. `resolvePythonCommand` probes the interpreter with a
+        // `spawnSync(cmd, ['--version'])`, which blocks the whole Node event loop —
+        // Playwright's socket pump and every timer with it — and this was called on
+        // EVERY inference, every CV fallback and every worker start. On the
+        // npm-install default (no bundled venv, nothing configured) that is up to
+        // two blocking process spawns per model call, for an answer that cannot
+        // change inside one process.
+        if (this.cliCache)
+            return this.cliCache;
         const { repoPath, pythonCommand } = this.config;
         const cliRoot = repoPath ?? (0, model_name_1.getBundledCliRoot)();
         if (!fs.existsSync(cliRoot)) {
@@ -1575,7 +1884,8 @@ class CaptchaKrakenSolver {
             venvPython: getVenvPython(cliRoot),
             exists: commandExists,
         });
-        return { cliRoot, py };
+        this.cliCache = { cliRoot, py };
+        return this.cliCache;
     }
     /**
      * Run an OpenCV tool subcommand of the CLI (e.g. `grid-cell-states a.png
@@ -1927,6 +2237,10 @@ class CaptchaKrakenSolver {
     }
     /** Smooth-move the mouse over one cell's center with intra-cell jitter. */
     async hoverCell(page, session, cell) {
+        // A hover is mimicry of a resting CURSOR, so on a device that has none it
+        // is not weaker mimicry — it is a mousemove at a touch-only widget.
+        if (!this.human.hovers)
+            return;
         const cellWPage = (session.gridBoxes[0][2] - session.gridBoxes[0][0]) * session.scaleX;
         const cellHPage = (session.gridBoxes[0][3] - session.gridBoxes[0][1]) * session.scaleY;
         const center = this.cellCenterPage(cell, session);
@@ -2238,13 +2552,19 @@ class CaptchaKrakenSolver {
         });
         for (let round = 1; round <= maxRounds; round++) {
             // 1. Settle and screenshot.
-            await this.waitForGridCellsLoaded(captchaElement);
+            //
+            // Round 1 skips the wait: `solveSingle` has just paid it, read the grid
+            // boxes off the loaded board and handed over, and nothing has touched
+            // the widget in between. Rounds 2..N still wait, because by then THIS
+            // driver has clicked and the tiles really are reloading.
+            if (round > 1)
+                await this.ph('grid-load', () => this.waitForGridCellsLoaded(captchaElement));
             const shotA = path.join(os.tmpdir(), `recap_${Date.now()}_${Math.floor(Math.random() * 1e9)}.png`);
             try {
                 // Explicit timeout — after a Verify this element is being torn down,
                 // and the 30s default waits for it to go stable first. See
                 // screenshot-timeouts.test.ts.
-                await captchaElement.screenshot({ path: shotA, timeout: 2500, animations: 'disabled' });
+                await this.ph('screenshot', () => captchaElement.screenshot({ path: shotA, timeout: 2500, animations: 'disabled' }));
             }
             catch {
                 // The board is gone. Stop driving rounds and let the outer loop
@@ -2275,7 +2595,7 @@ class CaptchaKrakenSolver {
                 //    (the dynamic 3x3 puzzle is the case this matters most for).
                 const retryForThisRound = pendingRetry;
                 pendingRetry = null; // only the first round carries the inbound retry hint
-                const response = await this.solveFrameFreshnessGuarded(captchaElement, shotA, (imagePath) => this.getSolution(imagePath, 'recaptcha', retryForThisRound));
+                const response = await this.ph('inference', () => this.solveFrameFreshnessGuarded(captchaElement, shotA, (imagePath) => this.getSolution(imagePath, 'recaptcha', retryForThisRound)));
                 this.archiveLatestDebugRun(attempt, response.actions);
                 allTokenUsage.push(...response.token_usage);
                 const actionList = Array.isArray(response.actions) ? response.actions : [response.actions];
@@ -2302,8 +2622,10 @@ class CaptchaKrakenSolver {
                 // Tiles are still loading; the CLI explicitly told us NOT to submit.
                 // Find what's loading, hover it, and wait for at least one to settle.
                 console.log(`[recaptcha-grid] round ${round}: CLI says wait (${action.duration_ms ?? 0}ms).`);
-                const { loading } = await this.watchClickedTiles(page, captchaElement, session, clickedOrder);
-                await this.waitForAnyClickedTileLoaded(page, captchaElement, session, loading);
+                await this.ph('fade-wait', async () => {
+                    const { loading } = await this.watchClickedTiles(page, captchaElement, session, clickedOrder);
+                    await this.waitForAnyClickedTileLoaded(page, captchaElement, session, loading);
+                });
                 continue;
             }
             if (action.action === 'click') {
@@ -2327,7 +2649,7 @@ class CaptchaKrakenSolver {
                         clickedOrder.push(cell);
                         clickedThisRound.push(cell);
                     }
-                    await delay(Math.random() * 80 + 80);
+                    await this.human.pause('between');
                 }
                 performedAction = true;
                 console.log(`[recaptcha-grid] round ${round}: clicked ${bboxes.length} tile(s) -> cells ${JSON.stringify(clickedThisRound)}.`);
@@ -2337,7 +2659,7 @@ class CaptchaKrakenSolver {
                 //    this board is answered) or go blank / fade out for a replacement
                 //    (dynamic puzzle: read it again). reCAPTCHA's reply lags the click,
                 //    so we watch a grace window, not a single instant-after snapshot.
-                const { loading, chipped } = await this.watchClickedTiles(page, captchaElement, session, clickedThisRound);
+                const { loading, chipped } = await this.ph('fade-wait', () => this.watchClickedTiles(page, captchaElement, session, clickedThisRound));
                 if (chipped || !loading.length) {
                     // Either the widget ticked our clicks and kept the photos — a board
                     // that does that is fully answered by the round that clicked it — or
@@ -2351,7 +2673,7 @@ class CaptchaKrakenSolver {
                 // Tiles are reloading — wait (while hovering) for at least one to settle
                 // before re-solving, so we don't feed the model a mid-fade grid.
                 console.log(`[recaptcha-grid] round ${round}: tiles loading ${JSON.stringify(loading)}; waiting.`);
-                await this.waitForAnyClickedTileLoaded(page, captchaElement, session, loading);
+                await this.ph('fade-wait', () => this.waitForAnyClickedTileLoaded(page, captchaElement, session, loading));
                 continue;
             }
             // Unexpected action type for a grid (drag/type) — re-solve.
@@ -2369,6 +2691,13 @@ class CaptchaKrakenSolver {
                 if (verifyButton) {
                     console.log('[recaptcha-grid] clicking Verify to submit.');
                     await this.moveAndClick(page, verifyButton);
+                    // The press IS an interaction, and saying so is load-bearing: the
+                    // caller polls for the vendor's verdict on a round that interacted
+                    // and sleeps postSolveDelayMs flat on one that did not — and throws
+                    // 'performed no interactions' if the widget outlives that sleep. A
+                    // `done` round clicks no tile, so without this line the one answer
+                    // shape that submits and nothing else reports having done nothing.
+                    performedAction = true;
                     await this.emitStep(captchaElement, 'submit', 'submitted (Verify)', 'recaptcha', 'challenge', attempt);
                     // Snapshot the submitted frame, exactly as the one-shot path does.
                     // Without it isChallengeFreshlyRendered reads the CLOSING board as a
@@ -2478,7 +2807,7 @@ class CaptchaKrakenSolver {
         // models.json, so the name and the prompt generation it selects come from
         // the same place the Python port reads them. See model-name.ts.
         const { cliRoot, py } = this.resolveCli();
-        const { model = (0, model_name_1.resolveLoraName)({ cliRoot }), apiKey = process.env.CAPTCHA_KRAKEN_API_KEY ?? process.env.VLLM_API_KEY, } = this.config;
+        const { model = this.loraName(cliRoot), apiKey = process.env.CAPTCHA_KRAKEN_API_KEY ?? process.env.VLLM_API_KEY, } = this.config;
         const args = [
             '-m', 'captchakraken.cli', 'solve-animated',
             '--frames-dir', framesDir,
@@ -2731,7 +3060,7 @@ class CaptchaKrakenSolver {
     async askModel(imagePath, puzzleSource = 'unknown', retryMode = null, textMode = false) {
         // resolveCli() FIRST — see getAnimatedSolution.
         const { cliRoot, py } = this.resolveCli();
-        const { model = (0, model_name_1.resolveLoraName)({ cliRoot }), apiKey = process.env.CAPTCHA_KRAKEN_API_KEY ?? process.env.VLLM_API_KEY, } = this.config;
+        const { model = this.loraName(cliRoot), apiKey = process.env.CAPTCHA_KRAKEN_API_KEY ?? process.env.VLLM_API_KEY, } = this.config;
         // An ARGV ARRAY for execFile, not a string for a shell.
         //
         // This was `cmdParts.join(' ')` handed to `exec`, so the bearer token sat in
@@ -2752,6 +3081,10 @@ class CaptchaKrakenSolver {
             // distorted-text prompt and skip grid detection. The picture alone cannot
             // decide this — see the textMode note in solveSingle.
             textMode,
+            // Undefined unless the caller pinned one, which is the normal case: a
+            // routed model picks its own expert from the prompt family the CLI is
+            // about to send.
+            expert: this.config.expert,
         });
         console.log(`Executing CaptchaKraken CLI: ${(0, cli_invocation_1.redactCommand)([py, ...args].join(' '), apiKey)}`);
         try {
@@ -3055,12 +3388,15 @@ class CaptchaKrakenSolver {
     /**
      * Run `fn` (typically the model query) while idly drifting the cursor over
      * the captcha, so the mouse behaves like a human weighing the options instead
-     * of freezing during inference. Uses the same generate_trajectory paths as real
-     * clicks; cancelled the instant `fn` resolves. Best-effort — any wander error
-     * is swallowed and never fails the solve. Disable via config.idleMouseWander.
+     * of freezing during inference. Uses the same humanizer as real clicks, so a
+     * mode with no cursor skips it entirely; cancelled the instant `fn` resolves.
+     * Best-effort — any wander error is swallowed and never fails the solve.
+     * Disable via config.idleMouseWander.
      */
     async withIdleWander(page, element, fn) {
-        if (this.config.idleMouseWander === false)
+        // Same rule as hoverCell: drifting a cursor that does not exist would emit
+        // mousemove at a touch-only widget.
+        if (this.config.idleMouseWander === false || !this.human.hovers)
             return fn();
         let box = null;
         try {
@@ -3073,10 +3409,22 @@ class CaptchaKrakenSolver {
             return fn();
         const b = box;
         let stop = false;
+        // The dwell is INTERRUPTIBLE, and that is not a detail. `fn` is the model
+        // call; the moment it returns there is a click to make, and the finally
+        // below waits for this loop to notice. With a plain `delay` it noticed only
+        // when the timer ran out, so every inference was followed by up to 540ms of
+        // waiting for a pause nobody was watching — paid once per round, and the
+        // Python port pays none of it because it does not wander at all. Same
+        // wake-able-sleep shape as watcher.ts.
+        const waker = { fn: null };
+        const nap = (ms) => new Promise((resolve) => {
+            const timer = setTimeout(() => { waker.fn = null; resolve(); }, ms);
+            waker.fn = () => { clearTimeout(timer); waker.fn = null; resolve(); };
+        });
         const pad = 0.18; // keep drift inside the tile area, off the extreme edges
         const wander = (async () => {
             // brief pause before the first drift — don't lurch the instant we ask
-            await delay(120 + Math.random() * 180);
+            await nap(120 + Math.random() * 180);
             while (!stop) {
                 const tx = b.x + b.width * (pad + Math.random() * (1 - 2 * pad));
                 const ty = b.y + b.height * (pad + Math.random() * (1 - 2 * pad));
@@ -3088,7 +3436,7 @@ class CaptchaKrakenSolver {
                 }
                 if (stop)
                     break;
-                await delay(180 + Math.random() * 360); // human dwell between glances
+                await nap(180 + Math.random() * 360); // human dwell between glances
             }
         })();
         try {
@@ -3096,6 +3444,7 @@ class CaptchaKrakenSolver {
         }
         finally {
             stop = true;
+            waker.fn?.();
             await wander.catch(() => { });
         }
     }
@@ -3111,7 +3460,21 @@ class CaptchaKrakenSolver {
         if (!elem) {
             throw new Error(`Element not found: ${selectorOrElement}`);
         }
-        await elem.scrollIntoViewIfNeeded();
+        // BOUNDED. Playwright's default is 30s and it waits for the element to be
+        // STABLE — not animating — before it will scroll. This runs once per action
+        // and once per submit, so on a challenge that is mid-animation it burned
+        // the full default every time: measured 10.1s of a 12.0s mtcaptcha_text
+        // solve, spent scrolling to a text box that was already on screen. The
+        // element is on screen in every real case here (we just screenshotted it),
+        // so a short bound loses nothing: on timeout we move to wherever it is.
+        // page_solver.py has had this since it turned a ~5s solve loop into minutes
+        // in live testing; this port never got it.
+        try {
+            await elem.scrollIntoViewIfNeeded({ timeout: 2000 });
+        }
+        catch {
+            /* an unscrolled element is still where boundingBox says it is */
+        }
         const box = await elem.boundingBox();
         if (!box) {
             throw new Error(`Element has no bounding box: ${selectorOrElement}`);
@@ -3127,64 +3490,15 @@ class CaptchaKrakenSolver {
     }
     async moveAndClick(page, element) {
         await this.move(page, element);
-        await page.mouse.down();
-        await delay(Math.random() * 20 + 20);
-        await page.mouse.up();
+        await this.ph('mouse', () => this.human.click(page, this.human.at));
     }
+    /**
+     * Travel to a point. What that MEANS is the humanizer's business — on a
+     * touchscreen with no finger down it is a bookkeeping update and emits
+     * nothing at all.
+     */
     async performSmoothMove(page, x, y) {
-        // 60Hz sampling; see src/trajectory.ts
-        const [points, timings] = (0, trajectory_js_1.generate_trajectory)([this.lastMousePosition.x, this.lastMousePosition.y], [x, y], 60 // 60 points per second
-        );
-        const SPEED_MULTIPLIER = 1;
-        const vectors = [];
-        for (let i = 0; i < points.length; i++) {
-            vectors.push({
-                x: points[i][0],
-                y: points[i][1],
-                timestamp: timings[i] / SPEED_MULTIPLIER // timings are cumulative from start
-            });
-        }
-        await this.tracePath(page, vectors);
-    }
-    async tracePath(page, vectors) {
-        // Get viewport for clamping
-        let viewport = { width: 1920, height: 1080 };
-        try {
-            const vp = page.viewportSize();
-            if (vp)
-                viewport = vp;
-        }
-        catch (e) { }
-        const startTime = Date.now();
-        for (let i = 0; i < vectors.length; i++) {
-            const v = vectors[i];
-            try {
-                // Clamp coordinates to viewport
-                const clampedX = Math.max(0, Math.min(v.x, viewport.width));
-                const clampedY = Math.max(0, Math.min(v.y, viewport.height));
-                // Move mouse
-                await page.mouse.move(clampedX, clampedY);
-                // Update last position
-                this.lastMousePosition = { x: clampedX, y: clampedY };
-                // Calculate delay to match target timestamp
-                if (v.timestamp !== undefined) {
-                    const targetTime = startTime + v.timestamp;
-                    const now = Date.now();
-                    const delayMs = targetTime - now;
-                    if (delayMs > 0) {
-                        await delay(delayMs);
-                    }
-                }
-            }
-            catch (error) {
-                // Check if page closed or other fatal errors if needed, otherwise ignore
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (errorMessage.includes('Target closed') || errorMessage.includes('Session closed')) {
-                    log('Warning: could not move mouse, page or session closed.');
-                    return;
-                }
-            }
-        }
+        await this.ph('mouse', () => this.human.move(page, [x, y]));
     }
     async executeClick(page, element, action, elementBox) {
         let relativeX;
@@ -3217,14 +3531,7 @@ class CaptchaKrakenSolver {
             console.warn('Click action received without coordinates or bounding box', action);
             return;
         }
-        const absoluteX = elementBox.x + relativeX;
-        const absoluteY = elementBox.y + relativeY;
-        // Use the shared smooth move method
-        await this.performSmoothMove(page, absoluteX, absoluteY);
-        // Perform click
-        await page.mouse.down();
-        await page.waitForTimeout(Math.random() * 30 + 20); // Random hold duration
-        await page.mouse.up();
+        await this.ph('mouse', () => this.human.click(page, [elementBox.x + relativeX, elementBox.y + relativeY]));
     }
     async executeDrag(page, _element, action, elementBox) {
         const bboxCenter = (bbox) => {
@@ -3234,12 +3541,7 @@ class CaptchaKrakenSolver {
         };
         const src = bboxCenter(action.source_bounding_box);
         const dst = bboxCenter(action.target_bounding_box);
-        await this.performSmoothMove(page, src.x, src.y);
-        await page.mouse.down();
-        await page.waitForTimeout(Math.random() * 50 + 50);
-        await this.performSmoothMove(page, dst.x, dst.y);
-        await page.waitForTimeout(Math.random() * 50 + 50);
-        await page.mouse.up();
+        await this.ph('mouse', () => this.human.drag(page, [src.x, src.y], [dst.x, dst.y]));
     }
     // ────────────────────────────────────────────────────────── typing + sliding
     // Mirrors _find_control / _execute_type / _execute_slide in page_solver.py.
@@ -3265,36 +3567,70 @@ class CaptchaKrakenSolver {
         }
         return null;
     }
+    /**
+     * Where a distorted-text captcha's answer goes.
+     *
+     * Inside the widget first. If the widget holds no text box at all, widen ONCE
+     * to its enclosing <fieldset>/<form> and look again for a VENDOR-NAMED box
+     * only.
+     *
+     * BotDetect is why, and nothing else needs it. BotDetect is a self-hosted
+     * LIBRARY, so the host application owns the layout: measured on captcha.com
+     * 2026-08-24, `.BDC_CaptchaDiv` — the element detectCaptcha returns — is
+     * 280x50 and holds the image alone, while `#captchaCode` sits in a sibling
+     * `<div class="validationDiv">` under the enclosing <fieldset>. Scoped to the
+     * widget the solver found no box, textMode stayed false, and it read the code
+     * correctly and never typed it. A clean solve thrown away, and
+     * indistinguishable in any report from a model that cannot read warped text.
+     *
+     * The widened pass is restricted to TEXT_INPUT_VENDOR_SELECTORS on purpose.
+     * The generic tail is what makes the in-widget lookup work for every other
+     * vendor, and OUTSIDE the widget it is exactly how a captcha's answer ends up
+     * in a login form's username box. One level, named selectors, never the page.
+     *
+     * Mirrors `_answer_box` in page_solver.py — CLAUDE.md 1c.
+     */
+    async answerBox(scope, element) {
+        const inside = await this.findControl(scope, TEXT_INPUT_SELECTORS);
+        if (inside !== null || !element)
+            return inside;
+        // Nearest first: a <fieldset> inside a <form> is the tighter box, and a
+        // union query hands back whichever comes first in document order — the
+        // outer one.
+        for (const axis of ['ancestor::fieldset[1]', 'ancestor::form[1]']) {
+            let host = null;
+            try {
+                host = await element.$(`xpath=${axis}`);
+            }
+            catch {
+                continue;
+            }
+            if (!host)
+                continue;
+            const found = await this.findControl(host, TEXT_INPUT_VENDOR_SELECTORS);
+            if (found) {
+                console.log('Widget holds no answer box; using the vendor-named one in '
+                    + 'its enclosing form.');
+                return found;
+            }
+        }
+        return null;
+    }
     /** Put the model's reading of a distorted-text captcha into its box. */
-    async executeType(page, scope, action) {
+    async executeType(page, scope, action, element) {
         const text = action.text ?? '';
         if (!text)
             return false;
-        const field = await this.findControl(scope, TEXT_INPUT_SELECTORS);
+        const field = await this.answerBox(scope, element);
         if (!field) {
             console.warn('Type action, but no text box in the widget; skipping.');
             return false;
         }
-        await this.moveAndClick(page, field); // travel there, then press to focus
-        // A retry round arrives with the previous attempt still in the box, and
-        // typing would APPEND to it — submitting a string the model never read.
-        try {
-            await page.keyboard.press('Control+A');
-        }
-        catch { /* an adapter without a keyboard shortcut path */ }
-        // Per character rather than one type(text, {delay}) call: a constant
-        // inter-key delay is itself a signal, and these are the vendors that score
-        // typing cadence.
-        for (const ch of text) {
-            try {
-                await page.keyboard.type(ch);
-            }
-            catch (e) {
-                console.warn('Could not type into the captcha field:', e);
-                return false;
-            }
-            await page.waitForTimeout(Math.random() * 90 + 45);
-        }
+        // Tapping the box is what focuses it — and on a phone it is also what
+        // raises the keyboard, so this is not decoration on either device.
+        await this.moveAndClick(page, field);
+        if (!(await this.human.typeText(page, field, text)))
+            return false;
         console.log(`Typed ${text.length} character(s) into the captcha field.`);
         return true;
     }
@@ -3334,6 +3670,17 @@ class CaptchaKrakenSolver {
      * Returns false if there is nothing here to drag, leaving the caller's normal
      * no-op handling to deal with it.
      */
+    /**
+     * Device pixels per CSS pixel, read off the shot we are about to measure.
+     * 1 when the image cannot be read — an unreadable shot is already the
+     * trackPiece-returns-null path, and guessing a ratio would steer by it.
+     */
+    shotScale(shot, cssWidth) {
+        const dims = this.readPngDimensions(shot);
+        if (!dims || cssWidth <= 0)
+            return 1;
+        return dims.width / cssWidth;
+    }
     async executeSlide(page, element, scope, action, elementBox) {
         const targetX = ((action.target_bounding_box[0] + action.target_bounding_box[2]) / 2)
             * elementBox.width;
@@ -3356,12 +3703,7 @@ class CaptchaKrakenSolver {
             const targetY = ((action.target_bounding_box[1] + action.target_bounding_box[3]) / 2)
                 * elementBox.height;
             console.log('No slider track; dragging the piece to the slot directly.');
-            await this.performSmoothMove(page, box.x + box.width / 2, box.y + box.height / 2);
-            await page.mouse.down();
-            await page.waitForTimeout(Math.random() * 50 + 50);
-            await this.performSmoothMove(page, elementBox.x + targetX, elementBox.y + targetY);
-            await page.waitForTimeout(Math.random() * 50 + 50);
-            await page.mouse.up();
+            await this.human.drag(page, [box.x + box.width / 2, box.y + box.height / 2], [elementBox.x + targetX, elementBox.y + targetY]);
             return true;
         }
         const hbox = await handle.boundingBox();
@@ -3374,7 +3716,7 @@ class CaptchaKrakenSolver {
         // track behind it as it goes. Either would otherwise be the largest moving
         // thing in frame, and we would track the handle instead of the piece.
         const pad = Math.max(4, hbox.height * 0.35);
-        const exclude = [
+        const band = [
             0,
             hbox.y - elementBox.y - pad,
             elementBox.width,
@@ -3383,22 +3725,33 @@ class CaptchaKrakenSolver {
         const shots = Array.from({ length: 4 }, (_, i) => path.join(os.tmpdir(), `slide_${Date.now()}_${i}_${Math.floor(Math.random() * 1e9)}.png`));
         try {
             await this.move(page, handle, { paddingPercentage: 30 });
-            await page.mouse.down();
-            await page.waitForTimeout(Math.random() * 60 + 60);
+            await this.human.press(page);
+            await this.human.pause('grab');
             await element.screenshot({
                 path: shots[0],
                 timeout: this.config.elementScreenshotTimeoutMs ?? 8000,
                 animations: 'disabled',
             });
+            // CSS pixels out here, DEVICE pixels inside the shots. The same number on
+            // a 1x desktop and 2.625x apart on a phone, which is why this loop
+            // measured a slider correctly for a year and then missed every attempt
+            // the moment Tier 3 grew a mobile arm: the mask landed above the handle,
+            // the widths came back 2.6x too wide, and solveSlideGeometry threw them
+            // out as wider than the widget. Measured from the shot rather than asked
+            // of the page, for the same reason the grid path does it (`scaleX` in
+            // driveRecaptchaGrid): what the CV reads is the image, whatever the
+            // window thinks its ratio is.
+            const scale = this.shotScale(shots[0], elementBox.width);
+            const exclude = band.map((v) => v * scale);
             const widths = [];
             let lastBox = null;
             for (let i = 0; i < SLIDE_PROBE_OFFSETS_PX.length; i++) {
                 const offset = SLIDE_PROBE_OFFSETS_PX[i];
                 await this.performSmoothMove(page, startX + offset, holdY);
-                await page.waitForTimeout(Math.random() * 40 + 40);
+                await this.human.pause('probe');
                 const box = await this.trackPiece(element, shots[0], shots[i + 1], exclude);
                 if (box) {
-                    widths.push([offset, box[2] - box[0]]);
+                    widths.push([offset, (box[2] - box[0]) / scale]);
                     lastBox = box;
                 }
             }
@@ -3419,13 +3772,13 @@ class CaptchaKrakenSolver {
                 // neither the model nor the screen asked for.
                 let offset = widths[widths.length - 1][0];
                 for (let i = 0; i < SLIDE_MAX_CORRECTIONS; i++) {
-                    const pieceCentre = lastBox[2] - pieceWidth / 2;
+                    const pieceCentre = lastBox[2] / scale - pieceWidth / 2;
                     const error = targetX - pieceCentre;
                     if (Math.abs(error) <= SLIDE_TOLERANCE_PX)
                         break;
                     offset += error / ratio;
                     await this.performSmoothMove(page, startX + offset, holdY);
-                    await page.waitForTimeout(Math.random() * 40 + 40);
+                    await this.human.pause('probe');
                     const box = await this.trackPiece(element, shots[0], shots[3], exclude);
                     if (!box)
                         break; // ran out of track; release where we are
@@ -3435,11 +3788,11 @@ class CaptchaKrakenSolver {
             // Settle before letting go. A release in the same tick as the last move
             // reads as a machine, and some vendors sample the final milliseconds of
             // the gesture.
-            await page.waitForTimeout(Math.random() * 120 + 90);
+            await this.human.pause('settle');
         }
         finally {
             try {
-                await page.mouse.up();
+                await this.human.release(page);
             }
             catch { /* the page may have navigated */ }
             for (const shot of shots) {