captchakraken 2.9.0 → 3.0.0

package/dist/index.d.ts

@@ -1,139 +1,15 @@
 export * from './types';
+export * from './kinds';
 export { CaptchaKrakenSolver } from './solver';
-/**
- * The served LoRA name this client will ask for when `model` is left unset —
- * `CAPTCHA_LORA_NAME`, else `models.json`'s `latest`, else the shipped pin.
- *
- * Exported so anything that REPORTS which adapter was driven can ask the client
- * instead of re-deriving the answer. That distinction is not cosmetic: the name
- * selects the prompt generation, so a reporter that guesses it can disagree with
- * the solver and describe a run that never happened.
- */
+export type { Widget } from './solver';
 export { resolveLoraName } from './model-name';
-/**
- * Errors raised when the **hosted** CaptchaKraken API refuses a solve — out of
- * credits, rate limited, key rejected, attempt abandoned.
- *
- * `message` is already a complete sentence naming the product and, where one
- * exists, the URL that fixes it, so printing it is enough. `code` is the stable
- * contract to branch on; the prose is not.
- *
- * @example
- * ```typescript
- * import { CaptchaKrakenSolver, CaptchaKrakenAPIError } from 'captchakraken';
- *
- * try {
- *   await solver.solve(page);
- * } catch (e) {
- *   if (e instanceof CaptchaKrakenAPIError && e.code === 'insufficient_credits') {
- *     console.error(`Top up: ${e.resolutionUrl}`);
- *   } else throw e;
- * }
- * ```
- */
 export { CaptchaKrakenAPIError } from './errors';
 export type { CaptchaKrakenErrorCode } from './errors';
-/**
- * Adapter for driving the solver with **Puppeteer** instead of a Playwright
- * launcher. Puppeteer's `Page` is API-compatible with Playwright's except for a
- * few method names/options; `fromPuppeteer(page)` wraps it so `solve()` accepts
- * it. Playwright-family launchers (vanilla `playwright`, `patchright`,
- * `camoufox-js`) need no adapter — pass their `Page` directly.
- *
- * @example
- * ```typescript
- * import puppeteer from 'puppeteer';
- * import { CaptchaKrakenSolver, fromPuppeteer } from 'captchakraken';
- *
- * const browser = await puppeteer.launch({ headless: false });
- * const page = await browser.newPage();
- * await page.goto('https://www.google.com/recaptcha/api2/demo');
- *
- * const solver = new CaptchaKrakenSolver();
- * await solver.solve(fromPuppeteer(page));
- * await browser.close();
- * ```
- */
 export { fromPuppeteer } from './puppeteer-adapter';
-/**
- * The Playwright `Page` type the solver operates on.
- *
- * This is an implementation-neutral, structurally-typed Playwright `Page` — a
- * duck-typed surface defined by this package, NOT imported from any browser
- * library. The package depends on no concrete browser implementation, so you
- * can drive the solver with ANY Playwright-compatible launcher: vanilla
- * `playwright`, `patchright`, `camoufox-js`, or anything else that hands back a
- * standard Playwright `Page`. They all structurally satisfy this type — pass
- * yours directly, no cast needed.
- *
- * @example
- * ```typescript
- * // Pick whichever Playwright-compatible launcher you want — install it
- * // yourself; this package does not bundle a browser:
- * import { chromium } from 'playwright';          // vanilla
- * // import { chromium } from 'patchright';       // stealth-patched
- * // import { Camoufox } from 'camoufox-js';      // Firefox stealth
- * import { CaptchaKrakenSolver } from 'captchakraken';
- *
- * const browser = await chromium.launch({ headless: false });
- * const page = await (await browser.newContext()).newPage();
- * await page.goto('https://www.google.com/recaptcha/api2/demo');
- *
- * // Reads VLLM_BASE_URL + CAPTCHA_KRAKEN_API_KEY from the environment.
- * const solver = new CaptchaKrakenSolver();
- * await solver.solve(page);   // detect → solve grid → click → verify
- *
- * await browser.close();
- * ```
- */
-export type { Page, PlaywrightPage, PlaywrightFrame, PlaywrightElementHandle } from './playwright-types';
-/**
- * Auto-solve watcher: `solver.watch(page)` installs a background poller that
- * solves captchas as they appear, and returns a handle with `stop()`.
- *
- * Injects nothing into the page, on any platform — see watcher.ts. On Camoufox
- * its DOM reads run in the isolated Juggler world by default.
- *
- * @example
- * ```typescript
- * const solver = new CaptchaKrakenSolver();
- * const watcher = solver.watch(page, { onSolved: r => console.log(r.isSolved) });
- * // ... your automation ...
- * await watcher.stop();
- * ```
- */
+export type { Page, PlaywrightPage, PlaywrightFrame, PlaywrightElementHandle, PlaywrightLocator, PlaywrightScope } from './playwright-types';
+export { SELECTORS } from './selectors';
+export type { VendorSelectors } from './selectors';
 export { watchPage } from './watcher';
 export type { CaptchaWatcher, WatchOptions, WatchableSolver } from './watcher';
