captchakraken 3.0.0 → 3.2.0

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");
@@ -56,6 +59,10 @@ const slide_geometry_1 = require("./slide-geometry");
 const model_name_1 = require("./model-name");
 const selectors_1 = require("./selectors");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/** The ceiling on one ask, matching the Python planner's own default. */
+const CLI_ASK_TIMEOUT_MS = 120000;
+/** And the floor, so a nearly-spent budget still gets a real attempt rather than a certain timeout. */
+const CLI_ASK_MIN_TIMEOUT_MS = 10000;
 const log = (message, ...args) => console.log(`[Solver] ${message}`, ...args);
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 const tmp = (prefix) => path.join(os.tmpdir(), `${prefix}_${Date.now()}_${Math.floor(Math.random() * 1e9)}.png`);
@@ -135,8 +142,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.
@@ -144,9 +157,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,
 };
@@ -154,10 +206,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;
@@ -171,7 +236,9 @@ class CaptchaKrakenSolver {
         /** Answers keyed by screenshot hash; a hit means the answer already ran and changed nothing. */
         this.solutionCache = new Map();
         this.repeatedAnswerSeen = false;
-        /** The one recording and one answer for the animated board on screen. */
+        this.knownAnimated = false;
+        this.animatedProbeDone = false;
+        /** The one recording for the animated board on screen, and its answer until the widget refuses it. */
         this.animatedPlan = null;
         this.keyframeMode = null;
         this.keyframeSteadyScreens = 0;
@@ -181,13 +248,34 @@ class CaptchaKrakenSolver {
         this.resampleLevel = 0;
         /** The recording `classifyByRecording` started and left running for the branch below to finish or drop. */
         this.pendingBurst = null;
+        /**
+         * The camera on the animated board in front of us, running across rounds until that board is gone.
+         *
+         * Distinct from `pendingBurst`, which is the speculative film one round starts and the same round spends.
+         * This one outlives a rejected answer on purpose: it is the only thing that can give the next ask a
+         * different question to answer, since the answer itself is deterministic at temperature 0.
+         */
+        this.animatedFilm = null;
         this.lastBurstFps = null;
         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 } });
     }
@@ -197,14 +285,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);
@@ -216,48 +363,86 @@ class CaptchaKrakenSolver {
         finally {
             if ((0, timing_1.timingsEnabled)())
                 console.error(this.budget.report());
+            // The camera outlives a round by design, so it has to be ended by the thing that outlives the solve.
+            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;
@@ -265,23 +450,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;
@@ -292,49 +492,65 @@ class CaptchaKrakenSolver {
                 ({ didInteract, tokenUsage } = await this.solveSingle(page, widget, attempt, retryModeThisLoop));
             }
             catch (e) {
-                if (e?.animated)
-                    throw new Error(`Animated challenge could not be solved: ${e.message ?? 'recording failed'}`);
+                const emsg = String((e && e.message) || e);
                 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}`);
+                    // 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;
                 }
-                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);
+                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();
+                    }
+                    await again(emsg, { inTransition: true });
                     continue;
                 }
-                throw 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();
+                }
+                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.'
+                        : '.'));
+                }
+                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;
@@ -342,6 +558,16 @@ class CaptchaKrakenSolver {
                 if (await this.isChallengeFreshlyRendered(page)) {
                     this.resampleLevel = 0;
                     this.actedOnBoard = false;
+                    // ONE FILM, ONE BOARD — enforced where the board actually changes. The recorded answer
+                    // describes the board it was cut from, so replaying it here presses that board's
+                    // coordinates onto this one: live, a keyframe answer from an earlier board landed on
+                    // hCaptcha's reference photo and then pressed Skip, six rounds running.
+                    await this.stopAnimatedFilm();
+                    this.knownAnimated = false;
+                    // Its own second look, but only once IT fails: what armed it was evidence about the previous board,
+                    // and left set it filmed every still board after a solve's first miss.
+                    this.repeatedAnswerSeen = false;
+                    this.animatedProbeDone = false;
                     break;
                 }
                 await delay(cfg.postSolveOutcomePollMs ?? 75);
@@ -351,21 +577,83 @@ 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) {
-                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))}`);
+            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
+                await again('The solver performed no interactions this round');
+            }
+        }
+        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);
         }
