captchakraken 3.2.0 → 4.0.0

package/dist/selectors.js

@@ -1,121 +1,235 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PIECE_SELECTORS = exports.SLIDER_HANDLE_SELECTORS = exports.TEXT_INPUT_SELECTORS = exports.TEXT_INPUT_VENDOR_SELECTORS = exports.SUBMIT_SELECTORS = exports.submitByText = exports.ACCEPTED_SELECTORS = exports.RESPONSE_SELECTORS = exports.WIDGET_PROBES = exports.VENDORS = exports.SELECTORS = void 0;
+exports.PIECE_SELECTORS = exports.REFRESH_SELECTORS = exports.SLIDER_HANDLE_SELECTORS = exports.TEXT_INPUT_SELECTORS = exports.TEXT_INPUT_VENDOR_SELECTORS = exports.SUBMIT_SELECTORS = exports.ACCEPTED_SELECTORS = exports.RESPONSE_SELECTORS = exports.ENCLAVE_SELECTORS = exports.WIDGET_PROBES = exports.VENDORS = exports.DEFAULT_TABLE = exports.SelectorTable = exports.submitByText = exports.SELECTORS = exports.DEFAULT_CONFIG = exports.DEFAULT_CONFIG_PATH = exports.DETECTOR_MODELS = exports.SelectorConfigError = void 0;
+exports.loadConfig = loadConfig;
 /**
- * Every selector the driver knows, keyed by vendor. Mirrored in python/src/captchakraken/selectors.py; keep both in the
- * same order, because detection takes the first visible match in table order.
+ * Every selector the driver knows, keyed by vendor, read from `captchakraken.config.json` at the repository root. The
+ * Python port reads the same file. Detection takes the first visible match in table order, so the file's order is the
+ * detection order.
  */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const kinds_1 = require("./kinds");