-/**
- * Humanisation: how the driver moves. `humanization: 'mouse' | 'mobile' |
- * 'none'` picks a built-in; `humanizer` takes one of your own.
- *
- * `MobileHumanizer` emits real touch events with finger kinematics, through a
- * `TouchBackend` — CDP against a Chromium-family page, or W3C pointer actions
- * against an Appium / WebdriverIO driver on a real handset.
- *
- * @example Mobile emulation in the browser
- * ```typescript
- * import { chromium, devices } from 'playwright';
- * import { CaptchaKrakenSolver } from 'captchakraken';
- *
- * const browser = await chromium.launch();
- * const context = await browser.newContext({ ...devices['Pixel 7'], hasTouch: true });
- * const page = await context.newPage();
- * await page.goto('https://example.com/signup');
- *
- * await new CaptchaKrakenSolver({ humanization: 'mobile' }).solve(page);
- * ```
- *
- * @example A real device over Appium
- * ```typescript
- * const solver = new CaptchaKrakenSolver({
- *   humanization: 'mobile',
- *   touchDriver: driver,                                  // the WebdriverIO browser
- *   touchTransform: { scale: 3, origin: [0, 132] },       // CSS px -> screen px
- * });
- * await solver.solve(page);
- * ```
- */
 export { MouseHumanizer, MobileHumanizer, NullHumanizer, BaseHumanizer, resolveHumanizer, touchBackendFor, CdpTouchBackend, AppiumTouchBackend, TouchscreenTouchBackend, PAUSE_KINDS, MODES as HUMANIZATION_MODES, } from './humanize';
 export type { Humanizer, HumanizationMode, HumanizerOptions, TouchBackend, TouchSample, TouchTransform, PauseKind, } from './humanize';

package/dist/index.js

@@ -14,115 +14,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HUMANIZATION_MODES = exports.PAUSE_KINDS = exports.TouchscreenTouchBackend = exports.AppiumTouchBackend = exports.CdpTouchBackend = exports.touchBackendFor = exports.resolveHumanizer = exports.BaseHumanizer = exports.NullHumanizer = exports.MobileHumanizer = exports.MouseHumanizer = exports.watchPage = exports.fromPuppeteer = exports.CaptchaKrakenAPIError = exports.resolveLoraName = exports.CaptchaKrakenSolver = void 0;
+exports.HUMANIZATION_MODES = exports.PAUSE_KINDS = exports.TouchscreenTouchBackend = exports.AppiumTouchBackend = exports.CdpTouchBackend = exports.touchBackendFor = exports.resolveHumanizer = exports.BaseHumanizer = exports.NullHumanizer = exports.MobileHumanizer = exports.MouseHumanizer = exports.watchPage = exports.SELECTORS = exports.fromPuppeteer = exports.CaptchaKrakenAPIError = exports.resolveLoraName = exports.CaptchaKrakenSolver = void 0;
 __exportStar(require("./types"), exports);
