captchakraken 3.1.0 → 3.2.1

package/dist/solver.js

@@ -33,9 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CaptchaKrakenSolver = exports.SOLVE_DEFAULTS = void 0;
+exports.CaptchaKrakenSolver = exports.SOLVE_DEFAULTS = exports.INPUT_SETTLE_MS = void 0;
 exports.answerNeedsElementBox = answerNeedsElementBox;
 exports.isStaleHandleError = isStaleHandleError;
+exports.isClosedTargetError = isClosedTargetError;
 exports.burstHangDeadlineMs = burstHangDeadlineMs;
 const watcher_1 = require("./watcher");
 const humanize_js_1 = require("./humanize.js");
@@ -46,7 +47,9 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const crypto_1 = require("crypto");
 const timing_1 = require("./timing");
+const png_1 = require("./png");
 const kinds_1 = require("./kinds");
+const verdicts_1 = require("./verdicts");
 const token_usage_1 = require("./token-usage");
 const errors_1 = require("./errors");
 const limits_1 = require("./limits");
@@ -130,6 +133,12 @@ const visible = async (scope, selectors) => (await Promise.all(selectors.map((s)
 const handleOf = (at) => at.elementHandle({ timeout: HANDLE_TIMEOUT_MS }).catch(() => null);
 const handles = async (ats) => (await Promise.all(ats.map(handleOf))).filter((h) => h !== null);
 const frameOf = async (at) => (await (await handleOf(at))?.contentFrame().catch(() => null)) ?? null;
+/**
+ * Where the host-page selectors are read: the page, then the inside of every VISIBLE vendor enclave. A hidden enclave is
+ * skipped because Playwright judges an element visible within its own document, whatever its frame's visibility.
+ */
+const hostScopes = async (page) => [page, ...(await Promise.all((await visible(page, selectors_1.ENCLAVE_SELECTORS)).map(frameOf))).filter((f) => f !== null)];
+const visibleIn = async (scopes, selectors) => (await Promise.all(scopes.map((scope) => visible(scope, selectors)))).flat();
 const hasText = async (el) => !!((await el.textContent().catch(() => null)) ?? '').trim();
 const SLIDE_TOLERANCE_PX = 2;
 const SLIDE_MAX_CORRECTIONS = 3;
@@ -139,8 +148,14 @@ function answerNeedsElementBox(actions) {
 }
 /** The widget moved on under us (hCaptcha swapped rounds, GeeTest closed on accept): re-detect, do not fail. */
 function isStaleHandleError(message) {
-    return /Timeout .*exceeded|not visible|not attached|detached|Target closed|bounding box of captcha element/i.test(message);
+    return /Timeout .*exceeded|not visible|not attached|detached|bounding box of captcha element/i.test(message);
 }
+/** A closed target is not a stale handle: retried as one, a dead page was re-detected until the loops ran out. */
+function isClosedTargetError(message) {
+    return /Target (?:page, context or browser )?(?:has been )?closed|Session closed/i.test(message);
+}
+/** How often a page that has not drawn its widget yet is looked at again. */
+const DETECTION_POLL_MS = 250;
 // Frame-diff thresholds; two screens of one board differ by ~0.0056, a different board by ~0.77.
 const NOT_THIS_BOARD_DIFF = 0.5;
 // Tighter than staleFrameDiffThreshold (0.02), which was blind to GeeTest svg; 0.001 is the noise floor.
@@ -148,9 +163,48 @@ const MOVED_DURING_INFERENCE_DIFF = 0.002;
 // hCaptcha odd-animal showed 38 screens in 4s with no repeat; past DEFAULT_MAX_KEYFRAMES a keyframe answer cannot describe the motion.
 const BURST_ANIMATED_SCREENS = 6;
 const NOT_THIS_BOARD_POLLS = 3;
+// How long a control we hovered, pressed or typed into takes to stop repainting in reaction. A board read inside
+// this window is wearing our own feedback, which is not a screen it ever showed by itself.
+exports.INPUT_SETTLE_MS = 400;
+/** `viewportSize()` is null on a context launched without one (camoufox), where only the window knows. */
+async function viewportOf(page) {
+    const view = page.viewportSize() ?? await page.evaluate?.(() => ({ width: window.innerWidth, height: window.innerHeight }));
+    if (!view)
+        throw new Error('the page reports no viewport size and cannot evaluate one');
+    return view;
+}
+/**
+ * Does a viewport capture speak the bounding box's coordinates? Not on a page laid out wider than the device and
+ * zoomed out to fit, which is every mobile layout of a desktop page: there the box is in layout pixels and the
+ * capture is not.
+ */
+async function layoutIsTheViewport(page, view) {
+    const frame = await page.evaluate?.(() => ({
+        width: window.innerWidth,
+        scale: window.visualViewport ? window.visualViewport.scale : 1,
+    }));
+    if (!frame)
+        throw new Error('the page cannot evaluate its own layout width');
+    return Math.abs((frame.scale ?? 1) - 1) < 1e-3 && Math.abs(frame.width - view.width) <= 1;
+}
+const within = (r, view) => r.x >= 0 && r.y >= 0 && r.x + r.width <= view.width && r.y + r.height <= view.height;
+/** A point just outside the board, past the edge nearest the pointer, that is still inside the viewport. */
+function offBoardPoint(box, at, view) {
+    const [x, y] = at;
+    const gap = 24 + Math.random() * 40;
+    const right = box.x + box.width;
+    const bottom = box.y + box.height;
+    const exits = [
+        [x - box.x, [box.x - gap, y]], [right - x, [right + gap, y]], [y - box.y, [x, box.y - gap]], [bottom - y, [x, bottom + gap]],
+    ];
+    return exits.sort((a, b) => a[0] - b[0]).map(([, p]) => p)
+        .find(([px, py]) => px >= 0 && px < view.width && py >= 0 && py < view.height) ?? null;
+}
 exports.SOLVE_DEFAULTS = {
     maxSolveLoops: 6,
     overallSolveTimeoutMs: 45000,
+    // A page just navigated has often not drawn its widget; solving straight after `domcontentloaded` failed 3/3 on a demo page.
+    detectionTimeoutMs: 15000,
     // 9s holds a 3-screen GeeTest svg cycle at 2.7s a screen; 6s gave up one screen short. videoBudgetMs derives from it on both ports.
     keyframeWaitTimeoutMs: 9000,
 };
@@ -158,10 +212,23 @@ exports.SOLVE_DEFAULTS = {
 function burstHangDeadlineMs(cfg) {
     return 3 * (cfg.videoBurstMaxMs ?? 12000) + 5000;
 }
+/** The page's host alone: a path or query can carry a user's own data. */
+function hostname(page) {
+    try {
+        return new URL(page.url?.() ?? '').hostname.toLowerCase() || null;
+    }
+    catch {
+        return null;
+    }
+}
 class CaptchaKrakenSolver {
     ph(name, fn) {
         return this.budget ? this.budget.phase(name, fn) : fn();
     }
+    /** A pointer gesture, timed as MOUSE and remembered: see `INPUT_SETTLE_MS`. */
+    gesture(fn) {
+        return this.ph(kinds_1.Phase.MOUSE, fn).finally(() => { this.lastInputAt = Date.now(); });
+    }
     constructor(config = {}) {
         this.videoBudgetMs = 0;
         this.videoBudgetGranted = false;
@@ -175,7 +242,6 @@ class CaptchaKrakenSolver {
         /** Answers keyed by screenshot hash; a hit means the answer already ran and changed nothing. */
         this.solutionCache = new Map();
         this.repeatedAnswerSeen = false;
-        this.retriedUnusableAnswer = false;
         this.knownAnimated = false;
         this.animatedProbeDone = false;
         /** The one recording for the animated board on screen, and its answer until the widget refuses it. */
@@ -200,9 +266,22 @@ class CaptchaKrakenSolver {
         this.actedOnBoard = false;
         this.lastSubmitFrameHash = null;
         this.solveSessionId = null;
+        /** Which vendor and site this solve is for, sent to the hosted API; the site is a hostname only. */
+        this.solveVendor = null;
+        this.solveSite = null;
+        /** The host the widget itself was served from (its iframe's); null for an inline widget. */
+        this.solveWidgetHost = null;
+        this.legacyModelWarned = false;
+        this.verdicts = null;
+        /** False once a self-hosted endpoint has answered 404: it has no outcome route to report to. */
+        this.outcomeSupported = true;
         this.cliCache = null;
         this.loraNameCache = null;
         this.budget = null;
+        /** The page being solved: every capture is taken of its viewport. Set by `solve`. */
+        this.page = null;
+        /** When our last gesture ended; the board's reaction to it is never read as the board's own motion. */
+        this.lastInputAt = -Infinity;
         this.config = config;
         this.human = (0, humanize_js_1.resolveHumanizer)({ ...config, startingMousePosition: config.startingMousePosition ?? { x: 100, y: 100 } });
     }
@@ -212,14 +291,73 @@ class CaptchaKrakenSolver {
     set lastMousePosition(v) {
         this.human.at = [v.x, v.y];
     }
-    /** `disabled` freezes CSS animation, which once sliced GeeTest svg to a static clip; callers filming motion pass `allow`. */
-    shot(el, p, timeout = 2500, animations = 'disabled') {
-        return el.screenshot({ path: p, timeout, animations });
+    /**
+     * Every capture the driver takes: the whole viewport, cropped here to the element.
+     *
+     * Never a clipped capture. An element screenshot, or any `clip`, makes a headed Chromium repaint the page at the
+     * clip's size for that frame, which the user watches as the page flashing and jumping; a viewport capture
+     * repaints nothing, and measured twice as fast. `disabled` freezes CSS animation, which once sliced GeeTest svg to
+     * a static clip; callers filming motion pass `allow`.
+     */
+    async shot(el, p, timeout = 2500, animations = 'disabled') {
+        const page = this.page;
+        const view = await viewportOf(page);
+        const rect = (await layoutIsTheViewport(page, view)) ? await this.rectInView(el, view) : null;
+        if (!rect) {
+            // Bigger than the viewport, or a zoomed-out mobile layout: no viewport capture holds it in its own
+            // coordinates, so the element photographs itself.
+            await el.screenshot({ path: p, timeout, animations });
+            return;
+        }
+        fs.writeFileSync(p, (0, png_1.cropPng)(await page.screenshot({ timeout, animations }), rect, view.width));
+    }
+    async rectOf(el) {
+        const box = await el.boundingBox();
+        const rect = box ? (0, png_1.enclosingRect)(box) : null;
+        if (!rect || rect.width <= 0 || rect.height <= 0)
+            throw new Error('the element is not visible: it has no bounding box to photograph');
+        return rect;
+    }
+    /** Where the element sits in the viewport, scrolled in when it is merely off screen; null when it cannot fit. */
+    async rectInView(el, view) {
+        let rect = await this.rectOf(el);
+        if (rect.width > view.width || rect.height > view.height)
+            return null;
+        if (!within(rect, view)) {
+            await el.scrollIntoViewIfNeeded({ timeout: 2000 });
+            rect = await this.rectOf(el);
+        }
+        return within(rect, view) ? rect : null;
+    }
+    /**
+     * Take the pointer off the board and let our own feedback fade before the board is judged still or animated.
+     *
+     * A hovered or pressed control repaints, and a board wearing our highlight read as motion: a still board was
+     * filmed as animated because of the Verify button under the cursor.
+     */
+    async stepOffTheBoard(page, el) {
+        // Only a board we pointed at wears our feedback. One the vendor dealt under a resting pointer has nothing of
+        // ours to fade, and stepping off it cost every round its own gesture and settle window.
+        if (!this.actedOnBoard)
+            return;
+        const box = await el.boundingBox();
+        const [x, y] = this.human.at;
+        if (box && this.human.hovers && x >= box.x && x <= box.x + box.width && y >= box.y && y <= box.y + box.height) {
+            const spot = offBoardPoint(box, [x, y], await viewportOf(page));
+            if (spot)
+                await this.performSmoothMove(page, ...spot);
+        }
+        await delay(this.lastInputAt + exports.INPUT_SETTLE_MS - Date.now());
     }
     async solve(page) {
         // One session id per solve groups its inference rounds into one billable attempt.
         this.solveSessionId = (0, crypto_1.randomUUID)();
+        this.page = page;
+        this.solveVendor = null;
+        this.solveSite = hostname(page);
+        this.solveWidgetHost = null;
         this.budget = new timing_1.PhaseBudget();
+        this.verdicts = null;
         let solvedForReport = false;
         try {
             const result = await this.solveImpl(page);
@@ -235,47 +373,82 @@ class CaptchaKrakenSolver {
             await this.stopAnimatedFilm();
             this.teardownCvWorker();
             this.cvWorkerReady = null;
-            this.reportOutcome(this.solveSessionId, solvedForReport);
+            // Set by solveImpl, which the narrowing from the reset above cannot see.
+            const verdicts = this.verdicts;
+            await verdicts?.close();
+            // The vendor's own verdict when it was readable; the DOM's done-signal only when it was not.
+            const said = verdicts?.decisive() ?? null;
+            void this.reportOutcome(this.solveSessionId, said === null ? solvedForReport : said === kinds_1.Verdict.ACCEPTED);
             this.solveSessionId = null;
         }
     }
-    /** Tell the hosted API whether the widget accepted, through the CLI, detached, never awaited. */
+    /** Tell the hosted API whether the widget accepted, through the CLI. The solve never awaits it; the promise is for callers that must know it finished. */
     reportOutcome(sessionId, solved) {
         // The opt-out is honoured here too: otherwise every solve spawns a process just to be told 404 by a local vLLM.
-        if (!sessionId || 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 ? kinds_1.Outcome.SOLVED : kinds_1.Outcome.FAILED], { cwd: cliRoot, env: cliEnv(cliRoot), detached: true, stdio: 'ignore' });
-            child.on('error', () => { });
-            child.unref();
-        }
-        catch { /* a missing engine is loud everywhere else */ }
+        if (!sessionId || !this.outcomeSupported || process.env.CAPTCHA_REPORT_OUTCOME === '0')
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            try {
+                const { cliRoot, py } = this.resolveCli();
+                const child = (0, child_process_1.spawn)(py, ['-m', 'captchakraken.cli', 'report-outcome', sessionId, solved ? kinds_1.Outcome.SOLVED : kinds_1.Outcome.FAILED], { cwd: cliRoot, env: cliEnv(cliRoot, this.routingEnv()), stdio: ['ignore', 'pipe', 'pipe'] });
+                let stdout = '';
+                child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+                // The engine words its own warnings; a hosted refusal must be as visible here as it is from Python.
+                child.stderr.on('data', (chunk) => process.stderr.write(chunk));
+                child.on('error', () => resolve());
+                child.on('close', () => {
+                    try {
+                        if (JSON.parse(stdout.trim()).supported === false)
+                            this.outcomeSupported = false;
+                    }
+                    catch { /* nothing parseable to learn from */ }
+                    resolve();
+                });
+                // Never holds the process open: the solve's result is already decided.
+                child.unref();
+                [child.stdout, child.stderr].forEach((stream) => stream.unref?.());
+            }
+            catch {
+                resolve(); // a missing engine is loud everywhere else
+            }
+        });
     }
     /** Solve captchas on `page` as they appear, until `stop()`. Injects nothing into the page. */
     watch(page, options = {}) {
         return (0, watcher_1.watchPage)(this, page, options);
     }
+    /**
+     * Give up only when the vendor refuses to serve us, or when every one of `maxSolveLoops` has been spent. Any other
+     * failed round — a stale handle, an unusable or repeated answer, a board that would not film — counts one loop,
+     * pauses, and goes again.
+     */
     async solveImpl(page) {
         const cfg = this.config;
         const maxSolveLoops = cfg.maxSolveLoops ?? exports.SOLVE_DEFAULTS.maxSolveLoops;
         const overallSolveTimeoutMs = cfg.overallSolveTimeoutMs ?? exports.SOLVE_DEFAULTS.overallSolveTimeoutMs;
-        const start = Date.now();
+        const detectionTimeoutMs = cfg.detectionTimeoutMs ?? exports.SOLVE_DEFAULTS.detectionTimeoutMs;
+        let start = Date.now();
         const cumulativeTokenUsage = [];
         this.stepIndex = 0;
         this.solveStartMs = start;
         await this.human.reset(page);
         await this.stopAnimatedFilm();
         this.resetSolveState();
-        const done = () => ({ isSolved: true, finalMousePosition: this.lastMousePosition, tokenUsage: (0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage) });
+        const verdicts = this.verdicts = new verdicts_1.VerdictLog(page);
+        const done = () => ({ isSolved: true, finalMousePosition: this.lastMousePosition,
+            tokenUsage: (0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage), verdicts: [...verdicts.verdicts] });
+        const blocked = (how) => new Error(`The vendor refused to serve this client (${how}); no further round can succeed.`);
+        let lastFailure = null;
+        // Count the loop. Only a widget caught mid-transition is worth waiting out; a refused or repeated answer changed
+        // nothing on the page, and pausing after it only spends the solve's budget.
+        const again = async (message, { unsupported = false, inTransition = false } = {}) => {
+            lastFailure = { message, unsupported };
+            console.log(`${message}; counting this loop and going again.`);
+            if (inTransition)
+                await delay(cfg.staleElementBackoffMs ?? 900);
+        };
         let pendingRetryMode = null;
-        let alreadyRetriedRecaptchaError = false;
-        let unsupportedRetries = 0;
-        let staleElementRetries = 0;
         let hasInteracted = false;
-        let renderWaits = 0;
-        // Strictly fewer than the loops, else the reCAPTCHA v3 "no interactive widget" branch never gets a turn.
-        const MAX_RENDER_WAITS = Math.min(6, maxSolveLoops - 1);
         for (let attempt = 1; attempt <= maxSolveLoops; attempt++) {
             const budgetMs = overallSolveTimeoutMs + this.videoBudgetMs;
             this.solveDeadlineAt = start + budgetMs;
@@ -283,23 +456,38 @@ class CaptchaKrakenSolver {
                 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` : '') + '.');
             }
+            const said = await this.vendorVerdict();
+            if (said === kinds_1.Verdict.ACCEPTED) {
+                console.log('[verdict] the vendor accepted the answer; finishing.');
+                return done();
+            }
+            if (said === kinds_1.Verdict.BLOCKED)
+                throw blocked('its server answered 429');
             if (hasInteracted && await this.isCaptchaSolved(page)) {
                 console.log('Vendor reports solved; returning without another detect pass.');
                 return done();
             }
-            const widget = await this.ph(kinds_1.Phase.DETECT, () => this.detectCaptcha(page));
+            let widget = await this.ph(kinds_1.Phase.DETECT, () => this.detectCaptcha(page));
             if (!widget) {
-                if (hasInteracted) {
+                // A widget that vanished right after the vendor refused the answer was not solved.
+                if (hasInteracted && verdicts.decisive() !== kinds_1.Verdict.REJECTED) {
                     console.log('No supported captcha found (post-interaction); considering solved.');
                     return done();
                 }
-                if (await this.hasInteractiveWidgetInDom(page) && renderWaits < MAX_RENDER_WAITS) {
-                    renderWaits++;
-                    console.log(`Captcha widget present in DOM but not yet rendered; waiting (${renderWaits}/${MAX_RENDER_WAITS}).`);
-                    await delay(800 + Math.random() * 300);
-                    continue;
+                const waitedFrom = Date.now();
+                widget = await this.ph(kinds_1.Phase.DETECT, () => this.awaitWidget(page, detectionTimeoutMs));
+                // The budget is for solving; the page drawing its widget is not charged to it.
+                start += Date.now() - waitedFrom;
+                this.solveDeadlineAt = start + budgetMs;
+                if (!widget) {
+                    if (await this.isCaptchaSolved(page)) {
+                        console.log('Captcha already satisfied; nothing to solve.');
+                        return done();
+                    }
+                    if (hasInteracted)
+                        throw new Error(`The vendor rejected the last answer and its widget did not come back within ${detectionTimeoutMs}ms.`);
+                    throw new Error(await this.noWidgetMessage(page, detectionTimeoutMs));
                 }
-                throw new Error(await this.noWidgetMessage(page));
             }
             console.log(`\n--- Captcha Solve Loop ${attempt}/${maxSolveLoops} ---`);
             const retryModeThisLoop = pendingRetryMode;
@@ -310,68 +498,65 @@ class CaptchaKrakenSolver {
                 ({ didInteract, tokenUsage } = await this.solveSingle(page, widget, attempt, retryModeThisLoop));
             }
             catch (e) {
-                if (e?.nothingFilmed && hasInteracted) {
-                    // Every other failure in this loop asks `isCaptchaSolved` before giving up; this one did not,
-                    // and threw away boards the vendor had already taken. Measured on the python port, which fails
-                    // the same way: prosopo_grid_3x3 was 8/8 green across six runs on 09-12 and 09-13, then lost
-                    // four attempts on 09-17 to exactly this — each after its FIRST board came back from /fx/verify
-                    // graded `solved: true`, with the solve dying on the second board the vendor dealt.
-                    if (await this.isCaptchaSolved(page)) {
+                const emsg = String((e && e.message) || e);
+                if (e?.unsupported) {
+                    // The model had nothing usable for this board. The next round re-asks, often of a board the vendor has replaced.
+                    await again(`Cannot solve this kind of captcha — ${emsg}`, { unsupported: true });
+                    continue;
+                }
+                if (e?.animated) {
+                    if (cfg.videoSolveEnabled === false)
+                        throw new Error(`Animated challenge could not be solved: ${emsg}`);
+                    // A widget that will not screenshot is usually one that is closing, because the answer was accepted: measured, a
+                    // vendor that deals several boards lost four attempts to exactly this, each after its first board came back graded solved.
+                    if (hasInteracted && await this.isCaptchaSolved(page)) {
                         console.log('nothing left to film because the board was accepted; finishing.');
                         return done();
                     }
-                    // Not solved: the handle is stale for the same reason it is unscreenshottable, so take the
-                    // stale-handle recovery rather than ending a solve with loops still in it.
-                    if (staleElementRetries < (cfg.maxStaleElementRetries ?? 3)) {
-                        staleElementRetries++;
-                        console.log(`the widget would not screenshot; re-detecting next round (${staleElementRetries}/${cfg.maxStaleElementRetries ?? 3}).`);
-                        await delay(cfg.staleElementBackoffMs ?? 900);
-                        continue;
-                    }
+                    await again(emsg, { inTransition: true });
+                    continue;
                 }
-                if (e?.animated)
-                    throw new Error(`Animated challenge could not be solved: ${e.message ?? 'recording failed'}`);
-                if (e?.unsupported) {
-                    // Mid-solve, a transitional blank frame reads as unsupported; settle and retry.
-                    if (hasInteracted && unsupportedRetries < (cfg.maxUnsupportedReSolves ?? 3)) {
-                        unsupportedRetries++;
-                        const again = await this.detectCaptcha(page);
-                        if (again && await this.ph(kinds_1.Phase.SETTLE, () => this.waitForElementSettled(again.el)) === kinds_1.SettleVerdict.ANIMATED && cfg.videoSolveEnabled === false) {
-                            throw new Error('Animated/video challenge detected — the puzzle never settles and videoSolveEnabled is off.');
-                        }
-                        console.log(`"unsupported" mid-solve; settled and retrying (${unsupportedRetries}/${cfg.maxUnsupportedReSolves ?? 3}).`);
-                        continue;
-                    }
-                    throw new Error(`Cannot solve this kind of captcha — ${e?.message ?? e}`);
+                const closed = isClosedTargetError(emsg);
+                if (!closed && !isStaleHandleError(emsg))
+                    throw e;
+                // The handle most often went stale because the answer was accepted.
+                if (hasInteracted && await this.isCaptchaSolved(page).catch(() => false)) {
+                    console.log('Vendor reports solved; finishing.');
+                    return done();
                 }
-                const emsg = String((e && e.message) || e);
-                if (hasInteracted && staleElementRetries < (cfg.maxStaleElementRetries ?? 3) && isStaleHandleError(emsg)) {
-                    staleElementRetries++;
-                    console.log(`stale challenge handle after submit ("${emsg.split('\n')[0]}"); re-detecting next round (${staleElementRetries}/${cfg.maxStaleElementRetries ?? 3}).`);
-                    await delay(cfg.staleElementBackoffMs ?? 900);
-                    continue;
+                if (closed) {
+                    throw new Error('The page, context or browser closed mid-solve' + (hasInteracted
+                        ? ', after the answer had been submitted but before the vendor\'s verdict could be read — the solve may in fact have succeeded.'
+                        : '.'));
                 }
-                throw e;
+                await again(`the challenge handle went stale (${emsg.split('\n')[0]})`, { inTransition: true });
+                continue;
             }
             hasInteracted = hasInteracted || didInteract;
-            if (this.noProgressRounds >= (cfg.maxNoProgressRounds ?? 2)) {
-                throw new Error(`No progress: the model returned the same answer ${this.noProgressRounds + 1} times running and the challenge is still up (attempt ${attempt}/${maxSolveLoops}). Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`);
-            }
-            renderWaits = 0;
             cumulativeTokenUsage.push(...tokenUsage);
             // One polled wait per round, not a flat sleep: the sleep observed nothing and cost 1200-1500ms a round, and
-            // hCaptcha keeps its iframe visible ~2s while verifying, which read as a fresh puzzle and burned ~18s.
-            const settleMs = didInteract ? (cfg.postSolveOutcomeTimeoutMs ?? 1000) : (cfg.postSolveDelayMs ?? 1200) + Math.random() * 300;
+            // hCaptcha keeps its iframe visible ~2s while verifying, which read as a fresh puzzle and burned ~18s. A round that
+            // performed nothing gave the page nothing to react to, so it looks once and goes on: waiting there cost every
+            // refused or repeated answer the full window.
+            const settleMs = didInteract ? (cfg.postSolveOutcomeTimeoutMs ?? 1000) : 0;
             const deadline = Date.now() + settleMs;
             const verdictT0 = Date.now();
             let solved = false;
+            let roundSaid = null;
             let widgetGone = 0;
-            while (Date.now() < deadline) {
+            let looked = false;
+            while (!looked || Date.now() < deadline) {
+                looked = true;
+                roundSaid = (await this.vendorVerdict()) ?? roundSaid;
+                if (roundSaid === kinds_1.Verdict.ACCEPTED || roundSaid === kinds_1.Verdict.BLOCKED) {
+                    solved = roundSaid === kinds_1.Verdict.ACCEPTED;
+                    break;
+                }
                 if (await this.isCaptchaSolved(page)) {
                     solved = true;
                     break;
                 }
-                widgetGone = (await this.detectCaptcha(page)) ? 0 : widgetGone + 1;
+                widgetGone = roundSaid !== kinds_1.Verdict.REJECTED && !(await this.detectCaptcha(page)) ? widgetGone + 1 : 0;
                 if (widgetGone >= 2) {
                     solved = true;
                     break;
@@ -398,32 +583,84 @@ class CaptchaKrakenSolver {
                 console.log(`[verdict] success signal arrived after ${Date.now() - verdictT0}ms`);
                 return done();
             }
+            if (roundSaid === kinds_1.Verdict.BLOCKED)
+                throw blocked('its server answered 429');
+            if (await this.isBlocked(page))
+                throw blocked('it is showing its try-again-later screen');
+            if (roundSaid === kinds_1.Verdict.REJECTED)
+                console.log(`[verdict] the vendor rejected the answer after ${Date.now() - verdictT0}ms`);
             if (this.bannerIsFatalAfterRetry(await this.bannerKind(page))) {
-                if (alreadyRetriedRecaptchaError) {
-                    throw new Error(`reCAPTCHA still showing the under-selection error after retry; aborting (model unable to identify the missed tile). Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`);
-                }
-                console.log('reCAPTCHA returned under-selection error; retrying with missed-tiles prompt.');
+                console.log('reCAPTCHA under-selection error; the next round asks for the missed tiles.');
                 pendingRetryMode = kinds_1.RetryMode.MISSED_TILES;
-                alreadyRetriedRecaptchaError = true;
             }
-            if (!(await this.detectCaptcha(page)))
+            if (roundSaid !== kinds_1.Verdict.REJECTED && !(await this.detectCaptcha(page)))
                 return done();
-            if (!didInteract && !this.noProgressRounds) {
-                // AN ANSWER WITH NOTHING TO EXECUTE IS NOT PROOF THE PAGE IS STUCK. The throw below is for a
-                // driver that cannot act at all; an answer the driver could not use is a different thing, and
-                // on an animated board it is what a still expert returns when the board is not a still —
-                // measured on the hosted arms: a drag with no source box, "slide action, but the widget has
-                // neither a slider nor a draggable piece", solve over in 6s with the recording never taken.
-                if (cfg.videoSolveEnabled !== false && !this.retriedUnusableAnswer) {
-                    this.retriedUnusableAnswer = true;
+            if (this.noProgressRounds) {
+                const stuck = `No progress: the model returned the same answer ${this.noProgressRounds + 1} times running`;
+                // A board answered the same way after every resample is one the model cannot read: measured, no solve ever
+                // followed a third identical answer, and each further round cost the board 3-7s.
+                if (this.noProgressRounds >= (cfg.maxNoProgressRounds ?? 2))
+                    throw new Error(`${stuck}.`);
+                await again(stuck);
+            }
+            else if (!didInteract) {
+                // An answer with nothing to execute is not proof the page is stuck; on an animated board it is what a still
+                // expert returns when the board is not a still, so the next round takes a second look.
+                if (cfg.videoSolveEnabled !== false)
                     this.repeatedAnswerSeen = true; // what arms the second look
-                    console.log('[animated] the answer had nothing this widget could execute; taking a second look before giving up.');
-                    continue;
-                }
-                throw new Error(`Captcha still detected but solver performed no interactions; aborting to avoid an infinite loop. Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`);
+                await again('The solver performed no interactions this round');
             }
         }
-        throw new Error(`Captcha still detected after ${maxSolveLoops} solve loops. Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`);
+        const last = lastFailure;
+        const usage = ` Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`;
+        if (last?.unsupported)
+            throw new Error(`${last.message} (after ${maxSolveLoops} solve loops).${usage}`);
+        throw new Error(`Captcha still detected after ${maxSolveLoops} solve loops${last ? `; the last failed round: ${last.message}` : ''}.${usage}`);
+    }
+    /** What the vendor's server said since the last look: BLOCKED outranks everything, else the latest answer. */
+    async vendorVerdict() {
+        const fresh = (await this.verdicts?.fresh() ?? []).map((v) => v.verdict).filter((v) => v !== kinds_1.Verdict.NEW_CHALLENGE);
+        return fresh.includes(kinds_1.Verdict.BLOCKED) ? kinds_1.Verdict.BLOCKED : fresh[fresh.length - 1] ?? null;
+    }
+    /**
+     * A page that has not drawn its widget yet is looked at again until `detectionTimeoutMs`. Solving straight after
+     * `domcontentloaded` failed 3/3 on a demo page whose frames arrived a moment later.
+     */
+    async awaitWidget(page, timeoutMs) {
+        const started = Date.now();
+        let widget = null;
+        while (!widget && Date.now() - started < timeoutMs && !(await this.isCaptchaSolved(page))) {
+            await delay(DETECTION_POLL_MS);
+            widget = await this.detectCaptcha(page);
+        }
+        return widget;
+    }
+    /** The vendor showing its refusal screen: rate-limited or flagged, with no board to answer. */
+    async isBlocked(page) {
+        try {
+            const probes = selectors_1.WIDGET_PROBES.filter((p) => p.role === kinds_1.FrameRole.CHALLENGE && selectors_1.SELECTORS[p.vendor].blocked);
+            const scopes = await hostScopes(page);
+            const shown = await Promise.all(probes.map(async (p) => {
+                const [at] = await visibleIn(scopes, [p.selector]);
+                const frame = at && await frameOf(at);
+                return !!frame && (await Promise.all((selectors_1.SELECTORS[p.vendor].blocked ?? []).map((sel) => this.visibleWithText(frame, sel)))).some(Boolean);
+            }));
+            return shown.some(Boolean);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** The env the engine reads its routing headers from: session, and the vendor and site once they are known. */
+    routingEnv() {
+        return {
+            ...(this.solveSessionId ? { CAPTCHA_KRAKEN_SESSION: this.solveSessionId } : {}),
+            ...(this.solveVendor ? { CAPTCHA_KRAKEN_VENDOR: this.solveVendor } : {}),
+            ...(this.solveSite ? { CAPTCHA_KRAKEN_SITE: this.solveSite } : {}),
+            ...(this.solveWidgetHost ? { CAPTCHA_KRAKEN_WIDGET_HOST: this.solveWidgetHost } : {}),
+            // This driver warns about a legacy model name itself, once; the engine it starts per round stays quiet.
+            CAPTCHA_KRAKEN_MODEL_WARNING: '0',
+        };
     }
     /** Fire the optional onStep observer with a fresh screenshot; best-effort, never fails the solve. */
     async emitStep(captchaElement, stage, label, puzzleSource, frameRole, attempt, meta) {
@@ -449,8 +686,14 @@ class CaptchaKrakenSolver {
     async solveSingle(page, widget, attempt, retryMode = null) {
         const cfg = this.config;
         const { el: captchaElement, vendor: puzzleSource, role: frameRole } = widget;
+        this.solveVendor = puzzleSource;
         const frame = await captchaElement.contentFrame();
+        this.solveWidgetHost = frame ? hostname(frame) : null;
         const scope = frame ?? widget.at;
+        if (frameRole === kinds_1.FrameRole.CHECKBOX) {
+            await this.clickCheckbox(page, widget, frame);
+            return { didInteract: true, tokenUsage: [] };
+        }
         if (frame && frameRole === kinds_1.FrameRole.CHALLENGE && selectors_1.SELECTORS[puzzleSource].images) {
             if (this.lastSubmitFrameHash) {
                 await this.ph(kinds_1.Phase.AWAIT_NEXT_ROUND, () => this.waitForChangeSince(captchaElement, this.lastSubmitFrameHash));
@@ -471,8 +714,10 @@ class CaptchaKrakenSolver {
         const textMode = !VENDORS_WITH_BESPOKE_HANDLING.has(puzzleSource) && (await this.answerBox(scope, widget.at)) !== null;
         if (textMode)
             console.log('Widget has a text box; solving as a distorted-text captcha.');
-        // A checkbox is clicked, not filmed, and a reCAPTCHA board is read by its grid below.
-        const filmable = frameRole !== kinds_1.FrameRole.CHECKBOX && puzzleSource !== kinds_1.Vendor.RECAPTCHA && !textMode;
+        // A reCAPTCHA board is read by its grid below, not filmed.
+        const filmable = puzzleSource !== kinds_1.Vendor.RECAPTCHA && !textMode;
+        if (filmable && !this.knownAnimated)
+            await this.stepOffTheBoard(page, captchaElement);
         let isAnimated = false;
         if (filmable && cfg.videoSolveEnabled === false) {
             if (await this.ph(kinds_1.Phase.SETTLE, () => this.waitForElementSettled(captchaElement)) === kinds_1.SettleVerdict.ANIMATED) {
@@ -737,12 +982,83 @@ class CaptchaKrakenSolver {
         }
         return { didInteract: performedAction, tokenUsage: allTokenUsage };
     }
+    /**
+     * Tick the box and wait for what it opens. A checkbox is not a board: it is never polled, filmed or asked about.
+     *
+     * Treated as a board it cost 70 screenshots and three model calls in one measured solve, two of them answering the
+     * checkbox picture with a drag.
+     */
+    async clickCheckbox(page, widget, frame) {
+        const box = await this.checkboxBox(frame, widget.vendor);
+        if (box)
+            await this.move(page, box);
+        else
+            await this.performSmoothMove(page, ...await this.findCheckboxOnScreen(widget.el));
+        await this.human.pause(kinds_1.PauseKind.BETWEEN);
+        await this.gesture(() => this.human.click(page, this.human.at));
+        await this.awaitWhatTheCheckboxOpened(page);
+    }
+    /**
+     * The box in a checkbox frame once the frame has drawn it; null when the DOM cannot reach it. Turnstile's box is in
+     * a closed shadow root, and a frame can refuse access; both are found on screen instead.
+     */
+    async checkboxBox(frame, vendor) {
+        const box = selectors_1.SELECTORS[vendor].box;
+        if (!frame || !box?.length)
+            return null;
+        try {
+            return await frame.waitForSelector(box.join(', '), { state: 'visible', timeout: this.config.detectionTimeoutMs ?? exports.SOLVE_DEFAULTS.detectionTimeoutMs });
+        }
+        catch (e) {
+            console.log(`[checkbox] the box is out of the DOM's reach (${String(e?.message ?? e).split('\n')[0]}); finding it on screen`);
+            return null;
+        }
+    }
+    /** One capture and OpenCV: a point inside the tick box, in page coordinates. No model is asked. */
+    async findCheckboxOnScreen(el) {
+        const box = await el.boundingBox();
+        if (!box)
+            throw new Error('Could not get bounding box of captcha element');
+        const shot = tmp('checkbox');
+        let found;
+        let scale;
+        try {
+            await this.ph(kinds_1.Phase.SCREENSHOT, () => this.shot(el, shot, this.config.elementScreenshotTimeoutMs ?? 8000));
+            found = await this.runCvTool('find-checkbox', { image: shot }, ['find-checkbox', shot]);
+            scale = this.shotScale(shot, box.width);
+        }
+        finally {
+            unlink(shot);
+        }
+        if (!found) {
+            const e = new Error('UNSUPPORTED_CAPTCHA: the checkbox widget shows no tick box to click');
+            e.unsupported = true;
+            throw e;
+        }
+        const [x, y, w, h] = found.map((v) => v / scale);
+        return [box.x + x + w * (0.3 + Math.random() * 0.4), box.y + y + h * (0.3 + Math.random() * 0.4)];
+    }
+    /**
+     * A clicked checkbox passes or opens a challenge, and both show in the DOM.
+     * Without this wait the next round found the same checkbox still up and clicked it again.
+     */
+    async awaitWhatTheCheckboxOpened(page) {
+        const deadline = Date.now() + (this.config.postSubmitChangeTimeoutMs ?? 4000);
+        await this.ph(kinds_1.Phase.AWAIT_NEXT_ROUND, async () => {
+            while (Date.now() < deadline && !(await this.isCaptchaSolved(page))) {
+                const widget = await this.detectCaptcha(page);
+                if (widget?.role !== kinds_1.FrameRole.CHECKBOX)
+                    return;
+                await delay(this.config.postSolveOutcomePollMs ?? 75);
+            }
+        });
+    }
     getVerifyButton(scope) {
         return this.findControl(scope, selectors_1.SUBMIT_SELECTORS);
     }
     /** Any element at `selector` carrying a non-blank value; response fields are hidden, so no visibility filter. */
-    async hasValue(page, selector) {
-        const fields = await handles(await page.locator(selector).all().catch(() => []));
+    async hasValue(scopes, selector) {
+        const fields = await handles((await Promise.all(scopes.map((scope) => scope.locator(selector).all().catch(() => [])))).flat());
         return (await Promise.all(fields.map((f) => f.inputValue().catch(() => '')))).some((v) => v.trim().length > 0);
     }
     /** A visible match carrying text; an empty banner or prompt is a placeholder, not a signal. */
@@ -759,8 +1075,9 @@ class CaptchaKrakenSolver {
     /** Which verdict banner the open challenge shows; `dynamic-more` is the dynamic board's normal flow, not an error. */
     async bannerKind(page) {
         const probes = selectors_1.WIDGET_PROBES.filter((p) => p.role === kinds_1.FrameRole.CHALLENGE && selectors_1.SELECTORS[p.vendor].banners);
+        const scopes = await hostScopes(page);
         const kinds = await Promise.all(probes.map(async (p) => {
-            const [at] = await visible(page, [p.selector]);
+            const [at] = await visibleIn(scopes, [p.selector]);
             const frame = at && await frameOf(at);
             if (!frame)
                 return null;
@@ -773,11 +1090,12 @@ class CaptchaKrakenSolver {
     async isCaptchaSolved(page) {
         try {
             const checkboxes = selectors_1.WIDGET_PROBES.filter((p) => p.role === kinds_1.FrameRole.CHECKBOX && selectors_1.SELECTORS[p.vendor].checked);
+            const scopes = await hostScopes(page);
             const signals = await Promise.all([
-                ...selectors_1.RESPONSE_SELECTORS.map((s) => this.hasValue(page, s)),
-                visible(page, selectors_1.ACCEPTED_SELECTORS).then((found) => found.length > 0),
+                ...selectors_1.RESPONSE_SELECTORS.map((s) => this.hasValue(scopes, s)),
+                visibleIn(scopes, selectors_1.ACCEPTED_SELECTORS).then((found) => found.length > 0),
                 ...checkboxes.map(async (p) => {
-                    const [at] = await visible(page, [p.selector]);
+                    const [at] = await visibleIn(scopes, [p.selector]);
                     return !!at && this.checkedIn(at, selectors_1.SELECTORS[p.vendor].checked);
                 }),
             ]);
@@ -791,8 +1109,9 @@ class CaptchaKrakenSolver {
     async isChallengeFreshlyRendered(page) {
         try {
             const probes = selectors_1.WIDGET_PROBES.filter((p) => p.role === kinds_1.FrameRole.CHALLENGE && selectors_1.SELECTORS[p.vendor].fresh);
+            const scopes = await hostScopes(page);
             const fresh = await Promise.all(probes.map(async (p) => {
-                const [at] = await visible(page, [p.selector]);
+                const [at] = await visibleIn(scopes, [p.selector]);
                 const el = at && await handleOf(at);
                 if (!el || (this.lastSubmitFrameHash && (await this.elementFrameHash(el)) === this.lastSubmitFrameHash))
                     return false;
@@ -850,13 +1169,28 @@ class CaptchaKrakenSolver {
         const blob = names.join(' ');
         return selectors_1.VENDORS.filter(([, s]) => s.hosts.some((h) => blob.includes(h))).map(([vendor]) => vendor);
     }
-    async noWidgetMessage(page) {
-        const base = 'No interactive captcha widget detected';
+    /** Vendors showing a frame no selector names. Only asked once detection has found nothing, and a passive frame (an invisible badge, an enclave) is not a widget, so what is left is markup the table no longer matches. */
+    async unmatchedVendorFrames(page) {
+        const scopes = await hostScopes(page);
+        const counts = await Promise.all(selectors_1.VENDORS.map(async ([vendor, s]) => {
+            if (!s.hosts.length)
+                return null;
+            const [frames, passive] = await Promise.all([visibleIn(scopes, s.hosts.map((h) => `iframe[src*="${h}"]`)), visibleIn(scopes, s.passive ?? [])]);
+            return frames.length > passive.length ? vendor : null;
+        }));
+        return counts.filter((v) => v !== null);
+    }
+    async noWidgetMessage(page, waitedMs) {
+        const base = `No interactive captcha widget detected within ${waitedMs}ms`;
         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} (no vendor captcha code loaded on this page — likely reCAPTCHA v3 / invisible, or a click-triggered challenge that has not been triggered).`;
+        }
+        const framed = await this.unmatchedVendorFrames(page);
+        if (framed.length) {
+            return `${base}, BUT ${framed.join('/')} is showing a frame that matches nothing in SELECTORS. The vendor's markup has changed — the table needs re-measuring against the vendor's current markup, in both solver ports.`;
         }
-        return `${base}, BUT ${loaded.join('/')} code IS loaded and running on this page. The vendor's markup no longer matches anything in SELECTORS — the table needs re-measuring against the vendor's current markup, in both solver ports.`;
+        return `${base}; ${loaded.join('/')} code is loaded but drew no widget — the challenge may be invisible or not triggered yet, or an in-page widget's markup has changed.`;
     }
     /**
      * Is a widget in the DOM at all, rendered or not? Invisible reCAPTCHA is excluded by its selector. The inline vendors
@@ -867,20 +1201,21 @@ class CaptchaKrakenSolver {
     }
     /** Open challenges first, then unsolved checkboxes, then the inline vendors; every probe is queried at once. */
     async detectCaptcha(page) {
+        const scopes = await hostScopes(page);
         const found = await Promise.all(selectors_1.WIDGET_PROBES.map(async (p) => {
-            const [at] = await visible(page, [p.selector]);
-            return at && !(await this.alreadyAccepted(page, at, p)) ? { ...p, at } : null;
+            const [at] = await visibleIn(scopes, [p.selector]);
+            return at && !(await this.alreadyAccepted(scopes, at, p)) ? { ...p, at } : null;
         }));
         const hit = found.find((h) => h !== null);
         const el = hit && await handleOf(hit.at);
         return hit && el ? { el, at: hit.at, vendor: hit.vendor, role: hit.role } : null;
     }
     /** A checkbox the vendor has already accepted is not a captcha to solve. */
-    async alreadyAccepted(page, at, { role, vendor }) {
+    async alreadyAccepted(scopes, at, { role, vendor }) {
         const { response, checked } = selectors_1.SELECTORS[vendor];
         if (role !== kinds_1.FrameRole.CHECKBOX)
             return false;
-        const [token, box] = await Promise.all([!!response && this.hasValue(page, response), !!checked && this.checkedIn(at, checked)]);
+        const [token, box] = await Promise.all([!!response && this.hasValue(scopes, response), !!checked && this.checkedIn(at, checked)]);
         return token || box;
     }
     loraName(cliRoot) {
@@ -891,9 +1226,13 @@ class CaptchaKrakenSolver {
     /** The `--model` argv, or nothing: without VLLM_BASE_URL the CLI can see a credentials file this process cannot. */
     modelName(cliRoot) {
         const explicit = this.config.model ?? process.env.CAPTCHA_LORA_NAME;
-        if (explicit)
-            return explicit;
-        return process.env.VLLM_BASE_URL ? this.loraName(cliRoot) : undefined;
+        const name = explicit || (process.env.VLLM_BASE_URL ? this.loraName(cliRoot) : undefined);
+        if (name && !this.legacyModelWarned && (0, model_name_1.isHostedEndpoint)(process.env.VLLM_BASE_URL)
+            && (0, model_name_1.isLegacyHostedName)(name, cliRoot)) {
+            this.legacyModelWarned = true;
+            console.error(`[captchakraken] ${model_name_1.LEGACY_MODEL_WARNING.replace('{model}', name)}`);
+        }
+        return name;
     }
     resolveCli() {
         if (this.cliCache)
@@ -1361,36 +1700,38 @@ class CaptchaKrakenSolver {
                     break;
                 }
                 const frame = path.join(dir, `frame_${String(seq).padStart(4, '0')}.png`); // zero-padded: the slicer sorts by name
-                try {
-                    await this.shot(captchaElement, frame, cfg.elementScreenshotTimeoutMs ?? 8000, 'allow');
-                    captured++;
-                    seq++;
-                    lastFrame = frame;
+                // A frame taken while the board still wears our last gesture is not a screen it showed by itself.
+                if (Date.now() - this.lastInputAt >= exports.INPUT_SETTLE_MS)
                     try {
-                        const d = sha1(frame);
-                        if (d !== lastDigest) {
-                            lastChangeMs = elapsed();
-                            const seen = firstSeen.get(d);
-                            if (seen === undefined) {
-                                firstSeen.set(d, seq - 1);
-                                order.push(d);
-                                lastNewAt = Date.now();
-                                lastNewMs = elapsed();
-                            }
-                            else {
-                                if (order.length >= 2)
-                                    cycleClosed = true;
-                                if (seen >= cutAt)
-                                    segCycled = true;
-                                else if (seen >= filmStart)
-                                    sawPreCut = true;
+                        await this.shot(captchaElement, frame, cfg.elementScreenshotTimeoutMs ?? 8000, 'allow');
+                        captured++;
+                        seq++;
+                        lastFrame = frame;
+                        try {
+                            const d = sha1(frame);
+                            if (d !== lastDigest) {
+                                lastChangeMs = elapsed();
+                                const seen = firstSeen.get(d);
+                                if (seen === undefined) {
+                                    firstSeen.set(d, seq - 1);
+                                    order.push(d);
+                                    lastNewAt = Date.now();
+                                    lastNewMs = elapsed();
+                                }
+                                else {
+                                    if (order.length >= 2)
+                                        cycleClosed = true;
+                                    if (seen >= cutAt)
+                                        segCycled = true;
+                                    else if (seen >= filmStart)
+                                        sawPreCut = true;
+                                }
+                                lastDigest = d;
                             }
-                            lastDigest = d;
                         }
+                        catch { /* no digest, no early stop */ }
                     }
-                    catch { /* no digest, no early stop */ }
-                }
-                catch { /* a dropped frame costs a sample, not the recording */ }
+                    catch { /* a dropped frame costs a sample, not the recording */ }
                 // A continuous film reaches these same conditions and keeps rolling: they are what makes a SNAPSHOT
                 // ready to slice, not what makes the recording over. `settledOrCycled()` reads them without stopping.
                 const elapsedMs = elapsed();
@@ -1551,16 +1892,9 @@ class CaptchaKrakenSolver {
                 if (!names.length) {
                     const e = new Error('ANIMATED_CHALLENGE: could not record the animated challenge (no frame screenshotted).');
                     e.animated = true;
-                    // NOTHING CAME BACK, which is not a verdict about the board: a still photographs fine. It is a
-                    // widget that would not screenshot for the whole window, and the commonest reason for that is
-                    // that it is CLOSING, because the answer was accepted. The loop asks before giving up.
-                    // ONLY the speculative second look gets the soft landing. A board this solve has PROVEN
-                    // animated is a real dead end when it will not film, and must fail loudly as it always has:
-                    // measured on the python port, the two video types went from 3 solved and 10 keyframe calls
-                    // to 0 and 0 when both cases shared a handler, because the first failed film spends the
-                    // probe and every round after it is answered as a still.
-                    if (!this.knownAnimated)
-                        e.nothingFilmed = true;
+                    // Not a verdict about the board — a still photographs fine. A widget that would not screenshot for a
+                    // whole window is usually closing because the answer was accepted, so the loop asks before it counts
+                    // the round. A board proven animated keeps that verdict, and is filmed again rather than read as a still.
                     throw e;
                 }
                 const out = fs.mkdtempSync(path.join(os.tmpdir(), 'ck_slice_'));
@@ -1619,16 +1953,9 @@ class CaptchaKrakenSolver {
                     rmdir(dir);
                     const e = new Error('ANIMATED_CHALLENGE: could not record the animated challenge (no frame screenshotted).');
                     e.animated = true;
-                    // NOTHING CAME BACK, which is not a verdict about the board: a still photographs fine. It is a
-                    // widget that would not screenshot for the whole window, and the commonest reason for that is
-                    // that it is CLOSING, because the answer was accepted. The loop asks before giving up.
-                    // ONLY the speculative second look gets the soft landing. A board this solve has PROVEN
-                    // animated is a real dead end when it will not film, and must fail loudly as it always has:
-                    // measured on the python port, the two video types went from 3 solved and 10 keyframe calls
-                    // to 0 and 0 when both cases shared a handler, because the first failed film spends the
-                    // probe and every round after it is answered as a still.
-                    if (!this.knownAnimated)
-                        e.nothingFilmed = true;
+                    // Not a verdict about the board — a still photographs fine. A widget that would not screenshot for a
+                    // whole window is usually closing because the answer was accepted, so the loop asks before it counts
+                    // the round. A board proven animated keeps that verdict, and is filmed again rather than read as a still.
                     throw e;
                 }
                 const burstMs = Math.max(1, elapsed());
@@ -1662,9 +1989,9 @@ class CaptchaKrakenSolver {
             throw this.cliError(error, 'Cannot solve this animated captcha', 'Failed to execute the animated captcha solver');
         }
     }
-    /** The session id and the credential travel in the environment, never in argv. */
+    /** The routing values and the credential travel in the environment, never in argv. */
     solveEnvironment(cliRoot, apiKey) {
-        return (0, cli_invocation_1.solveEnv)(cliEnv(cliRoot, this.solveSessionId ? { CAPTCHA_KRAKEN_SESSION: this.solveSessionId } : undefined), apiKey, this.resampleLevel);
+        return (0, cli_invocation_1.solveEnv)(cliEnv(cliRoot, this.routingEnv()), apiKey, this.resampleLevel);
     }
     /** Exit 2 is an unsupported puzzle, exit 3 the hosted API's own refusal; both are relayed, not reworded. */
     cliError(error, unsupportedMessage, failMessage) {
@@ -1753,7 +2080,6 @@ class CaptchaKrakenSolver {
     resetSolveState() {
         this.solutionCache.clear();
         this.repeatedAnswerSeen = false;
-        this.retriedUnusableAnswer = false;
         this.knownAnimated = false;
         this.animatedProbeDone = false;
         this.discardAnimatedPlan();
@@ -1789,7 +2115,7 @@ class CaptchaKrakenSolver {
         const sig = CaptchaKrakenSolver.answerSignature(actions, retryMode);
         if (sig !== null && sig === this.lastAnswerSig) {
             this.noProgressRounds++;
-            console.log(`[no-progress] the model returned the same answer again (${this.noProgressRounds}/${this.config.maxNoProgressRounds ?? 2}) — the previous one already ran and changed nothing`);
+            console.log(`[no-progress] the model returned the same answer again (${this.noProgressRounds} in a row) — the previous one already ran and changed nothing`);
             this.resampleLevel++;
             // A raised sample never reaches the wire while the cached animated answer stands in front of it.
             this.invalidateAnimatedAnswer();
@@ -1936,11 +2262,15 @@ class CaptchaKrakenSolver {
                 haveAnchor = true;
             }
             catch { /* no anchor, no movement check */ }
+            // The idle wander hovers the board while the model reads it, and a board reacting to our pointer has not moved
+            // by itself: once we have touched it since the anchor, a change is no evidence that it cycles.
+            const anchoredAt = Date.now();
+            const untouched = () => this.lastInputAt < anchoredAt;
             let response = await runQuery(currentPath);
             mergedUsage.push(...response.token_usage);
             if (!enabled)
                 return response;
-            if (!this.actedOnBoard && !this.repeatedAnswerSeen && haveAnchor
+            if (!this.actedOnBoard && !this.repeatedAnswerSeen && haveAnchor && untouched()
                 && await this.captchaFrameChangedSince(captchaElement, liveAnchor, MOVED_DURING_INFERENCE_DIFF, 'allow')) {
                 this.repeatedAnswerSeen = true;
                 console.log('[freshness] the widget moved while the model was reading it, with nothing clicked — recording it rather than answering another still.');
@@ -1952,7 +2282,7 @@ class CaptchaKrakenSolver {
             for (let i = 0; i < maxReSolves; i++) {
                 if (!(await this.captchaFrameChangedSince(captchaElement, currentPath, threshold)))
                     break;
-                if (++changedDuringInference >= 2 && !this.actedOnBoard) {
+                if (++changedDuringInference >= 2 && !this.actedOnBoard && untouched()) {
                     this.repeatedAnswerSeen = true;
                     console.log('[freshness] the frame changed twice during inference with nothing clicked — this board cycles; recording it rather than re-solving a screen that has gone.');
                     return { actions: response.actions, token_usage: mergedUsage };
@@ -2129,10 +2459,10 @@ class CaptchaKrakenSolver {
     }
     async moveAndClick(page, element) {
         await this.move(page, element);
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.click(page, this.human.at));
+        await this.gesture(() => this.human.click(page, this.human.at));
     }
     async performSmoothMove(page, x, y) {
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.move(page, [x, y]));
+        await this.gesture(() => this.human.move(page, [x, y]));
     }
     /** Element-relative click point: a random spot inside the box, inset 10% off its border. */
     clickPointFor(action, elementBox) {
@@ -2154,10 +2484,10 @@ class CaptchaKrakenSolver {
             return;
         }
         const at = [elementBox.x + rel[0], elementBox.y + rel[1]];
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.move(page, at));
+        await this.gesture(() => this.human.move(page, at));
         await this.waitForKeyframe(element, awaitKeyframe, rel[0] / elementBox.width, rel[1] / elementBox.height);
         this.actedOnBoard = true;
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.click(page, at));
+        await this.gesture(() => this.human.click(page, at));
     }
     async executeClick(page, _element, action, elementBox) {
         this.actedOnBoard = true;
@@ -2166,12 +2496,12 @@ class CaptchaKrakenSolver {
             console.warn('Click action received without coordinates or bounding box', action);
             return;
         }
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.click(page, [elementBox.x + rel[0], elementBox.y + rel[1]]));
+        await this.gesture(() => this.human.click(page, [elementBox.x + rel[0], elementBox.y + rel[1]]));
     }
     async executeDrag(page, _element, action, elementBox) {
         this.actedOnBoard = true;
         const center = (bbox) => [elementBox.x + ((bbox[0] + bbox[2]) / 2) * elementBox.width, elementBox.y + ((bbox[1] + bbox[3]) / 2) * elementBox.height];
-        await this.ph(kinds_1.Phase.MOUSE, () => this.human.drag(page, center(action.source_bounding_box), center(action.target_bounding_box)));
+        await this.gesture(() => this.human.drag(page, center(action.source_bounding_box), center(action.target_bounding_box)));
     }
     /**
      * The slider piece's box: the first visible match small enough to be a piece. Runs during detection, so it must
@@ -2206,7 +2536,9 @@ class CaptchaKrakenSolver {
             return false;
         }
         await this.moveAndClick(page, field);
-        if (!(await this.human.typeText(page, field, text)))
+        const typed = await this.human.typeText(page, field, text);
+        this.lastInputAt = Date.now();
+        if (!typed)
             return false;
         console.log(`Typed ${text.length} character(s) into the captcha field.`);
         return true;
@@ -2241,7 +2573,7 @@ class CaptchaKrakenSolver {
             }
             const targetY = ((tb[1] + tb[3]) / 2) * elementBox.height;
             console.log('No slider track; dragging the piece to the slot directly.');
-            await this.human.drag(page, [box.x + box.width / 2, box.y + box.height / 2], [elementBox.x + targetX, elementBox.y + targetY]);
+            await this.gesture(() => 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();
@@ -2314,6 +2646,7 @@ class CaptchaKrakenSolver {
                 await this.human.release(page);
             }
             catch { /* the page may have navigated */ }
+            this.lastInputAt = Date.now();
             for (const s of shots)
                 unlink(s);
         }