-        throw new Error(`Captcha still detected after ${maxSolveLoops} solve loops. Total usage: ${JSON.stringify((0, token_usage_1.aggregateTokenUsage)(cumulativeTokenUsage))}`);
+        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 shown = await Promise.all(probes.map(async (p) => {
+                const [at] = await visible(page, [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) {
@@ -391,12 +679,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;
-        // Only the DOM can tell a typed captcha from a click puzzle; hCaptcha and reCAPTCHA never type.
-        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.');
+        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));
@@ -404,8 +694,23 @@ class CaptchaKrakenSolver {
             }
             await this.ph(kinds_1.Phase.HCAPTCHA_IMAGES, () => this.waitForBoardImages(frame, selectors_1.SELECTORS[puzzleSource]));
         }
-        // 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;
+        // THE TWO QUESTIONS BELOW ARE PUT TO A PAINTED BOARD. Which expert answers the round is read out of the
+        // DOM and whether the board cycles is read off its motion, and a widget that has not drawn yet has no
+        // text box to find and no motion but its own arrival.
+        //
+        // A reCAPTCHA board is asked NEITHER — it is never typed and never filmed — and it waits for its board
+        // at the grid gate below, on the cells themselves. Waiting here as well put 0.8-1.8s in front of that
+        // gate on every dynamic round, on the family with the tightest per-board budget.
+        const painted = puzzleSource === kinds_1.Vendor.RECAPTCHA ? null
+            : await this.ph(kinds_1.Phase.BOARD_PAINT, () => this.waitForBoardPainted(captchaElement));
+        // Only the DOM can tell a typed captcha from a click puzzle; hCaptcha and reCAPTCHA never type.
+        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 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) {
@@ -423,9 +728,15 @@ class CaptchaKrakenSolver {
             await this.releasePendingBurst();
             return { didInteract: false, tokenUsage: [] };
         }
-        if (!isAnimated && this.shouldRetryAsAnimated(puzzleSource)) {
-            console.log('[animated] a picture we already answered came back — recording it');
+        // 'settled' is not proof of static: a repeated answer buys ONE recording to find out, and the clip that
+        // recording brings back is what decides — `knownAnimated` is set from it below, not from here.
+        let probing = false;
+        if (!isAnimated && this.knownAnimated)
             isAnimated = true;
+        else if (!isAnimated && this.shouldRetryAsAnimated(puzzleSource)) {
+            console.log('[animated] a second look at a board that did not solve as a still — recording it');
+            this.animatedProbeDone = true;
+            isAnimated = probing = true;
         }
         let establishedGridSize = null;
         // The challenge frame only: on the anchor this wasted an 8s grid-load timeout plus a find-grid subprocess.
@@ -441,10 +752,15 @@ class CaptchaKrakenSolver {
             }
             establishedGridSize = grid?.size ?? null;
         }
-        const painted = await this.ph(kinds_1.Phase.BOARD_PAINT, () => this.waitForBoardPainted(captchaElement));
-        // The classifier's last frame is a settled still, unless the board painted while we watched.
+        // The board a reCAPTCHA round photographs, for the rounds that do not take the grid path above.
+        if (puzzleSource === kinds_1.Vendor.RECAPTCHA) {
+            await this.ph(kinds_1.Phase.BOARD_PAINT, () => this.waitForBoardPainted(captchaElement));
+        }
+        // The classifier watched a board that had already painted, so its last frame is that board at rest —
+        // unless it never painted at all, where a fresh photograph is the better chance of catching one.
         const screenshotPath = tmp('captcha');
-        const settledFrame = (isAnimated || painted.waitedMs >= (cfg.boardPaintPollMs ?? 180)) ? null : (this.pendingBurst?.stableFrame() ?? null);
+        const settledFrame = (isAnimated || painted?.verdict !== kinds_1.PaintVerdict.PAINTED)
+            ? null : (this.pendingBurst?.stableFrame() ?? null);
         if (settledFrame && fs.existsSync(settledFrame)) {
             fs.copyFileSync(settledFrame, screenshotPath);
         }
@@ -460,24 +776,75 @@ class CaptchaKrakenSolver {
         let allTokenUsage = [];
         let burstDir = null;
         try {
-            let response;
+            let response = null;
             const ask = (imagePath) => this.getSolution(imagePath, puzzleSource, retryMode, textMode);
             const askAnimated = () => this.ph(kinds_1.Phase.INFERENCE, () => this.withIdleWander(page, captchaElement, () => this.getAnimatedSolution(burstDir)));
             if (isAnimated) {
-                if (this.animatedPlan) {
+                // The camera was paused while the last answer was performed; from here the board is its own again.
+                this.animatedFilm?.resume();
+                if (this.animatedPlan?.response) {
                     burstDir = this.animatedPlan.burstDir;
                     response = this.animatedPlan.response;
                     console.log('[animated] reusing the recorded answer — same board, same screens');
                 }
-                else {
-                    const rec = this.pendingBurst;
-                    this.pendingBurst = null;
-                    burstDir = await this.ph(kinds_1.Phase.BURST, () => rec ? rec.finish() : this.recordKeyframeBurst(captchaElement));
+                else if (this.animatedPlan) {
+                    // Drop the ANSWER, keep the FRAMES — and the frames have grown. The camera did not stop when the
+                    // last answer was sent, so re-slicing now covers a round more of the board than the ask that was
+                    // refused. Re-asking the SAME frames would put the same question up and get the same answer back,
+                    // which is the loop this invariant exists to break.
+                    //
+                    // But it has to be the SAME BOARD. The wait below is what decides: it ends the moment a screen
+                    // from before our answer comes back — usually one frame — and otherwise runs until the board that
+                    // IS there has shown itself, and the slice is cut to that. Skipping it re-asked over a film that
+                    // held nothing of the current board at all.
+                    const film = this.animatedFilm;
+                    let grown = null;
+                    if (film) {
+                        await this.ph(kinds_1.Phase.BURST, () => film.settledOrCycled());
+                        grown = await film.snapshot();
+                    }
+                    if (grown)
+                        rmdir(this.animatedPlan.burstDir);
+                    burstDir = grown?.dir ?? this.animatedPlan.burstDir;
+                    console.log(grown
+                        ? '[animated] the last answer was refused — re-asking on the film as it stands now'
+                        : '[animated] the last answer was refused — re-asking on the frames already recorded');
                     response = await askAnimated();
                     this.animatedPlan = { burstDir, response };
                 }
+                else {
+                    const rec = this.animatedFilm ?? this.pendingBurst ?? this.startKeyframeBurst(captchaElement, true);
+                    this.pendingBurst = null;
+                    // First slice of a board waits for it to show a cycle or settle; a later one does not, because the
+                    // camera has been running through the whole previous round and already holds more than that.
+                    const first = this.animatedFilm !== rec;
+                    if (first)
+                        await this.ph(kinds_1.Phase.BURST, () => rec.settledOrCycled());
+                    const film = await rec.snapshot();
+                    if (probing)
+                        this.knownAnimated = film.moved;
+                    if (!probing || film.moved) {
+                        this.animatedFilm = rec;
+                        burstDir = film.dir;
+                        response = await askAnimated();
+                        this.animatedPlan = { burstDir, response };
+                    }
+                    else {
+                        // The clip answers the question the probe asked: a board that never moved is a still, and the
+                        // video expert can only answer a still with a frame number the widget will not take.
+                        console.log('[animated] the recording shows a still board; solving it as a still');
+                        const rested = rec.stableFrame();
+                        if (rested && fs.existsSync(rested))
+                            fs.copyFileSync(rested, screenshotPath);
+                        rmdir(film.dir);
+                        if (this.animatedFilm === rec)
+                            this.animatedFilm = null;
+                        await rec.abandon();
+                        isAnimated = false;
+                    }
+                }
             }
-            else if (this.shouldSpeculate(puzzleSource, textMode)) {
+            if (!response && this.shouldSpeculate(puzzleSource, textMode)) {
                 // Ask the still and film at once. No idle wander: a moving cursor reads as new screens.
                 const rec = this.pendingBurst ?? this.startKeyframeBurst(captchaElement);
                 this.pendingBurst = null;
@@ -508,14 +875,13 @@ class CaptchaKrakenSolver {
                 }
                 else {
                     console.log('[animated] the widget moved while the model was reading it — dropping the still answer and finishing the recording.');
-                    isAnimated = true;
-                    this.repeatedAnswerSeen = true;
-                    burstDir = await this.ph(kinds_1.Phase.BURST, () => rec.finish());
+                    isAnimated = this.knownAnimated = true;
+                    burstDir = (await this.ph(kinds_1.Phase.BURST, () => rec.finish())).dir;
                     response = await askAnimated();
                     this.animatedPlan = { burstDir, response };
                 }
             }
-            else {
+            else if (!response) {
                 response = await this.ph(kinds_1.Phase.INFERENCE, () => this.solveFrameFreshnessGuarded(captchaElement, screenshotPath, (imagePath) => this.withIdleWander(page, captchaElement, () => ask(imagePath))));
             }
             const actionList = Array.isArray(response.actions) ? response.actions : [response.actions];
@@ -533,9 +899,13 @@ class CaptchaKrakenSolver {
             console.log('[answer] ' + JSON.stringify({ actions: actionList }));
             // A repeated answer is not re-performed: the widget already refused it, and every extra press is
             // behaviour a vendor scores. Re-asking with a fresh sample or a recording is the round's only move.
+            // `noteAnswer` drops the refused animated answer on its way through, so the next round re-asks.
             if (this.noteAnswer(actionList, retryMode))
                 return { didInteract: false, tokenUsage: allTokenUsage };
             console.log(`Executing ${actionList.length} actions.`);
+            // Stop filming before we touch it. Everything from here to the vendor's verdict is our own answer
+            // landing, and a frame of the board wearing our clicks is not a screen the board ever showed.
+            this.animatedFilm?.pause();
             for (const action of actionList) {
                 if (action.action === kinds_1.ActionKind.CLICK) {
                     const c = action;
@@ -605,6 +975,77 @@ 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);
     }
@@ -718,13 +1159,27 @@ 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) is not a widget, so what is left is markup the table no longer matches. */
+    async unmatchedVendorFrames(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([visible(page, s.hosts.map((h) => `iframe[src*="${h}"]`)), visible(page, 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
@@ -759,9 +1214,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)
@@ -775,6 +1234,18 @@ class CaptchaKrakenSolver {
         this.cliCache = { cliRoot, py };
         return this.cliCache;
     }
+    /** What is LEFT of the solve, as a bound on one ask.
+     *
+     * The CLI is a child process and the solve deadline is only read between steps, so nothing stops an
+     * ask already in flight — measured against the hosted endpoint, one hung for ~124s inside a 45s
+     * budget and the attempt ran 143s. Never below the floor: a keyframe ask carries six images, and a
+     * timeout shorter than the work turns a busy endpoint into a guaranteed failure. */
+    askTimeoutMs() {
+        const ceiling = CLI_ASK_TIMEOUT_MS;
+        if (!this.solveDeadlineAt)
+            return ceiling;
+        return Math.max(CLI_ASK_MIN_TIMEOUT_MS, Math.min(ceiling, this.solveDeadlineAt - Date.now()));
+    }
     /** One-shot CLI tool call; `{}` on any failure so polling callers keep going. */
     async runCliTool(args) {
         try {
@@ -1140,20 +1611,32 @@ class CaptchaKrakenSolver {
         }
         return { didInteract: performedAction, tokenUsage: allTokenUsage };
     }
-    async recordKeyframeBurst(captchaElement) {
-        return this.startKeyframeBurst(captchaElement).finish();
-    }
     /**
      * Start filming now and decide later what it was for: the classifier, the speculative film, or the
      * recording an animated answer is sliced from. Every window is wall-clock. A cycle is a screen that
      * comes back; a board that shows nothing new for a floor window has settled. There is deliberately no
      * "enough screens, stop" exit: measured on number_with_highest_value_video it failed every seed either way.
+     *
+     * `continuous` keeps the camera rolling past the first answer, for the whole solve. A one-shot burst can
+     * only ever show the model the screens that happened to fall inside its window — measured, a 4s burst
+     * against a 5.3s cycle showed two screens of three, and when the answer lived on the third there was no
+     * second chance, because the reused answer is identical by construction. Filming on means every later
+     * round slices a STRICTLY LONGER film: more repetitions for `_detect_cycle` to confirm against, and, on a
+     * board that never repeats, six evenly-spread picks across the whole solve instead of across four seconds.
+     *
+     * Longer, but never of TWO boards. A vendor that deals a fresh puzzle on a miss has replaced everything
+     * filmed so far, and keyframes cut across both states describe neither. `resume` cuts the film where our
+     * answer landed; a screen from before the cut coming back is what un-cuts it. See `snapshot`.
      */
-    startKeyframeBurst(captchaElement) {
+    startKeyframeBurst(captchaElement, continuous = false) {
         const cfg = this.config;
         const fps = Math.max(1, cfg.videoBurstFps ?? 10);
         const floorMs = cfg.videoBurstDurationMs ?? 4000;
-        const ceilingMs = Math.max(floorMs, cfg.videoBurstMaxMs ?? 12000);
+        // A continuous film ends with the solve, not on its own clock. The ceiling stays as a safety net so a
+        // widget that never stops changing cannot fill a disk; it is not the working limit.
+        const ceilingMs = continuous
+            ? Math.max(floorMs, cfg.videoFilmMaxMs ?? 120000)
+            : Math.max(floorMs, cfg.videoBurstMaxMs ?? 12000);
         const intervalMs = 1000 / fps;
         const t0 = Date.now();
         let nextAt = t0;
@@ -1163,58 +1646,107 @@ class CaptchaKrakenSolver {
         const order = [];
         let captured = 0;
         let lastDigest = null;
+        let lastNewAt = t0;
         let lastNewMs = 0;
         let lastChangeMs = 0;
+        // WHERE THE BOARD ON SCREEN STARTED. A film can only describe ONE board, and a vendor that refuses an
+        // answer sometimes deals a fresh puzzle rather than the same one again. The boundary is where OUR ANSWER
+        // LANDED — `pause` — because that is the moment a board can be replaced; `sawPreCut` is the proof it was
+        // not, a screen from before that boundary coming back. `filmStart` is the committed one: once a film has
+        // been cut, the footage before the cut is gone for good and a later repeat cannot resurrect it.
+        let filmStart = 0;
+        let filmT0 = t0;
+        let cutAt = 0;
+        let cutT0 = t0;
+        let sawPreCut = false;
+        // A cycle closed among screens first seen SINCE the cut: the board on screen now repeats, and it is not
+        // repeating anything the film already held. That, and only that, is evidence of a replacement — a board
+        // that never repeats a screen at all cannot produce the proof either way, and is not a new board.
+        let segCycled = false;
+        const firstSeen = new Map();
         let lastFrame = null;
         let cycleClosed = false;
         let stopped = false;
         let runToEnd = false;
+        let paused = false;
+        let hangAt = hangDeadline;
+        // Names are contiguous across a pause and across a dropped frame, because the slicer sorts by name and
+        // spaces what it finds evenly. A gap in the numbering would tell it the board held a screen it never held.
+        let seq = 0;
         const loop = (async () => {
             for (let i = 0; elapsed() < ceilingMs && !stopped; i++) {
-                if (Date.now() > hangDeadline) {
+                if (paused) {
+                    // The camera stays alive but films nothing: the next frames would be OUR answer landing, and a
+                    // board carrying our own clicks is not a screen the board ever showed on its own.
+                    await delay(intervalMs);
+                    nextAt = Date.now();
+                    hangAt = Date.now() + burstHangDeadlineMs(cfg);
+                    continue;
+                }
+                if (Date.now() > hangAt) {
                     console.warn(`[animated] the recording stalled: ${captured} frames in ${burstHangDeadlineMs(cfg)}ms — the widget is not screenshotting`);
                     break;
                 }
-                const frame = path.join(dir, `frame_${String(i).padStart(4, '0')}.png`); // zero-padded: the slicer sorts by name
-                try {
-                    await this.shot(captchaElement, frame, cfg.elementScreenshotTimeoutMs ?? 8000, 'allow');
-                    captured++;
-                    lastFrame = frame;
+                const frame = path.join(dir, `frame_${String(seq).padStart(4, '0')}.png`); // zero-padded: the slicer sorts by name
+                // 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();
-                            if (order.includes(d) && order.length >= 2)
-                                cycleClosed = true;
-                            else if (!order.includes(d)) {
-                                order.push(d);
-                                lastNewMs = elapsed();
+                        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();
-                if (runToEnd && elapsedMs >= floorMs && elapsedMs - lastNewMs >= floorMs) {
+                if (!continuous && runToEnd && elapsedMs >= floorMs && Date.now() - lastNewAt >= floorMs) {
                     console.log(`[animated] no new screen for ${(floorMs / 1000).toFixed(1)}s (${order.length} seen) — the board has settled; stopping the burst`);
                     break;
                 }
-                if (runToEnd && cycleClosed && elapsedMs >= floorMs) {
+                if (!continuous && runToEnd && cycleClosed && elapsedMs >= floorMs) {
                     console.log(`[animated] cycle closed after ${(elapsedMs / 1000).toFixed(1)}s (${order.length} screens); stopping the burst`);
                     break;
                 }
                 // Sleep to a fixed grid, not `interval - work`: per-frame overshoot would otherwise accumulate and a
                 // loaded runner films fewer frames than the floor window holds. A stalled frame skips, not bunches.
+                // End on the frame that would land past the ceiling rather than declining to sleep for it: declining
+                // left the loop spinning at whatever rate the screenshots came back, filming junk into the tail of
+                // the clip (measured on the python twin: 2487 frames in a 150ms window).
                 nextAt = Math.max(nextAt + intervalMs, Date.now());
+                if (nextAt - t0 >= ceilingMs)
+                    break;
                 const wait = nextAt - Date.now();
-                if (wait > 0 && nextAt - t0 < ceilingMs)
+                if (wait > 0)
                     await delay(wait);
             }
         })();
         let ended = false;
-        loop.then(() => { ended = true; }, () => { ended = true; });
+        let endedAtMs = 0;
+        loop.then(() => { ended = true; endedAtMs = elapsed(); }, () => { ended = true; endedAtMs = elapsed(); });
         return {
             moved: () => cycleClosed,
             screensSeen: () => order.length,
@@ -1246,7 +1778,7 @@ class CaptchaKrakenSolver {
                 while (!cycleClosed && !ended && !stopped) {
                     const elapsedMs = elapsed();
                     if (elapsedMs >= floorMs) {
-                        if (elapsedMs - lastNewMs >= floorMs) {
+                        if (Date.now() - lastNewAt >= floorMs) {
                             why = 'no new screen for a full floor window — it moved once and settled';
                             break;
                         }
@@ -1258,12 +1790,134 @@ class CaptchaKrakenSolver {
                     }
                     await delay(intervalMs);
                 }
+                // A RECORDING THAT HAS ENDED STILL ANSWERS THE QUESTION, by the same rule and off its own clock
+                // rather than the wall's. The loop above only reads a film that is still rolling, so an ask that
+                // outlived the recording turned every finished film into "still" — and a board that cycles, filmed
+                // for its whole window, was then answered from one screen, clicked, and refused.
+                if (!cycleClosed && !animating && ended && order.length > BURST_ANIMATED_SCREENS
+                    && endedAtMs - lastNewMs < floorMs) {
+                    animating = true;
+                    why = `${order.length} screens and still arriving when the recording ended`;
+                }
                 const moved = cycleClosed || animating;
                 if (!moved && (ended || stopped))
                     why = ended ? 'the recording ended' : 'abandoned';
                 console.log(`[animated] burst verdict after ${(elapsed() / 1000).toFixed(1)}s: ${moved ? 'ANIMATED' : 'still'} (${order.length} screens; ${why})`);
                 return moved;
             },
+            /**
+             * Resolve once the film holds something worth slicing: a closed cycle, or a board that has shown
+             * nothing new for a floor window. The same two conditions `finish()` stops on — read, not acted on,
+             * so a continuous film can be sliced repeatedly without ever being ended.
+             */
+            settledOrCycled: async () => {
+                runToEnd = true;
+                // HOW LONG TO WAIT BEFORE SLICING, which is NOT how long the camera may run. Those are different
+                // quantities and conflating them cost a board 121.9s against a 20s gate ceiling: a film that never
+                // cycles and never settles held the first slice until the CAMERA's ceiling. The wait keeps the
+                // burst ceiling it always had; the camera keeps running afterwards regardless.
+                const waitUntil = Math.max(floorMs, cfg.videoBurstMaxMs ?? 12000);
+                // Nothing has been answered on this board yet, so there is a cycle to go and find.
+                const firstSlice = cutAt === filmStart;
+                while (!ended && !stopped) {
+                    // A screen from before our answer came back: the board was NOT replaced, so the film already in
+                    // hand describes the board that is on screen and there is nothing left to wait for. This is the
+                    // common case and it costs a frame, not a window.
+                    if (sawPreCut)
+                        return;
+                    const segMs = Date.now() - cutT0;
+                    if (segMs >= floorMs) {
+                        if (segCycled)
+                            return;
+                        if (Date.now() - lastNewAt >= floorMs)
+                            return;
+                        // A board that never repeated a screen BEFORE our answer will not start now: there is no cycle
+                        // to wait for and no replacement it could prove, so the film in hand is everything there is to
+                        // know and waiting out the ceiling every round is pure cost. Measured: one such board took
+                        // 110.3s that way, against a 49s gate ceiling.
+                        if (!firstSlice && !cycleClosed)
+                            return;
+                    }
+                    if (segMs >= waitUntil) {
+                        console.log(`[animated] no cycle and no settle in ${(segMs / 1000).toFixed(1)}s — slicing what the film holds`);
+                        return;
+                    }
+                    await delay(intervalMs);
+                }
+            },
+            /**
+             * Our answer is about to land, so this frame is the boundary: everything after it is whatever board
+             * the vendor leaves behind, which may not be the one filmed up to here. Only a screen from before the
+             * boundary coming back proves it is still the same board — see `snapshot`.
+             */
+            pause: () => {
+                paused = true;
+                cutAt = seq;
+                sawPreCut = false;
+                segCycled = false;
+            },
+            resume: () => {
+                paused = false;
+                nextAt = Date.now();
+                cutT0 = Date.now();
+                lastNewAt = Date.now();
+                hangAt = Date.now() + burstHangDeadlineMs(cfg);
+            },
+            /**
+             * A stable copy of everything filmed so far, WITHOUT ending the recording.
+             *
+             * Hardlinked rather than copied: the slicer wants a directory it can sort by name and read to the end,
+             * and handing it the live one would have it read a directory being written underneath it — a frame
+             * half-flushed reads as a corrupt PNG, and a frame arriving mid-sort shifts every index after it.
+             * Links are near-free on the same filesystem, which is why this can be afforded once a round.
+             */
+            snapshot: async () => {
+                if (cfg.videoSolveEnabled !== false && !this.videoBudgetGranted) {
+                    this.videoBudgetGranted = true;
+                    this.videoBudgetMs = (cfg.videoBurstMaxMs ?? 12000) + (cfg.keyframeWaitTimeoutMs ?? exports.SOLVE_DEFAULTS.keyframeWaitTimeoutMs) + (cfg.videoExtraInferenceMs ?? 8000);
+                }
+                const names = fs.readdirSync(dir).filter((f) => f.endsWith('.png')).sort();
+                if (!names.length) {
+                    const e = new Error('ANIMATED_CHALLENGE: could not record the animated challenge (no frame screenshotted).');
+                    e.animated = 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_'));
+                // ONE FILM, ONE BOARD. Frames from a board the vendor has already replaced name screens that no
+                // longer exist: the model answers with one, the widget never shows it, and the click waits out
+                // `keyframeWaitTimeoutMs` for a picture that is gone. So a film whose board was replaced is read
+                // from the cut; one whose screens kept coming back is read whole, which is the point of filming on.
+                // The LAST name can be the frame currently being written. Dropping it costs one sample and removes
+                // the only torn read this can have.
+                // Cut ONLY on proof of a replacement: this board repeats, and nothing it repeats was in the film.
+                // Defaulting the other way threw away the whole film on every board that never repeats a screen —
+                // exactly the boards a film running the whole solve exists to accumulate.
+                let from = (!sawPreCut && segCycled) ? cutAt : filmStart;
+                if (names.length - 1 - from < 1)
+                    from = filmStart;
+                // Committed: a board that was replaced stays replaced, so a repeat two rounds later cannot pull its
+                // screens back into the film.
+                if (from !== filmStart) {
+                    filmStart = from;
+                    filmT0 = cutT0;
+                }
+                for (const n of names.slice(from, -1)) {
+                    try {
+                        fs.linkSync(path.join(dir, n), path.join(out, n));
+                    }
+                    catch {
+                        fs.copyFileSync(path.join(dir, n), path.join(out, n));
+                    }
+                }
+                const burstMs = Math.max(1, Date.now() - filmT0);
+                this.lastBurstFps = (names.length - 1 - from) / (burstMs / 1000);
+                const animating = order.length > BURST_ANIMATED_SCREENS && Date.now() - lastNewAt < floorMs;
+                console.log(`[animated] sliced ${names.length - 1 - from} of ${captured} frames filmed over ${(burstMs / 1000).toFixed(1)}s (${order.length} screens)${from ? ' since the board was replaced' : ''} -> ${out}`);
+                return { dir: out, moved: cycleClosed || sawPreCut || animating };
+            },
             abandon: async () => {
                 stopped = true;
                 try {
@@ -1287,12 +1941,16 @@ class CaptchaKrakenSolver {
                     rmdir(dir);
                     const e = new Error('ANIMATED_CHALLENGE: could not record the animated challenge (no frame screenshotted).');
                     e.animated = 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());
                 this.lastBurstFps = captured / (burstMs / 1000);
+                const animating = order.length > BURST_ANIMATED_SCREENS && Date.now() - lastNewAt < floorMs;
                 console.log(`[animated] recorded ${captured} frames in ${(burstMs / 1000).toFixed(1)}s (${this.lastBurstFps.toFixed(1)}fps) -> ${dir}`);
-                return dir;
+                return { dir, moved: cycleClosed || animating };
             },
         };
     }
@@ -1304,7 +1962,7 @@ class CaptchaKrakenSolver {
         const args = ['-m', 'captchakraken.cli', 'solve-animated', '--frames-dir', framesDir,
             '--fps', String(this.lastBurstFps ?? this.config.videoBurstFps ?? 10), ...(m ? ['--model', m] : [])];
         try {
-            const { stdout, stderr } = await execFileAsync(py, args, { cwd: cliRoot, env: this.solveEnvironment(cliRoot, apiKey), maxBuffer: 10 * 1024 * 1024 });
+            const { stdout, stderr } = await execFileAsync(py, args, { cwd: cliRoot, env: this.solveEnvironment(cliRoot, apiKey), maxBuffer: 10 * 1024 * 1024, timeout: this.askTimeoutMs(), killSignal: 'SIGKILL' });
             if (stderr)
                 console.error('CaptchaKraken CLI stderr:', stderr);
             const parsed = JSON.parse(stdout.trim());
@@ -1319,9 +1977,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) {
@@ -1391,6 +2049,7 @@ class CaptchaKrakenSolver {
                     if (polls >= NOT_THIS_BOARD_POLLS && best > NOT_THIS_BOARD_DIFF) {
                         console.log(`[animated] the widget no longer resembles the recorded board (best diff=${best.toFixed(4)} over ${polls} polls); not waiting out the budget`);
                         this.discardAnimatedPlan();
+                        await this.stopAnimatedFilm();
                         return false;
                     }
                 }
@@ -1402,12 +2061,15 @@ class CaptchaKrakenSolver {
             unlink(probe);
         }
         this.discardAnimatedPlan();
+        await this.stopAnimatedFilm();
         console.log(`[animated] widget never matched the chosen keyframe within ${timeout}ms (closest diff=${best.toFixed(4)}); clicking on the model's coordinates anyway, and recording afresh next round`);
         return false;
     }
     resetSolveState() {
         this.solutionCache.clear();
         this.repeatedAnswerSeen = false;
+        this.knownAnimated = false;
+        this.animatedProbeDone = false;
         this.discardAnimatedPlan();
         this.lastSubmitFrameHash = null;
         this.keyframeMode = null;
@@ -1430,13 +2092,21 @@ class CaptchaKrakenSolver {
             return null;
         }
     }
+    /** The recording still stands; dropping only the refused answer makes the retry an inference, not a burst. */
+    invalidateAnimatedAnswer() {
+        const plan = this.animatedPlan;
+        if (plan?.response)
+            this.animatedPlan = { burstDir: plan.burstDir, response: null };
+    }
     /** True when this answer already ran and changed nothing: resample, and let the recording path have a go. */
     noteAnswer(actions, retryMode) {
         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();
             this.repeatedAnswerSeen = true;
             return true;
         }
@@ -1456,12 +2126,30 @@ class CaptchaKrakenSolver {
         this.solutionCache.set(cacheKey, fresh);
         return fresh;
     }
+    /**
+     * Drop the ANSWER, keep the camera.
+     *
+     * The two are deliberately separable. An answer the widget refused is spent — reusing it just presses the
+     * same wrong thing until the no-progress fence trips, three rounds in, with half the budget unspent. The
+     * film is the opposite: every second it keeps running makes the next slice a better question. So a
+     * refusal discards this and leaves `animatedFilm` alone; only a board that is GONE stops the camera.
+     */
     discardAnimatedPlan() {
         const dir = this.animatedPlan?.burstDir;
         this.animatedPlan = null;
         if (dir && fs.existsSync(dir))
             rmdir(dir);
     }
+    /** The board is gone: its film can never describe the next one, so end it and free the frames. */
+    async stopAnimatedFilm() {
+        const film = this.animatedFilm;
+        this.animatedFilm = null;
+        // The plan's slice goes too. This runs from the solve's `finally`, so on a thrown solve it is the only
+        // thing that will, and a slice directory left behind is frames on what is a tmpfs on plenty of boxes.
+        this.discardAnimatedPlan();
+        if (film)
+            await film.abandon();
+    }
     /** Static or animated, decided by filming once. The film stays running for the branch that uses it. */
     async classifyByRecording(el) {
         // Only on an untouched board: after a click the film cannot tell the board's own motion from our feedback.
@@ -1493,8 +2181,10 @@ class CaptchaKrakenSolver {
             return false;
         return true;
     }
+    /** One second look per solve: a repeated answer arms it, and the recording it takes spends it. */
     shouldRetryAsAnimated(puzzleSource) {
-        return this.repeatedAnswerSeen && puzzleSource !== kinds_1.Vendor.RECAPTCHA && this.config.videoSolveEnabled !== false;
+        return this.repeatedAnswerSeen && !this.animatedProbeDone
+            && puzzleSource !== kinds_1.Vendor.RECAPTCHA && this.config.videoSolveEnabled !== false;
     }
     async getSolution(imagePath, puzzleSource = kinds_1.Vendor.UNKNOWN, retryMode = null, textMode = false) {
         let cacheKey = null;
@@ -1514,7 +2204,7 @@ class CaptchaKrakenSolver {
         const args = (0, cli_invocation_1.buildSolveArgs)({ imagePath, model: this.modelName(cliRoot), puzzleSource, retryMode, textMode, expert: this.config.expert });
         console.log(`Executing CaptchaKraken CLI: ${(0, cli_invocation_1.redactCommand)([py, ...args].join(' '), apiKey)}`);
         try {
-            const { stdout, stderr } = await execFileAsync(py, args, { cwd: cliRoot, env: this.solveEnvironment(cliRoot, apiKey), maxBuffer: 10 * 1024 * 1024 });
+            const { stdout, stderr } = await execFileAsync(py, args, { cwd: cliRoot, env: this.solveEnvironment(cliRoot, apiKey), maxBuffer: 10 * 1024 * 1024, timeout: this.askTimeoutMs(), killSignal: 'SIGKILL' });
             console.log('CaptchaKraken CLI stdout:', stdout);
             if (stderr)
                 console.error('CaptchaKraken CLI stderr:', stderr);
@@ -1560,11 +2250,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.');
@@ -1576,7 +2270,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 };
@@ -1753,10 +2447,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) {
@@ -1778,10 +2472,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;
@@ -1790,12 +2484,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
@@ -1830,7 +2524,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;
@@ -1865,7 +2561,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();
@@ -1938,6 +2634,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);
         }