+__exportStar(require("./kinds"), exports);
 var solver_1 = require("./solver");
 Object.defineProperty(exports, "CaptchaKrakenSolver", { enumerable: true, get: function () { return solver_1.CaptchaKrakenSolver; } });
-/**
- * The served LoRA name this client will ask for when `model` is left unset —
- * `CAPTCHA_LORA_NAME`, else `models.json`'s `latest`, else the shipped pin.
- *
- * Exported so anything that REPORTS which adapter was driven can ask the client
- * instead of re-deriving the answer. That distinction is not cosmetic: the name
- * selects the prompt generation, so a reporter that guesses it can disagree with
- * the solver and describe a run that never happened.
- */
 var model_name_1 = require("./model-name");
 Object.defineProperty(exports, "resolveLoraName", { enumerable: true, get: function () { return model_name_1.resolveLoraName; } });
-/**
- * Errors raised when the **hosted** CaptchaKraken API refuses a solve — out of
- * credits, rate limited, key rejected, attempt abandoned.
- *
- * `message` is already a complete sentence naming the product and, where one
- * exists, the URL that fixes it, so printing it is enough. `code` is the stable
- * contract to branch on; the prose is not.
- *
- * @example
- * ```typescript
- * import { CaptchaKrakenSolver, CaptchaKrakenAPIError } from 'captchakraken';
- *
- * try {
- *   await solver.solve(page);
- * } catch (e) {
- *   if (e instanceof CaptchaKrakenAPIError && e.code === 'insufficient_credits') {
- *     console.error(`Top up: ${e.resolutionUrl}`);
- *   } else throw e;
- * }
- * ```
- */
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "CaptchaKrakenAPIError", { enumerable: true, get: function () { return errors_1.CaptchaKrakenAPIError; } });
-/**
- * Adapter for driving the solver with **Puppeteer** instead of a Playwright
- * launcher. Puppeteer's `Page` is API-compatible with Playwright's except for a
- * few method names/options; `fromPuppeteer(page)` wraps it so `solve()` accepts
- * it. Playwright-family launchers (vanilla `playwright`, `patchright`,
- * `camoufox-js`) need no adapter — pass their `Page` directly.
- *
- * @example
- * ```typescript
- * import puppeteer from 'puppeteer';
- * import { CaptchaKrakenSolver, fromPuppeteer } from 'captchakraken';
- *
- * const browser = await puppeteer.launch({ headless: false });
- * const page = await browser.newPage();
- * await page.goto('https://www.google.com/recaptcha/api2/demo');
- *
- * const solver = new CaptchaKrakenSolver();
- * await solver.solve(fromPuppeteer(page));
- * await browser.close();
- * ```
- */
 var puppeteer_adapter_1 = require("./puppeteer-adapter");
 Object.defineProperty(exports, "fromPuppeteer", { enumerable: true, get: function () { return puppeteer_adapter_1.fromPuppeteer; } });
-/**
- * Auto-solve watcher: `solver.watch(page)` installs a background poller that
- * solves captchas as they appear, and returns a handle with `stop()`.
- *
- * Injects nothing into the page, on any platform — see watcher.ts. On Camoufox
- * its DOM reads run in the isolated Juggler world by default.
- *
- * @example
- * ```typescript
- * const solver = new CaptchaKrakenSolver();
- * const watcher = solver.watch(page, { onSolved: r => console.log(r.isSolved) });
- * // ... your automation ...
- * await watcher.stop();
- * ```
- */
+var selectors_1 = require("./selectors");
+Object.defineProperty(exports, "SELECTORS", { enumerable: true, get: function () { return selectors_1.SELECTORS; } });
 var watcher_1 = require("./watcher");
 Object.defineProperty(exports, "watchPage", { enumerable: true, get: function () { return watcher_1.watchPage; } });