-exports.SELECTORS = {
-    [kinds_1.Vendor.RECAPTCHA]: {
-        hosts: ['google.com/recaptcha', 'recaptcha.net'],
-        challenge: ['iframe[src*="recaptcha/api2/bframe"]'],
-        checkbox: ['iframe[src*="recaptcha/api2/anchor"]:not([src*="size=invisible"])'],
-        response: '[name="g-recaptcha-response"]',
-        checked: '.recaptcha-checkbox-checked',
-        box: ['#recaptcha-anchor'],
-        fresh: '.rc-imageselect-instructions, #rc-imageselect',
-        submit: ['#recaptcha-verify-button'],
-        banners: [
-            ['.rc-imageselect-error-select-more', kinds_1.RecaptchaBanner.SELECT_MORE],
-            ['.rc-imageselect-error-dynamic-more', kinds_1.RecaptchaBanner.DYNAMIC_MORE],
-            ['.rc-imageselect-incorrect-response', kinds_1.RecaptchaBanner.REJECTED],
-        ],
-        blocked: ['.rc-doscaptcha-header-text'],
-        passive: ['iframe[src*="size=invisible"]'],
-    },
-    // Keyed on the `hcaptcha` substring, not the apex host: challenges are served off newassets.hcaptcha.com.
-    [kinds_1.Vendor.HCAPTCHA]: {
-        hosts: ['hcaptcha.com'],
-        challenge: ['iframe[src*="hcaptcha"][src*="frame=challenge"]'],
-        checkbox: ['iframe[src*="hcaptcha"][src*="frame=checkbox"]'],
-        response: '[name="h-captcha-response"]',
-        checked: '#checkbox[aria-checked="true"]',
-        box: ['#checkbox'],
-        fresh: '.prompt-text',
-        images: ['.task-image .image', '.task .image', '.challenge-example img', '.image-wrapper img'],
-        submit: ['.button-submit'],
-    },
-    [kinds_1.Vendor.TURNSTILE]: {
-        hosts: ['challenges.cloudflare.com'],
-        checkbox: ['iframe[src*="challenges.cloudflare.com"]', '.cf-turnstile'],
-        response: '[name="cf-turnstile-response"]',
-    },
-    [kinds_1.Vendor.GEETEST]: {
-        hosts: ['geetest.com'],
-        widget: ['.geetest_box', '.geetest_panel_box', '.geetest_popup_window', '.geetest_widget'],
-        accepted: '.geetest_result_tips.geetest_success, .geetest_captcha.geetest_success, .geetest_captcha.geetest_lock_success',
-        submit: ['.geetest_submit'],
-        sliderHandle: ['.geetest_slider_button', '.geetest_btn', '.geetest_slider .geetest_arrow'],
-        piece: ['.geetest_slice'],
-    },
-    // Both in-page and iframe shapes stay (Tencent moved in-host on 2026-08-11; see TRIBAL_KNOWLEDGE.md), and the iframe id
-    // is prefix-anchored: `[id*=tcaptcha]` also matched MTCaptcha's iframe and hid that `.mtcap` matched nothing.
-    [kinds_1.Vendor.TENCENT]: {
-        hosts: ['captcha.gtimg.com', 'captcha.qcloud.com'],
-        widget: ['#tcaptcha_transform_dy', '#tCaptchaDyContent', '.tencent-captcha-dy__content', 'iframe#tcaptcha_iframe_dy', 'iframe[id^="tcaptcha"]', 'iframe[src*="captcha.gtimg.com"]', 'iframe[src*="captcha.qq.com"]'],
-        sliderHandle: ['.tencent-captcha-dy__slider-block', '#tcaptcha_drag_thumb', '.tc-slider-normal', '[id*=slideBlock]'],
-        piece: ['.tencent-captcha-dy__fg-item'],
-    },
-    [kinds_1.Vendor.YIDUN]: {
-        hosts: ['dun.163.com', 'cstaticdun.126.net', 'necaptcha.nosdn.127.net'],
-        widget: ['.yidun_panel', '.yidun'],
-        sliderHandle: ['.yidun_slider', '.yidun_jigsaw'],
-        piece: ['.yidun_jigsaw'],
-    },
-    [kinds_1.Vendor.YANDEX]: {
-        hosts: ['smartcaptcha.yandexcloud.net'],
-        widget: ['iframe[src*="smartcaptcha.yandexcloud.net/advanced"]', 'iframe[src*="smartcaptcha.yandexcloud.net"]', '.CheckboxCaptcha'],
-        textInput: ['.AdvancedCaptcha-Input input', 'input.Textinput-Control', 'input[name="rep"]'],
-    },
-    [kinds_1.Vendor.LEMIN]: {
-        hosts: ['leminnow.com'],
-        widget: ['#lemin-cropped-captcha', '.lemin-captcha-popup'],
-        sliderHandle: ['.lemin-slider-handle', '#lemin-cropped-captcha .slider'],
-        piece: ['.lemin-cropped-puzzle-piece', '#lemin-cropped-captcha canvas + canvas'],
-    },
-    [kinds_1.Vendor.PROSOPO]: {
-        hosts: ['prosopo.io'],
-        widget: ['.prosopo-modalInner', '.procaptcha-checkbox'],
-    },
-    [kinds_1.Vendor.MTCAPTCHA]: {
-        hosts: ['mtcaptcha.com'],
-        widget: ['iframe[src*="service.mtcaptcha.com"]', 'iframe[id^="mtcaptcha-iframe"]', '.mtcaptcha', '.mtcap'],
-        textInput: ['input.mtcap-inputtext', '.mtcap input[type=text]'],
-    },
-    [kinds_1.Vendor.BOTDETECT]: {
-        hosts: [],
-        widget: ['.BDC_CaptchaDiv'],
-        textInput: ['input[id*=captchaCode]', 'input#captchaCode', 'input[id*=validateCaptcha]', '.BDC_CaptchaDiv input[type=text]'],
-    },
-    [kinds_1.Vendor.UNKNOWN]: { hosts: [] },
-};
-exports.VENDORS = Object.entries(exports.SELECTORS);
-const ofEveryVendor = (key) => exports.VENDORS.flatMap(([, s]) => s[key] ?? []);
-/** Every host-page selector with what it names, in detection order: open challenges, then checkboxes, then inline widgets. */
-exports.WIDGET_PROBES = [
-    [kinds_1.FrameRole.CHALLENGE, 'challenge'], [kinds_1.FrameRole.CHECKBOX, 'checkbox'], [kinds_1.FrameRole.UNKNOWN, 'widget'],
-].flatMap(([role, key]) => exports.VENDORS.flatMap(([vendor, s]) => (s[key] ?? []).map((selector) => ({ vendor, role, selector }))));
-exports.RESPONSE_SELECTORS = exports.VENDORS.flatMap(([, s]) => s.response ?? []);
-exports.ACCEPTED_SELECTORS = exports.VENDORS.flatMap(([, s]) => s.accepted ?? []);
+const model_name_1 = require("./model-name");
+/** A selector config the solver cannot use; the message names the file and the key. */
+class SelectorConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SelectorConfigError';
+    }
+}
+exports.SelectorConfigError = SelectorConfigError;
+/**
+ * The element detector's weights: `lite` keeps a board near 100 ms on one vCPU, `standard` is the larger network, and
+ * `auto` takes `lite` on a machine of two CPUs or fewer, else times one board and takes `standard` when it fits.
+ * `CAPTCHA_KRAKEN_DETECTOR_MODEL` in the environment overrides the config.
+ */
+exports.DETECTOR_MODELS = ['auto', 'standard', 'lite'];
+const GENERIC = ['submit_text', 'text_input', 'slider_handle', 'piece'];
+// The file is spelled as the Python port's fields; these three are camelCase here.
+const CAMEL = { text_input: 'textInput', slider_handle: 'sliderHandle', hold_completes: 'holdCompletes' };
+const FIELDS = ['hosts', 'challenge', 'checkbox', 'enclave', 'widget', 'response', 'checked', 'box', 'accepted', 'fresh',
+    'images', 'submit', 'banners', 'blocked', 'passive', 'text_input', 'slider_handle', 'piece', 'refresh', 'hold_completes'];
+const ONE = new Set(['response', 'checked', 'accepted', 'fresh']);
+const BANNERS = new Set(Object.values(kinds_1.RecaptchaBanner));
+const VENDOR_VALUES = new Set(Object.values(kinds_1.Vendor));
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function strings(where, value) {
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+        throw new SelectorConfigError(`${where}: must be a list of strings`);
+    }
+    return value;
+}
+function entry(where, raw, hostsRequired = true) {
+    if (!isObject(raw))
+        throw new SelectorConfigError(`${where}: must be an object`);
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const at = `${where}.${key}`;
+        if (key === 'note' || key.startsWith('_'))
+            continue;
+        if (!FIELDS.includes(key))
+            throw new SelectorConfigError(`${at}: not a selector field (one of ${FIELDS.join(', ')})`);
+        const name = CAMEL[key] ?? key;
+        if (ONE.has(key)) {
+            if (value !== null && typeof value !== 'string')
+                throw new SelectorConfigError(`${at}: must be one selector string`);
+            if (value !== null)
+                out[name] = value;
+        }
+        else if (key === 'hold_completes') {
+            if (typeof value !== 'boolean')
+                throw new SelectorConfigError(`${at}: must be true or false`);
+            if (value)
+                out[name] = value;
+        }
+        else if (key === 'banners') {
+            if (!Array.isArray(value))
+                throw new SelectorConfigError(`${at}: must be a list of [selector, verdict] pairs`);
+            out[name] = value.map((pair, i) => {
+                if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== 'string') {
+                    throw new SelectorConfigError(`${at}[${i}]: must be a [selector, verdict] pair`);
+                }
+                if (!BANNERS.has(pair[1])) {
+                    throw new SelectorConfigError(`${at}[${i}]: verdict ${JSON.stringify(pair[1])} is not one of ${JSON.stringify([...BANNERS])}`);
+                }
+                return [pair[0], pair[1]];
+            });
+        }
+        else {
+            const list = strings(at, value);
+            if (list.length || key === 'hosts')
+                out[name] = list;
+        }
+    }
+    if (!('hosts' in out)) {
+        if (hostsRequired)
+            throw new SelectorConfigError(`${where}.hosts: missing (an empty list when the vendor has no host of its own)`);
+        out.hosts = [];
+    }
+    return out;
+}
+function parse(name, doc, base) {
+    if (!isObject(doc))
+        throw new SelectorConfigError(`${name}: the top level must be an object`);
+    for (const key of Object.keys(doc)) {
+        if (!key.startsWith('_') && !['detector', 'custom', 'vendors', 'generic'].includes(key)) {
+            throw new SelectorConfigError(`${name}: ${key}: not a config key (detector, custom, vendors, generic)`);
+        }
+    }
+    let detector = base?.detector ?? 'auto';
+    if ('detector' in doc) {
+        if (!exports.DETECTOR_MODELS.includes(doc.detector)) {
+            throw new SelectorConfigError(`${name}: detector: ${JSON.stringify(doc.detector)} is not one of ${exports.DETECTOR_MODELS.join(', ')}`);
+        }
+        detector = doc.detector;
+    }
+    let custom = base?.custom ?? null;
+    if ('custom' in doc)
+        custom = doc.custom === null ? null : entry(`${name}: custom`, doc.custom, false);
+    const rawVendors = doc.vendors ?? {};
+    if (!isObject(rawVendors))
+        throw new SelectorConfigError(`${name}: vendors: must be an object keyed by vendor`);
+    const vendors = new Map(base?.vendors ?? []);
+    for (const [key, raw] of Object.entries(rawVendors)) {
+        if (key.startsWith('_'))
+            continue;
+        if (!VENDOR_VALUES.has(key)) {
+            throw new SelectorConfigError(`${name}: vendors.${key}: not a vendor this solver knows; a captcha of your own goes under \`custom\``);
+        }
+        vendors.set(key, entry(`${name}: vendors.${key}`, raw));
+    }
+    if (!base) {
+        const missing = [...VENDOR_VALUES].filter((v) => !vendors.has(v)).sort();
+        if (missing.length)
+            throw new SelectorConfigError(`${name}: vendors: every vendor must have an entry; missing ${JSON.stringify(missing)}`);
+    }
+    const rawGeneric = doc.generic ?? {};
+    if (!isObject(rawGeneric))
+        throw new SelectorConfigError(`${name}: generic: must be an object`);
+    const generic = { ...(base?.generic ?? {}) };
+    for (const [key, value] of Object.entries(rawGeneric)) {
+        if (key.startsWith('_'))
+            continue;
+        if (!GENERIC.includes(key)) {
+            throw new SelectorConfigError(`${name}: generic.${key}: not a generic list (one of ${GENERIC.join(', ')})`);
+        }
+        generic[key] = strings(`${name}: generic.${key}`, value);
+    }
+    const absent = GENERIC.filter((k) => !generic[k]);
+    if (absent.length)
+        throw new SelectorConfigError(`${name}: generic: missing ${JSON.stringify(absent)}`);
+    return { custom, vendors: [...vendors], generic: generic, detector };
+}
+function read(file) {
+    let text;
+    try {
+        text = node_fs_1.default.readFileSync(file, 'utf-8');
+    }
+    catch (e) {
+        throw new SelectorConfigError(`${file}: cannot be read (${e.message})`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        throw new SelectorConfigError(`${file}: cannot be read as JSON (${e.message})`);
+    }
+}
+/**
+ * The default config: the repository's own `captchakraken.config.json` when this package runs from a checkout, so an
+ * edit there is what the solver reads, else the copy the bundled Python engine ships (an installed package has no
+ * repository root). The Python port resolves the same file.
+ */
+exports.DEFAULT_CONFIG_PATH = (() => {
+    const checkout = node_path_1.default.resolve(__dirname, '..', '..', 'captchakraken.config.json');
+    return node_fs_1.default.existsSync(checkout)
+        ? checkout
+        : node_path_1.default.join((0, model_name_1.getBundledCliRoot)(), 'src', 'captchakraken', 'captchakraken.config.json');
+})();
+/**
+ * The shipped default, or `source` (a path or a parsed object) laid over it: a key it gives replaces the default's
+ * `custom`, one vendor's whole entry, or one generic list. Throws SelectorConfigError naming the bad key.
+ */
+function loadConfig(source) {
+    const base = parse(exports.DEFAULT_CONFIG_PATH, read(exports.DEFAULT_CONFIG_PATH), null);
+    if (source === undefined || (typeof source === 'string' && node_path_1.default.resolve(source) === exports.DEFAULT_CONFIG_PATH))
+        return base;
+    return typeof source === 'string' ? parse(source, read(source), base) : parse('selectors', source, base);
+}
+exports.DEFAULT_CONFIG = loadConfig();
+/** Every vendor's entry, in detection order, as the default config gives it. */
+exports.SELECTORS = Object.fromEntries(exports.DEFAULT_CONFIG.vendors);
 const lower = "translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')";
 /** `.//` keeps the xpath relative so a host-page widget cannot reach the form's own submit. */
 const submitByText = (text) => `xpath=.//button[contains(${lower}, '${text}')] | .//div[@role="button" and contains(${lower}, '${text}')]`;
 exports.submitByText = submitByText;
-/** A real Verify/Next/Submit/Skip first; the vendor-named controls are fallbacks. */
-exports.SUBMIT_SELECTORS = [...['verify', 'next', 'submit', 'skip'].map(exports.submitByText), ...ofEveryVendor('submit')];
-// Vendor-named first, generic last: the driver takes the first visible match, and a generic selector
-// reached before the vendor's own is how a captcha's answer ends up in a login form's username box.
-exports.TEXT_INPUT_VENDOR_SELECTORS = ofEveryVendor('textInput');
-exports.TEXT_INPUT_SELECTORS = [...exports.TEXT_INPUT_VENDOR_SELECTORS,
-    'input[name*="captcha" i]', 'input[id*="captcha" i]', 'input[aria-label*="captcha" i]',
-    'input[placeholder*="code" i]', 'input[autocomplete="off"][type=text]',
-    'input[type=text]', 'input:not([type])', 'input[type=tel]', 'textarea',
-];
-// `[draggable=true]` is absent: HTML5 DnD fires dragstart, not pointermove.
-exports.SLIDER_HANDLE_SELECTORS = [...ofEveryVendor('sliderHandle'),
-    '[role="slider"]', '[aria-valuenow]',
-    '[class*="slider"][class*="btn"]', '[class*="slider"][class*="button"]',
-    '[class*="slide"][class*="handle"]', '[class*="drag"][class*="thumb"]',
-];
-exports.PIECE_SELECTORS = [...ofEveryVendor('piece'), '[class*="puzzle"][class*="piece"]', '[class*="jigsaw"]'];
+const DETECTED_BY = [[kinds_1.FrameRole.CHALLENGE, 'challenge'], [kinds_1.FrameRole.CHECKBOX, 'checkbox'], [kinds_1.FrameRole.UNKNOWN, 'widget']];
+/**
+ * The table one solver detects and drives with: a selector config's vendors, plus its `custom` entry when it has one.
+ * `config` is a path, a parsed object or a loaded SelectorConfig, laid over the shipped default (see `loadConfig`);
+ * `custom` (the older `customSelectors`) replaces the config's own. A custom entry is reported as `Vendor.UNKNOWN` and
+ * searched before the built-in vendors, because the caller wrote it for the page in front of them.
+ */
+class SelectorTable {
+    constructor(custom, config) {
+        const loaded = isLoaded(config) ? config : loadConfig(config);
+        const own = custom ?? loaded.custom ?? undefined;
+        if (own && !DETECTED_BY.some(([, key]) => own[key]?.length)) {
+            throw new SelectorConfigError('custom selectors name nothing to detect: give the entry a `widget`, `challenge` or `checkbox`');
+        }
+        this.config = loaded;
+        this.vendors = own
+            ? [[kinds_1.Vendor.UNKNOWN, { hosts: [], ...own }], ...loaded.vendors.filter(([v]) => v !== kinds_1.Vendor.UNKNOWN)]
+            : loaded.vendors;
+        this.selectors = Object.fromEntries(this.vendors);
+        const every = (key) => this.vendors.flatMap(([, s]) => s[key] ?? []);
+        this.widgetProbes = DETECTED_BY.flatMap(([role, key]) => this.vendors.flatMap(([vendor, s]) => (s[key] ?? []).map((selector) => ({ vendor, role, selector }))));
+        this.enclave = every('enclave');
+        this.response = this.vendors.flatMap(([, s]) => s.response ?? []);
+        this.accepted = this.vendors.flatMap(([, s]) => s.accepted ?? []);
+        this.submit = [...loaded.generic.submit_text.map(exports.submitByText), ...every('submit')];
+        this.textInputVendor = every('textInput');
+        this.textInput = [...this.textInputVendor, ...loaded.generic.text_input];
+        this.sliderHandle = [...every('sliderHandle'), ...loaded.generic.slider_handle];
+        this.refresh = every('refresh');
+        this.piece = [...every('piece'), ...loaded.generic.piece];
+    }
+}
+exports.SelectorTable = SelectorTable;
+const isLoaded = (c) => isObject(c) && Array.isArray(c.vendors) && isObject(c.generic) && 'custom' in c;
+exports.DEFAULT_TABLE = new SelectorTable(undefined, exports.DEFAULT_CONFIG);
+exports.VENDORS = exports.DEFAULT_TABLE.vendors;
+exports.WIDGET_PROBES = exports.DEFAULT_TABLE.widgetProbes;
+exports.ENCLAVE_SELECTORS = exports.DEFAULT_TABLE.enclave;
+exports.RESPONSE_SELECTORS = exports.DEFAULT_TABLE.response;
+exports.ACCEPTED_SELECTORS = exports.DEFAULT_TABLE.accepted;
+exports.SUBMIT_SELECTORS = exports.DEFAULT_TABLE.submit;
+exports.TEXT_INPUT_VENDOR_SELECTORS = exports.DEFAULT_TABLE.textInputVendor;
+exports.TEXT_INPUT_SELECTORS = exports.DEFAULT_TABLE.textInput;
+exports.SLIDER_HANDLE_SELECTORS = exports.DEFAULT_TABLE.sliderHandle;
+exports.REFRESH_SELECTORS = exports.DEFAULT_TABLE.refresh;
+exports.PIECE_SELECTORS = exports.DEFAULT_TABLE.piece;

package/dist/solver.d.ts

@@ -14,6 +14,15 @@ export interface Widget {
     vendor: Vendor;
     role: FrameRole;
 }
+/**
+ * A typed captcha's image and its text box, photographed and pointed into as one element.
+ *
+ * BotDetect's widget element is a 280x50 strip holding only the image; its text box is a sibling. Every training
+ * board and every real capture of a typed captcha shows the box under the image, and on the bare strip the pointer
+ * read the image as a click puzzle or doubled a glyph. The answer's points are taken in this union's frame, so
+ * `boundingBox` is the union everywhere the round reads it; everything else is the element's own.
+ */
+export declare function withAnswerBox(el: ElementHandle, box: ElementHandle): ElementHandle;
 /** An allow-list of what needs nothing: the other direction raises instead of clicking at the origin. */
 export declare function answerNeedsElementBox(actions: ReadonlyArray<{
     action?: string;
@@ -23,6 +32,11 @@ export declare function isStaleHandleError(message: string): boolean;
 /** A closed target is not a stale handle: retried as one, a dead page was re-detected until the loops ran out. */
 export declare function isClosedTargetError(message: string): boolean;
 export declare const INPUT_SETTLE_MS = 400;
+export declare const IDLE_DRIFT_EVERY_MS: readonly [number, number];
+export declare const IDLE_DRIFT_PX = 3;
+export declare const GRID_LOAD_CAP_FACTOR = 3;
+export declare const HOLD_SETTLE_MS = 900;
+export declare const HOLD_MAX_MS = 12000;
 export declare const SOLVE_DEFAULTS: {
     readonly maxSolveLoops: 6;
     readonly overallSolveTimeoutMs: 45000;
@@ -38,6 +52,7 @@ export declare class CaptchaKrakenSolver {
     private videoBudgetMs;
     private videoBudgetGranted;
     private human;
+    private sel;
     private stepIndex;
     private solveStartMs;
     private cvWorker;
@@ -47,6 +62,15 @@ export declare class CaptchaKrakenSolver {
     private cvWorkerBuf;
     /** Answers keyed by screenshot hash; a hit means the answer already ran and changed nothing. */
     private solutionCache;
+    /** The other complete plans the pointer returned for this board, best first; a refresh is last. */
+    private fallbackPlans;
+    /** The screenshot those plans answered. A different board makes them the wrong answer, not an alternative. */
+    private fallbackBoardHash;
+    /** True only once THIS board refused the plan at the front. Nothing is pressed speculatively. */
+    private fallbackArmed;
+    private exchangesAtAnswer;
+    /** Earlier screens of the same paged puzzle (FunCaptcha), oldest first; the CLI sends them as `--history`. */
+    private pointerHistory;
     private repeatedAnswerSeen;
     private knownAnimated;
     private animatedProbeDone;
@@ -56,8 +80,9 @@ export declare class CaptchaKrakenSolver {
     private keyframeSteadyScreens;
     private solveDeadlineAt;
     private lastAnswerSig;
+    private triedAnswers;
+    private refreshedBoards;
     private noProgressRounds;
-    private resampleLevel;
     /** The recording `classifyByRecording` started and left running for the branch below to finish or drop. */
     private pendingBurst;
     /**
@@ -70,6 +95,7 @@ export declare class CaptchaKrakenSolver {
     private animatedFilm;
     private lastBurstFps;
     private actedOnBoard;
+    private submittedOnBoard;
     private lastSubmitFrameHash;
     private solveSessionId;
     /** Which vendor and site this solve is for, sent to the hosted API; the site is a hostname only. */
@@ -134,6 +160,9 @@ export declare class CaptchaKrakenSolver {
     /** The vendor showing its refusal screen: rate-limited or flagged, with no board to answer. */
     private isBlocked;
     /** The env the engine reads its routing headers from: session, and the vendor and site once they are known. */
+    /** This solver's endpoint and key: two solvers in one process may talk to different servers. */
+    private get baseUrl();
+    private get apiKey();
     private routingEnv;
     /** Fire the optional onStep observer with a fresh screenshot; best-effort, never fails the solve. */
     private emitStep;
@@ -150,8 +179,13 @@ export declare class CaptchaKrakenSolver {
      * a closed shadow root, and a frame can refuse access; both are found on screen instead.
      */
     private checkboxBox;
-    /** One capture and OpenCV: a point inside the tick box, in page coordinates. No model is asked. */
+    /**
+     * A point inside the tick box, in page coordinates, or null when the widget passed without drawing one. Turnstile
+     * shows "Verifying…" before its box, so an empty capture is looked at again until `detectionTimeoutMs`.
+     */
     private findCheckboxOnScreen;
+    /** One capture and the element detector, no model: a point inside the tick box, or null when none is drawn. */
+    private checkboxOnScreen;
     /**
      * 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.
@@ -163,7 +197,6 @@ export declare class CaptchaKrakenSolver {
     /** A visible match carrying text; an empty banner or prompt is a placeholder, not a signal. */
     private visibleWithText;
     private checkedIn;
-    private bannerIsFatalAfterRetry;
     /** Which verdict banner the open challenge shows; `dynamic-more` is the dynamic board's normal flow, not an error. */
     private bannerKind;
     /** The vendor's own done signal: a response token, a painted success state, or a checked box. */
@@ -177,7 +210,7 @@ export declare class CaptchaKrakenSolver {
     private waitForBoardImages;
     /** Which vendors' code the page loaded, from resource timing and linked URLs. A tripwire, not a detector. */
     vendorsOnTheWire(page: Page): Promise<Vendor[]>;
-    /** Vendors showing a frame no selector names. Only asked once detection has found nothing, and a passive frame (an invisible badge) is not a widget, so what is left is markup the table no longer matches. */
+    /** 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. */
     private unmatchedVendorFrames;
     private noWidgetMessage;
     /**
@@ -190,7 +223,7 @@ export declare class CaptchaKrakenSolver {
     /** A checkbox the vendor has already accepted is not a captcha to solve. */
     private alreadyAccepted;
     private loraName;
-    /** The `--model` argv, or nothing: without VLLM_BASE_URL the CLI can see a credentials file this process cannot. */
+    /** The `--model` argv, or nothing: without a base URL the CLI can see a credentials file this process cannot. */
     private modelName;
     private resolveCli;
     /** What is LEFT of the solve, as a bound on one ask.
@@ -215,10 +248,18 @@ export declare class CaptchaKrakenSolver {
      * A screenshot that fails ends the poll: the widget is gone or going.
      */
     private pollFrames;
+    /**
+     * Hold the next ask until every tile has painted: a model asked about a half-loaded board answers it.
+     *
+     * Past the timeout a blank tile that has stopped changing is taken as painted (a pale photo, or a tile whose
+     * image never came), and a board with no grid to read is let through. A tile still painting is waited on until
+     * GRID_LOAD_CAP_FACTOR times that, or the solve's deadline.
+     */
     private waitForGridCellsLoaded;
     private getGridBoxes;
     private bboxToCell;
     private cellCenterPage;
+    /** Rest the hand on a tile: reach it once, then drift a few pixels inside it. */
     private hoverCell;
     /** Per-cell state with the session's cached boxes: a blank mid-refresh frame has no lattice to detect. */
     private gridCellStates;
@@ -260,13 +301,27 @@ export declare class CaptchaKrakenSolver {
     private answerRegionRecurs;
     /** Hold until the widget looks like the keyframe around the action point, or the wait is spent. */
     private waitForKeyframe;
+    private dropPointerHistory;
+    /** A click board with no Verify submits itself at a count, so a plan of any other count leaves its tiles ticked
+     *  and never submits, and the next plan's clicks untick them. */
+    private keepPlansOfThisManyClicks;
     private resetSolveState;
-    /** Keyed on the retry mode too: the missed-tiles answer legitimately overlaps the previous one. */
+    /**
+     * Keyed on the BOARD and the retry mode, not the answer alone. A paged puzzle's next arrow sits at the
+     * same point on every page, so a signature over the actions alone would call a correct page turn a
+     * repeated answer and stop pressing it.
+     */
     private static answerSignature;
     /** The recording still stands; dropping only the refused answer makes the retry an inference, not a burst. */
     private invalidateAnimatedAnswer;
-    /** True when this answer already ran and changed nothing: resample, and let the recording path have a go. */
+    /** True when this answer already ran and changed nothing: re-ask, and let the recording path have a go. */
     private noteAnswer;
+    /** Whether the round after a repeat can differ. At temperature 0 the same question gets the same answer, so it
+     *  takes a different question (a retry mode, a film) or one of the model's other plans. */
+    private anotherMoveLeft;
+    private boardStayedSilent;
+    /** The board's identity, always from a plain photograph: a filmed frame of an unchanged board differs in bytes. */
+    private boardHash;
     /** A cache hit costs no inference, and means the answer already ran: the board cycles. */
     private answerFor;
     /**
@@ -305,15 +360,34 @@ export declare class CaptchaKrakenSolver {
     private performSmoothMove;
     /** Element-relative click point: a random spot inside the box, inset 10% off its border. */
     private clickPointFor;
+    /**
+     * The press point of a hold: the model's own point, the middle of its box. A hold can be on a bar narrower than that
+     * box, and a random spot in it lands off the bar, or close enough to its edge that the hand's drift lets go: the
+     * widget then never fills, and the same answer fails the same way.
+     */
+    private holdPointFor;
     /** Park on the target first, so only a mouse-down separates the right screen from the click. */
     private clickWhenFrameMatches;
     private executeClick;
-    private executeDrag;
     /**
-     * The slider piece's box: the first visible match small enough to be a piece. Runs during detection, so it must
-     * not set `actedOnBoard`: marking there disabled `shouldSpeculate` on every slide solve.
+     * Press-and-hold until the widget completes: true when it did, false when the cap ran out. Complete is the vendor's
+     * done signal, the widget closing, or its picture having changed (the fill) and then sat still for HOLD_SETTLE_MS.
+     * When the answer names the fill's line, the fill reaching its end is complete too: see `fillReached`. Except on a
+     * widget that `completesItself` (HUMAN's button): it verifies only once it has shown its done state, and letting go
+     * AT full resets it, so only its own signals end the hold.
+     */
+    private executeHold;
+    /**
+     * One look at a held widget's fill (`fill_tracker.py` behind the CV worker): true once it reaches the answer's `to`,
+     * after waiting out the tracker's `release_in` when the fill arrives between looks.
+     * The first look only shoots the reference, after the press, so the button's own pressed look is not read as fill;
+     * `looks` carries what each later look saw. A look that cannot be shot or read is not a release: the widget's own
+     * signals still end the hold.
      */
-    private measurePieceBox;
+    private fillReached;
+    /** Deal a new puzzle: the vendor's own control, else the model's point on one. False when there is neither. */
+    private executeRefresh;
+    private executeDrag;
     private findControl;
     /**
      * The text box inside the widget, else a vendor-named one in its enclosing fieldset/form, never the page: the generic
@@ -322,8 +396,14 @@ export declare class CaptchaKrakenSolver {
      */
     private answerBox;
     private executeType;
-    private trackPiece;
+    /** One look of the slide loop (`slide_tracker.py` behind the CV worker); null when the part cannot be followed. */
+    private slideStep;
     private shotScale;
-    /** Aim the handle at the slot once, then look and correct until the piece is home. Release is the submit. */
+    /**
+     * Press the handle, nudge it to see what it moves, then steer that part's point onto its target. Release is the submit.
+     * A generation-3 answer names all three points, so nothing is read from the page but pixels. A generation-2 answer
+     * names only the target: its handle comes from the selector table and the part it moves is whatever moved most.
+     * That path goes when the last generation-2 model does.
+     */
     private executeSlide;
 }