-/**
- * Humanisation: how the driver moves. `humanization: 'mouse' | 'mobile' |
- * 'none'` picks a built-in; `humanizer` takes one of your own.
- *
- * `MobileHumanizer` emits real touch events with finger kinematics, through a
- * `TouchBackend` — CDP against a Chromium-family page, or W3C pointer actions
- * against an Appium / WebdriverIO driver on a real handset.
- *
- * @example Mobile emulation in the browser
- * ```typescript
- * import { chromium, devices } from 'playwright';
- * import { CaptchaKrakenSolver } from 'captchakraken';
- *
- * const browser = await chromium.launch();
- * const context = await browser.newContext({ ...devices['Pixel 7'], hasTouch: true });
- * const page = await context.newPage();
- * await page.goto('https://example.com/signup');
- *
- * await new CaptchaKrakenSolver({ humanization: 'mobile' }).solve(page);
- * ```
- *
- * @example A real device over Appium
- * ```typescript
- * const solver = new CaptchaKrakenSolver({
- *   humanization: 'mobile',
- *   touchDriver: driver,                                  // the WebdriverIO browser
- *   touchTransform: { scale: 3, origin: [0, 132] },       // CSS px -> screen px
- * });
- * await solver.solve(page);
- * ```
- */
 var humanize_1 = require("./humanize");
 Object.defineProperty(exports, "MouseHumanizer", { enumerable: true, get: function () { return humanize_1.MouseHumanizer; } });
 Object.defineProperty(exports, "MobileHumanizer", { enumerable: true, get: function () { return humanize_1.MobileHumanizer; } });

package/dist/kinds.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Every closed set of names the two ports agree on. Mirrored in python/src/captchakraken/kinds.py; keep both in the same order.
+ * `as const` objects rather than `enum`: a literal off the wire (`'click'`) type-checks against them, an `enum` would not.
+ */
+/** `puzzleSource` everywhere. UNKNOWN must stay permissive: GeeTest and Prosopo report it, and so does the offline grader. */
+export declare const Vendor: {
+    readonly HCAPTCHA: "hcaptcha";
+    readonly RECAPTCHA: "recaptcha";
+    readonly TURNSTILE: "turnstile";
+    readonly GEETEST: "geetest";
+    readonly TENCENT: "tencent";
+    readonly YIDUN: "yidun";
+    readonly YANDEX: "yandex";
+    readonly LEMIN: "lemin";
+    readonly PROSOPO: "prosopo";
+    readonly MTCAPTCHA: "mtcaptcha";
+    readonly BOTDETECT: "botdetect";
+    readonly UNKNOWN: "unknown";
+};
+export type Vendor = (typeof Vendor)[keyof typeof Vendor];
+export declare const ActionKind: {
+    readonly CLICK: "click";
+    readonly DRAG: "drag";
+    readonly TYPE: "type";
+    readonly WAIT: "wait";
+    readonly DONE: "done";
+};
+export type ActionKind = (typeof ActionKind)[keyof typeof ActionKind];
+export declare const RetryMode: {
+    readonly MISSED_TILES: "missed-tiles";
+};
+export type RetryMode = (typeof RetryMode)[keyof typeof RetryMode];
+export declare const SettleVerdict: {
+    readonly SETTLED: "settled";
+    readonly ANIMATED: "animated";
+    readonly TIMEOUT: "timeout";
+};
+export type SettleVerdict = (typeof SettleVerdict)[keyof typeof SettleVerdict];
+export declare const PaintVerdict: {
+    readonly PAINTED: "painted";
+    readonly BLANK: "blank";
+    readonly UNKNOWN: "unknown";
+};
+export type PaintVerdict = (typeof PaintVerdict)[keyof typeof PaintVerdict];
+/** EVEN means the slicer could not prove recurrence, not that the board is still. */
+export declare const KeyframeMode: {
+    readonly STATIC: "static";
+    readonly CYCLE: "cycle";
+    readonly EVEN: "even";
+};
+export type KeyframeMode = (typeof KeyframeMode)[keyof typeof KeyframeMode];
+export declare const RecaptchaBanner: {
+    readonly SELECT_MORE: "select-more";
+    readonly DYNAMIC_MORE: "dynamic-more";
+    readonly REJECTED: "rejected";
+};
+export type RecaptchaBanner = (typeof RecaptchaBanner)[keyof typeof RecaptchaBanner];
+/** One expert per family; `pixel` is spelled to match ckgate's prompt markers. */
+export declare const PromptFamily: {
+    readonly PIXEL: "pixel";
+    readonly GRID: "grid";
+    readonly VIDEO: "video";
+    readonly TEXT: "text";
+};
+export type PromptFamily = (typeof PromptFamily)[keyof typeof PromptFamily];
+export declare const HumanizationMode: {
+    readonly MOUSE: "mouse";
+    readonly MOBILE: "mobile";
+    readonly NONE: "none";
+};
+export type HumanizationMode = (typeof HumanizationMode)[keyof typeof HumanizationMode];
+export declare const PauseKind: {
+    readonly TAP: "tap";
+    readonly BETWEEN: "between";
+    readonly GRAB: "grab";
+    readonly DROP: "drop";
+    readonly PROBE: "probe";
+    readonly SETTLE: "settle";
+    readonly KEY: "key";
+};
+export type PauseKind = (typeof PauseKind)[keyof typeof PauseKind];
+export declare const Outcome: {
+    readonly SOLVED: "solved";
+    readonly FAILED: "failed";
+};
+export type Outcome = (typeof Outcome)[keyof typeof Outcome];
+/** Timing phases. Only INFERENCE and MOUSE are productive; everything else is waiting. */
+export declare const Phase: {
+    readonly INFERENCE: "inference";
+    readonly MOUSE: "mouse";
+    readonly SCREENSHOT: "screenshot";
+    readonly DETECT: "detect";
+    readonly SETTLE: "settle";
+    readonly BURST: "burst";
+    readonly GRID: "grid";
+    readonly GRID_LOAD: "grid-load";
+    readonly FADE_WAIT: "fade-wait";
+    readonly BOARD_PAINT: "board-paint";
+    readonly HCAPTCHA_IMAGES: "hcaptcha-images";
+    readonly AWAIT_NEXT_ROUND: "await-next-round";
+    readonly AWAIT_VERDICT: "await-verdict";
+    readonly POST_SUBMIT_DELAY: "post-submit-delay";
+};
+export type Phase = (typeof Phase)[keyof typeof Phase];
+export declare const SolveStage: {
+    readonly INITIAL: "initial";
+    readonly CLICK: "click";
+    readonly DRAG: "drag";
+    readonly TYPE: "type";
+    readonly WAIT: "wait";
+    readonly SUBMIT: "submit";
+    readonly ROUND: "round";
+};
+export type SolveStage = (typeof SolveStage)[keyof typeof SolveStage];
+export declare const FrameRole: {
+    readonly CHECKBOX: "checkbox";
+    readonly CHALLENGE: "challenge";
+    readonly UNKNOWN: "unknown";
+};
+export type FrameRole = (typeof FrameRole)[keyof typeof FrameRole];
+/** The hosted API's machine-readable codes. Unknown codes still carry the server's message through; this is not a filter. */
+export declare const ErrorCode: {
+    readonly MISSING_API_KEY: "missing_api_key";
+    readonly INVALID_API_KEY: "invalid_api_key";
+    readonly ACCOUNT_SUSPENDED: "account_suspended";
+    readonly INSUFFICIENT_CREDITS: "insufficient_credits";
+    readonly RATE_LIMITED: "rate_limited";
+    readonly SOLVE_ABANDONED: "solve_abandoned";
+    readonly UNRECOGNIZED_PROMPT: "unrecognized_prompt";
+    readonly INVALID_REQUEST: "invalid_request";
+    readonly REQUEST_TOO_LARGE: "request_too_large";
+    readonly UPSTREAM_UNAVAILABLE: "upstream_unavailable";
+};
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+export declare function isOneOf<T extends Record<string, string>>(set: T, value: unknown): value is T[keyof T];

package/dist/kinds.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Every closed set of names the two ports agree on. Mirrored in python/src/captchakraken/kinds.py; keep both in the same order.
+ * `as const` objects rather than `enum`: a literal off the wire (`'click'`) type-checks against them, an `enum` would not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.FrameRole = exports.SolveStage = exports.Phase = exports.Outcome = exports.PauseKind = exports.HumanizationMode = exports.PromptFamily = exports.RecaptchaBanner = exports.KeyframeMode = exports.PaintVerdict = exports.SettleVerdict = exports.RetryMode = exports.ActionKind = exports.Vendor = void 0;
+exports.isOneOf = isOneOf;
+/** `puzzleSource` everywhere. UNKNOWN must stay permissive: GeeTest and Prosopo report it, and so does the offline grader. */
+exports.Vendor = {
+    HCAPTCHA: 'hcaptcha',
+    RECAPTCHA: 'recaptcha',
+    TURNSTILE: 'turnstile',
+    GEETEST: 'geetest',
+    TENCENT: 'tencent',
+    YIDUN: 'yidun',
+    YANDEX: 'yandex',
+    LEMIN: 'lemin',
+    PROSOPO: 'prosopo',
+    MTCAPTCHA: 'mtcaptcha',
+    BOTDETECT: 'botdetect',
+    UNKNOWN: 'unknown',
+};
+exports.ActionKind = { CLICK: 'click', DRAG: 'drag', TYPE: 'type', WAIT: 'wait', DONE: 'done' };
+exports.RetryMode = { MISSED_TILES: 'missed-tiles' };
+exports.SettleVerdict = { SETTLED: 'settled', ANIMATED: 'animated', TIMEOUT: 'timeout' };
+exports.PaintVerdict = { PAINTED: 'painted', BLANK: 'blank', UNKNOWN: 'unknown' };
+/** EVEN means the slicer could not prove recurrence, not that the board is still. */
+exports.KeyframeMode = { STATIC: 'static', CYCLE: 'cycle', EVEN: 'even' };
+exports.RecaptchaBanner = { SELECT_MORE: 'select-more', DYNAMIC_MORE: 'dynamic-more', REJECTED: 'rejected' };
+/** One expert per family; `pixel` is spelled to match ckgate's prompt markers. */
+exports.PromptFamily = { PIXEL: 'pixel', GRID: 'grid', VIDEO: 'video', TEXT: 'text' };
+exports.HumanizationMode = { MOUSE: 'mouse', MOBILE: 'mobile', NONE: 'none' };
+exports.PauseKind = { TAP: 'tap', BETWEEN: 'between', GRAB: 'grab', DROP: 'drop', PROBE: 'probe', SETTLE: 'settle', KEY: 'key' };
+exports.Outcome = { SOLVED: 'solved', FAILED: 'failed' };
+/** Timing phases. Only INFERENCE and MOUSE are productive; everything else is waiting. */
+exports.Phase = {
+    INFERENCE: 'inference',
+    MOUSE: 'mouse',
+    SCREENSHOT: 'screenshot',
+    DETECT: 'detect',
+    SETTLE: 'settle',
+    BURST: 'burst',
+    GRID: 'grid',
+    GRID_LOAD: 'grid-load',
+    FADE_WAIT: 'fade-wait',
+    BOARD_PAINT: 'board-paint',
+    HCAPTCHA_IMAGES: 'hcaptcha-images',
+    AWAIT_NEXT_ROUND: 'await-next-round',
+    AWAIT_VERDICT: 'await-verdict',
+    POST_SUBMIT_DELAY: 'post-submit-delay',
+};
+exports.SolveStage = { INITIAL: 'initial', CLICK: 'click', DRAG: 'drag', TYPE: 'type', WAIT: 'wait', SUBMIT: 'submit', ROUND: 'round' };
+exports.FrameRole = { CHECKBOX: 'checkbox', CHALLENGE: 'challenge', UNKNOWN: 'unknown' };
+/** The hosted API's machine-readable codes. Unknown codes still carry the server's message through; this is not a filter. */
+exports.ErrorCode = {
+    MISSING_API_KEY: 'missing_api_key',
+    INVALID_API_KEY: 'invalid_api_key',
+    ACCOUNT_SUSPENDED: 'account_suspended',
+    INSUFFICIENT_CREDITS: 'insufficient_credits',
+    RATE_LIMITED: 'rate_limited',
+    SOLVE_ABANDONED: 'solve_abandoned',
+    UNRECOGNIZED_PROMPT: 'unrecognized_prompt',
+    INVALID_REQUEST: 'invalid_request',
+    REQUEST_TOO_LARGE: 'request_too_large',
+    UPSTREAM_UNAVAILABLE: 'upstream_unavailable',
+};
+function isOneOf(set, value) {
+    return typeof value === 'string' && Object.values(set).includes(value);
+}

package/dist/limits.d.ts

@@ -1,51 +1,3 @@
-/**
- * Numbers that must agree with the hosted gateway, stated once.
- *
- * These are not arbitrary defaults. They sit inside an ordering the server
- * enforces, and the ordering — not any individual value — is the property worth
- * protecting. `limits.test.ts` pins it.
- */
-/**
- * The server bills at most this many responses per captcha attempt.
- *
- * Mirrors `MAX_BILLABLE_ROUNDS_PER_SESSION` in captchakraken-gateway's
- * `src/pricing.ts`. Declared here so the ordering below can be asserted; the
- * gateway is what actually enforces it.
- */
 export declare const SERVER_MAX_BILLABLE_ROUNDS = 5;
-/**
- * The server answers at most this many responses per attempt, then refuses the
- * eleventh with 409 `solve_abandoned`.
- *
- * Mirrors `MAX_ROUNDS_PER_SESSION` in the gateway.
- */
 export declare const SERVER_MAX_SERVED_ROUNDS = 10;
-/**
- * How many click → refresh → re-solve rounds the client will attempt on one
- * reCAPTCHA 3x3 dynamic puzzle.
- *
- * ── WHY 8, AND WHY IT MUST STAY STRICTLY BETWEEN 5 AND 10 ───────────────────
- *
- * The three numbers describe one attempt in three stages:
- *
- *     rounds 1–5     billed
- *     rounds 6–10    served, and comped
- *     round 11       refused — 409, the attempt is over
- *
- * 8 sits strictly inside that, with room on both sides, and both margins do a
- * job:
- *
- *   Above 5 — rounds 6, 7 and 8 are free. A puzzle that needs a couple of extra
- *   passes still gets them, and the customer is not charged for our model
- *   needing another look. Dropping to 5 would abandon winnable puzzles at
- *   exactly the point where continuing costs the customer nothing.
- *
- *   Below 10 — a well-behaved client gives up BEFORE the server refuses it.
- *   Raising this to 10 or beyond means the normal end of a hard puzzle is a
- *   409 rather than a clean local stop, which turns an ordinary outcome into an
- *   error the caller has to interpret.
- *
- * So: if the billable cap moves, re-derive this and move the test in the same
- * commit. Changing one number alone silently breaks one of the two margins.
- */
 export declare const DEFAULT_RECAPTCHA_MAX_DYNAMIC_ROUNDS = 8;

package/dist/limits.js

@@ -1,54 +1,8 @@
 "use strict";
-/**
- * Numbers that must agree with the hosted gateway, stated once.
- *
- * These are not arbitrary defaults. They sit inside an ordering the server
- * enforces, and the ordering — not any individual value — is the property worth
- * protecting. `limits.test.ts` pins it.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_RECAPTCHA_MAX_DYNAMIC_ROUNDS = exports.SERVER_MAX_SERVED_ROUNDS = exports.SERVER_MAX_BILLABLE_ROUNDS = void 0;
-/**
- * The server bills at most this many responses per captcha attempt.
- *
- * Mirrors `MAX_BILLABLE_ROUNDS_PER_SESSION` in captchakraken-gateway's
- * `src/pricing.ts`. Declared here so the ordering below can be asserted; the
- * gateway is what actually enforces it.
- */
+// The gateway's three tiers: rounds 1-5 are billed, 6-10 are served and comped, and the 11th is refused with 409.
 exports.SERVER_MAX_BILLABLE_ROUNDS = 5;
-/**
- * The server answers at most this many responses per attempt, then refuses the
- * eleventh with 409 `solve_abandoned`.
- *
- * Mirrors `MAX_ROUNDS_PER_SESSION` in the gateway.
- */
 exports.SERVER_MAX_SERVED_ROUNDS = 10;
-/**
- * How many click → refresh → re-solve rounds the client will attempt on one
- * reCAPTCHA 3x3 dynamic puzzle.
- *
- * ── WHY 8, AND WHY IT MUST STAY STRICTLY BETWEEN 5 AND 10 ───────────────────
- *
- * The three numbers describe one attempt in three stages:
- *
- *     rounds 1–5     billed
- *     rounds 6–10    served, and comped
- *     round 11       refused — 409, the attempt is over
- *
- * 8 sits strictly inside that, with room on both sides, and both margins do a
- * job:
- *
- *   Above 5 — rounds 6, 7 and 8 are free. A puzzle that needs a couple of extra
- *   passes still gets them, and the customer is not charged for our model
- *   needing another look. Dropping to 5 would abandon winnable puzzles at
- *   exactly the point where continuing costs the customer nothing.
- *
- *   Below 10 — a well-behaved client gives up BEFORE the server refuses it.
- *   Raising this to 10 or beyond means the normal end of a hard puzzle is a
- *   409 rather than a clean local stop, which turns an ordinary outcome into an
- *   error the caller has to interpret.
- *
- * So: if the billable cap moves, re-derive this and move the test in the same
- * commit. Changing one number alone silently breaks one of the two margins.
- */
+// Inside the comped band with margin on both sides. If the billable cap moves, re-derive this and move limits.test.ts in the same commit.
 exports.DEFAULT_RECAPTCHA_MAX_DYNAMIC_ROUNDS = 8;

package/dist/model-name.d.ts

@@ -1,23 +1,8 @@
-/**
- * Where the bundled Python engine lives — the copy of `models.json` this client
- * actually answers from.
- *
- * Lives HERE rather than in solver.ts because the registry lookup below is its
- * only remaining caller-visible use, and a second copy of this path logic is
- * how the two ports drifted apart in the first place. solver.ts imports it.
- *
- * When installed from npm this file is in `<pkgRoot>/dist` (compiled) or
- * `<pkgRoot>/src` (dev), and published packages bundle the engine at
- * `<pkgRoot>/python` (copied in by scripts/copy-python.mjs at build time). In
- * the source development checkout it instead lives at the sibling `../python`.
- */
 export declare function getBundledCliRoot(): string;
-/**
- * `cliRoot` is optional so a caller that only wants to REPORT the name — a test
- * harness recording which adapter it drove — can ask without reconstructing the
- * engine's layout. Re-deriving it is the same mistake one level down.
- */
-export declare function resolveLoraName({ cliRoot, env }?: {
+export declare function isHostedEndpoint(baseUrl: string | undefined, env?: NodeJS.ProcessEnv): boolean;
+/** Hosted: the routing alias, not an arm's `lora_name`, because a routed mixture is several names and only the alias routes. A missing or broken registry falls through to the pin, never throws. */
+export declare function resolveLoraName({ cliRoot, env, baseUrl }?: {
     cliRoot?: string;
     env?: NodeJS.ProcessEnv;
+    baseUrl?: string;
 }): string;