scrapely 1.2.18 → 1.2.20

package/dist/actor.d.ts

@@ -21,6 +21,7 @@ import { type ApiStorageConfig } from './storage/api-storage-client.js';
 import { ChargingManager, type ChargeOptions as ChargingChargeOptions, type ChargeResult as ChargingChargeResult } from './charging.js';
 import { createProxyConfiguration, type CreateProxyConfigurationOptions } from './proxy-configuration.js';
 import { type BrowserConfiguration, type BrowserConfigurationOptions } from './browser-configuration.js';
+import { type Clearance, type SolveOptions, type SolverVendorStatus } from './solver.js';
 import type { Dataset, KeyValueStore, RequestQueue } from 'crawlee';
 /** User function passed to {@link Actor.main} (Apify-compatible). */
 export type UserFunc<T = unknown> = () => T | Promise<T>;
@@ -530,6 +531,25 @@ export declare class Actor {
      * @returns The updated ActorRun object, or an empty object if running locally
      */
     static setStatusMessage(message: string, options?: SetStatusMessageOptions): Promise<ActorRun>;
+    /**
+     * Anti-bot solver status for a vendor (free, cached for 15 s, never throws).
+     * `usable: false` means the vendor cannot be solved right now: take your
+     * fallback (for example the hosted browser), or fail the items that need a
+     * solve at once and call `setSolverDegradedStatus()`.
+     */
+    static solverStatus(vendor: string): Promise<SolverVendorStatus>;
+    /**
+     * Solves one anti-bot challenge on the Actor's own session through the
+     * platform solver. See `solve` in `scrapely` (solver.ts) for the options.
+     */
+    static solve(options: SolveOptions): Promise<Clearance>;
+    /**
+     * Sets the standard status message for a run whose site protection cannot
+     * be solved right now ("Site protection temporarily unavailable, results
+     * may be incomplete", plus "(N of M items skipped)" when both counts are
+     * given). Never throws: the run goes on.
+     */
+    static setSolverDegradedStatus(skipped?: number, total?: number): Promise<void>;
     /**
      * Creates a proxy configuration and returns a promise resolving to an instance
      * of the ProxyConfiguration class that is already initialized.

package/dist/actor.js

@@ -33,6 +33,7 @@ const charging_client_js_1 = require("./charging_client.js");
 const proxy_configuration_js_1 = require("./proxy-configuration.js");
 const browser_configuration_js_1 = require("./browser-configuration.js");
 const utils_js_1 = require("./utils.js");
+const solver_js_1 = require("./solver.js");
 /** "429 Run API rate limit exceeded ..." for an API error, the message otherwise. */
 function describeRunApiError(err) {
     const status = err.statusCode;
@@ -1062,9 +1063,46 @@ class Actor {
             label: 'PUT status message',
             retryWindowMs: options?.retryWindowMs,
         }, async (response) => (await response.json().catch(() => ({})))).catch((err) => {
-            throw new Error(`Failed to update status message: ${describeRunApiError(err)}`);
+            const error = new Error(`Failed to update status message: ${describeRunApiError(err)}`);
+            // A progress update is best effort: if the API still fails after the
+            // retry window (e.g. a long 503), log it and carry on instead of
+            // crashing the run. Terminal updates keep throwing.
+            if (isStatusMessageTerminal)
+                throw error;
+            console.warn(`[Scrapely] ${error.message} (continuing)`);
+            return undefined;
         });
-        return (body.data ?? {});
+        return (body?.data ?? {});
+    }
+    /**
+     * Anti-bot solver status for a vendor (free, cached for 15 s, never throws).
+     * `usable: false` means the vendor cannot be solved right now: take your
+     * fallback (for example the hosted browser), or fail the items that need a
+     * solve at once and call `setSolverDegradedStatus()`.
+     */
+    static async solverStatus(vendor) {
+        return (0, solver_js_1.solverStatus)(vendor);
+    }
+    /**
+     * Solves one anti-bot challenge on the Actor's own session through the
+     * platform solver. See `solve` in `scrapely` (solver.ts) for the options.
+     */
+    static async solve(options) {
+        return (0, solver_js_1.solve)(options);
+    }
+    /**
+     * Sets the standard status message for a run whose site protection cannot
+     * be solved right now ("Site protection temporarily unavailable, results
+     * may be incomplete", plus "(N of M items skipped)" when both counts are
+     * given). Never throws: the run goes on.
+     */
+    static async setSolverDegradedStatus(skipped, total) {
+        try {
+            await Actor.setStatusMessage((0, solver_js_1.degradedStatusMessage)(skipped, total));
+        }
+        catch (err) {
+            console.warn(`Could not set the solver status message: ${err.message}`);
+        }
     }
     /**
      * Creates a proxy configuration and returns a promise resolving to an instance

package/dist/charging.d.ts

@@ -234,6 +234,8 @@ export declare function pushDataAndCharge<T>({ chargingManager, items, eventName
 /**
  * @internal True when a dataset push certainly stored nothing: the storage API
  * answered with an error status, or the request never reached it. Timeouts and
- * resets after the request was sent are not proof (the write may have landed).
+ * resets after the request was sent are not proof (the write may have landed),
+ * and neither is any error of a push one of whose earlier attempts may have
+ * been applied (`outcomeUnknown`, set by the storage client's retries).
  */
 export declare function pushCertainlyFailed(err: unknown): boolean;

package/dist/charging.js

@@ -25,7 +25,7 @@ const PENDING_MAX_ENTRIES = 1024;
 // so the retries here can honour deadlines: 429, 408, 5xx, timeouts and
 // network errors are re-sent with the same idempotency key, with exponential
 // backoff and jitter, never sooner than the server's Retry-After, within the API
-// retry window (2 minutes, SCRAPELY_API_RETRY_WINDOW_SECS) or the caller's
+// retry window (5 minutes, SCRAPELY_API_RETRY_WINDOW_SECS) or the caller's
 // deadline. Then the charge stays pending / the void is re-queued and retried
 // before the next push and at exit, the same as the Python SDK.
 const POST_ATTEMPTS = 64;
@@ -1182,9 +1182,15 @@ const NOT_SENT_CODES = new Set(['ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'EHOST
 /**
  * @internal True when a dataset push certainly stored nothing: the storage API
  * answered with an error status, or the request never reached it. Timeouts and
- * resets after the request was sent are not proof (the write may have landed).
+ * resets after the request was sent are not proof (the write may have landed),
+ * and neither is any error of a push one of whose earlier attempts may have
+ * been applied (`outcomeUnknown`, set by the storage client's retries).
  */
 function pushCertainlyFailed(err) {
+    for (let e = err, depth = 0; e && depth < 4; e = e.cause, depth++) {
+        if (e.outcomeUnknown === true)
+            return false;
+    }
     if ((0, api_storage_client_js_1.isConnectFailure)(err))
         return true;
     for (let e = err, depth = 0; e && depth < 4; e = e.cause, depth++) {

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { Actor, ACTOR_PERMISSION_LEVEL, type ActorInput, type InitOptions, type
 export type { StorageAlias, StorageId, StorageName, StorageIdentifier, StorageIdentifierWithoutAlias, } from './storage-identifiers.js';
 export { ApifyClient, type ApifyClientOptions, type ActorRun } from 'scrapely-client';
 export { Configuration, type ConfigurationOptions } from './configuration.js';
+export { DEGRADED_STATUS_MESSAGE, IpBanned, SolveAttemptError, SolverAuthError, SolverRateLimited, VendorUnavailable, degradedStatusMessage, detectVendor, isBlocked, reportSolveOutcome, solve, solverConfigured, solverStatus, stepAllowed, type Clearance, type SolveCookie, type SolveOptions, type SolverStepRequest, type SolverVendorStatus, } from './solver.js';
 export { ScrapelyEventManager as PlatformEventManager } from './events/scrapely-event-manager.js';
 export { ChargingManager, ChargeUncertainError, ChargeRejectedError, DEFAULT_DATASET_ITEM_EVENT, APIFY_DEFAULT_DATASET_ITEM_EVENT, SCRAPELY_DEFAULT_DATASET_ITEM_EVENT, hasDefaultDatasetItemEventInPricing, isDefaultDatasetItemEvent, resolveDefaultDatasetItemEventName, mergeChargeResults, pushDataAndCharge, type ChargeOptions, type ChargeResult, type ActorPricingInfo, } from './charging.js';
 export { createChargingClient, pushDataChargingContext, USES_PUSH_DATA_INTERCEPTION, type PpeAwarePushDataContext, } from './charging_client.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinkeDOMCrawler = exports.JSDOMCrawler = exports.BrowserCrawler = exports.BasicCrawler = exports.HttpCrawler = exports.CheerioCrawler = exports.PuppeteerCrawler = exports.PlaywrightCrawler = exports.ScrapelyRequestList = exports.enqueueLinks = exports.utils = exports.LoggerText = exports.LoggerJson = exports.Logger = exports.LogLevel = exports.Log = exports.log = exports.RequestQueue = exports.KeyValueStore = exports.Dataset = exports.createBrowserConfiguration = exports.BrowserConfiguration = exports.getPlatformProxyEnv = exports.createProxyConfiguration = exports.validateProxySessionId = exports.isPlatformProxySentinel = exports.ProxyConfiguration = exports.ApiStorageClientFactory = exports.BillingTracker = exports.USES_PUSH_DATA_INTERCEPTION = exports.pushDataChargingContext = exports.createChargingClient = exports.pushDataAndCharge = exports.mergeChargeResults = exports.resolveDefaultDatasetItemEventName = exports.isDefaultDatasetItemEvent = exports.hasDefaultDatasetItemEventInPricing = exports.SCRAPELY_DEFAULT_DATASET_ITEM_EVENT = exports.APIFY_DEFAULT_DATASET_ITEM_EVENT = exports.DEFAULT_DATASET_ITEM_EVENT = exports.ChargeRejectedError = exports.ChargeUncertainError = exports.ChargingManager = exports.PlatformEventManager = exports.Configuration = exports.ApifyClient = exports.EXIT_CODES = exports.ACTOR_PERMISSION_LEVEL = exports.Actor = exports.setCdpUrl = void 0;
-exports.puppeteerUtils = exports.playwrightUtils = void 0;
+exports.LogLevel = exports.Log = exports.log = exports.RequestQueue = exports.KeyValueStore = exports.Dataset = exports.createBrowserConfiguration = exports.BrowserConfiguration = exports.getPlatformProxyEnv = exports.createProxyConfiguration = exports.validateProxySessionId = exports.isPlatformProxySentinel = exports.ProxyConfiguration = exports.ApiStorageClientFactory = exports.BillingTracker = exports.USES_PUSH_DATA_INTERCEPTION = exports.pushDataChargingContext = exports.createChargingClient = exports.pushDataAndCharge = exports.mergeChargeResults = exports.resolveDefaultDatasetItemEventName = exports.isDefaultDatasetItemEvent = exports.hasDefaultDatasetItemEventInPricing = exports.SCRAPELY_DEFAULT_DATASET_ITEM_EVENT = exports.APIFY_DEFAULT_DATASET_ITEM_EVENT = exports.DEFAULT_DATASET_ITEM_EVENT = exports.ChargeRejectedError = exports.ChargeUncertainError = exports.ChargingManager = exports.PlatformEventManager = exports.stepAllowed = exports.solverStatus = exports.solverConfigured = exports.solve = exports.reportSolveOutcome = exports.isBlocked = exports.detectVendor = exports.degradedStatusMessage = exports.VendorUnavailable = exports.SolverRateLimited = exports.SolverAuthError = exports.SolveAttemptError = exports.IpBanned = exports.DEGRADED_STATUS_MESSAGE = exports.Configuration = exports.ApifyClient = exports.EXIT_CODES = exports.ACTOR_PERMISSION_LEVEL = exports.Actor = exports.setCdpUrl = void 0;
+exports.puppeteerUtils = exports.playwrightUtils = exports.LinkeDOMCrawler = exports.JSDOMCrawler = exports.BrowserCrawler = exports.BasicCrawler = exports.HttpCrawler = exports.CheerioCrawler = exports.PuppeteerCrawler = exports.PlaywrightCrawler = exports.ScrapelyRequestList = exports.enqueueLinks = exports.utils = exports.LoggerText = exports.LoggerJson = exports.Logger = void 0;
 require("./log-env.js");
 var patch_browser_pool_js_1 = require("./patch-browser-pool.js");
 Object.defineProperty(exports, "setCdpUrl", { enumerable: true, get: function () { return patch_browser_pool_js_1.setCdpUrl; } });
@@ -14,6 +14,21 @@ var scrapely_client_1 = require("scrapely-client");
 Object.defineProperty(exports, "ApifyClient", { enumerable: true, get: function () { return scrapely_client_1.ApifyClient; } });
 var configuration_js_1 = require("./configuration.js");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_js_1.Configuration; } });
+var solver_js_1 = require("./solver.js");
+Object.defineProperty(exports, "DEGRADED_STATUS_MESSAGE", { enumerable: true, get: function () { return solver_js_1.DEGRADED_STATUS_MESSAGE; } });
+Object.defineProperty(exports, "IpBanned", { enumerable: true, get: function () { return solver_js_1.IpBanned; } });
+Object.defineProperty(exports, "SolveAttemptError", { enumerable: true, get: function () { return solver_js_1.SolveAttemptError; } });
+Object.defineProperty(exports, "SolverAuthError", { enumerable: true, get: function () { return solver_js_1.SolverAuthError; } });
+Object.defineProperty(exports, "SolverRateLimited", { enumerable: true, get: function () { return solver_js_1.SolverRateLimited; } });
+Object.defineProperty(exports, "VendorUnavailable", { enumerable: true, get: function () { return solver_js_1.VendorUnavailable; } });
+Object.defineProperty(exports, "degradedStatusMessage", { enumerable: true, get: function () { return solver_js_1.degradedStatusMessage; } });
+Object.defineProperty(exports, "detectVendor", { enumerable: true, get: function () { return solver_js_1.detectVendor; } });
+Object.defineProperty(exports, "isBlocked", { enumerable: true, get: function () { return solver_js_1.isBlocked; } });
+Object.defineProperty(exports, "reportSolveOutcome", { enumerable: true, get: function () { return solver_js_1.reportSolveOutcome; } });
+Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return solver_js_1.solve; } });
+Object.defineProperty(exports, "solverConfigured", { enumerable: true, get: function () { return solver_js_1.solverConfigured; } });
+Object.defineProperty(exports, "solverStatus", { enumerable: true, get: function () { return solver_js_1.solverStatus; } });
+Object.defineProperty(exports, "stepAllowed", { enumerable: true, get: function () { return solver_js_1.stepAllowed; } });
 var scrapely_event_manager_js_1 = require("./events/scrapely-event-manager.js");
 Object.defineProperty(exports, "PlatformEventManager", { enumerable: true, get: function () { return scrapely_event_manager_js_1.ScrapelyEventManager; } });
 var charging_js_1 = require("./charging.js");

package/dist/solver.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Anti-bot solver helpers (JS). Python parity: scrapely-python `scrapely.solver`.
+ *
+ * The platform runs the challenge solver behind /v2/solver; Actors never
+ * hold a solver key. Runs of Actors that may use it get SCRAPELY_SOLVER_URL
+ * and SCRAPELY_SOLVER_API_KEY (the run's own token).
+ *
+ *   const st = await Actor.solverStatus('datadome');      // free, cached 15 s
+ *   if (!st.usable) { ...fallback or fail the item fast... }
+ *
+ *   const clearance = await Actor.solve({
+ *       url, response: { status, body },                  // the blocked response
+ *       fetch: (req) => mySession(req),                   // send step requests on YOUR session
+ *       sessionId: 's-42', identity: 'chrome-146-macos',
+ *   });
+ *   // clearance.cookies -> put them in your cookie jar (fetch already sent the rest)
+ *
+ * Errors: SolveAttemptError (retry on a fresh exit), IpBanned, VendorUnavailable
+ * (fail fast, `code`), SolverRateLimited, SolverAuthError.
+ */
+export declare const DEGRADED_STATUS_MESSAGE = "Site protection temporarily unavailable, results may be incomplete";
+export declare class SolveAttemptError extends Error {
+    constructor(message: string);
+}
+export declare class IpBanned extends SolveAttemptError {
+    constructor(message: string);
+}
+export declare class SolverRateLimited extends SolveAttemptError {
+    readonly retryAfterSecs: number | null;
+    constructor(retryAfterSecs?: number | null);
+}
+export declare class SolverAuthError extends SolveAttemptError {
+    constructor(message: string);
+}
+/** The platform says this vendor cannot be solved right now. Fail fast; do not retry. */
+export declare class VendorUnavailable extends Error {
+    readonly code: string;
+    readonly vendor: string | null;
+    readonly retryAfterSecs: number | null;
+    constructor(code: string, vendor?: string | null, retryAfterSecs?: number | null, message?: string);
+}
+export interface SolverVendorStatus {
+    status: 'healthy' | 'degraded' | 'down' | 'unsupported' | 'unknown';
+    usable: boolean;
+    code: string | null;
+    successRate30m: number | null;
+    since: string | null;
+    recheckAfterSecs: number;
+}
+export interface SolverStepRequest {
+    id: string;
+    method: 'GET' | 'POST';
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+export interface SolveCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+}
+export interface SolveOptions {
+    /** The page that was blocked. */
+    url: string;
+    /** The blocked response. */
+    response: {
+        status: number;
+        body: string;
+    };
+    /** Sends one step request on the Actor's own session (same exit IP); returns its status and body. */
+    fetch: (request: SolverStepRequest) => Promise<{
+        status: number;
+        body: string;
+    }>;
+    /** 'datadome', 'akamai-sbsd' or 'auto' (default). */
+    vendor?: string;
+    /** Proxy session id (enables the platform's clearance cache for that exit). */
+    sessionId?: string;
+    /** Browser profile the TLS impersonation claims (default chrome-146-macos), or an object with locale. */
+    identity?: string | {
+        profile?: string;
+        acceptLanguage?: string;
+        timezone?: string;
+        languages?: string;
+    };
+    /** Cookie header the session holds for the site (SBSD needs it). */
+    cookieHeader?: () => string | null | Promise<string | null>;
+    /** Verifies the clearance (cookies already applied by you or by `fetch`); reported to the platform. */
+    verify?: (cookies: SolveCookie[]) => Promise<boolean> | boolean;
+    timeoutMs?: number;
+}
+export interface Clearance {
+    solveId: string | null;
+    cookies: SolveCookie[];
+    ttlHintSecs: number;
+    cached: boolean;
+    verified: boolean | null;
+}
+/** True when the platform solver API is available to this run. */
+export declare function solverConfigured(): boolean;
+/**
+ * The protection behind a *challenge* response. Ordinary pages that merely load a
+ * vendor script are not challenges: DataDome, PerimeterX and Kasada need a 4xx
+ * status; an SBSD bundle counts only on a short interstitial page.
+ */
+export declare function detectVendor(status: number, body: string): string | null;
+/** A step may only go to the target page's own host or to captcha-delivery.com, over https. */
+export declare function stepAllowed(stepUrl: string, targetUrl: string): boolean;
+export declare function isBlocked(response: {
+    status: number;
+    body: string;
+}, vendor?: string): boolean;
+export declare function degradedStatusMessage(skipped?: number, total?: number): string;
+/** Vendor status from the platform (free, cached for 15 s). Never throws. */
+export declare function solverStatus(vendor: string): Promise<SolverVendorStatus>;
+/** Solves one challenge on the Actor's session through the platform. */
+export declare function solve(options: SolveOptions): Promise<Clearance>;
+/** Reports your own verification of a clearance (when `verify` was not passed to solve). */
+export declare function reportSolveOutcome(clearance: Clearance, verified: boolean): Promise<void>;
+/** Test hook. */
+export declare function clearSolverStatusCache(): void;

package/dist/solver.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * Anti-bot solver helpers (JS). Python parity: scrapely-python `scrapely.solver`.
+ *
+ * The platform runs the challenge solver behind /v2/solver; Actors never
+ * hold a solver key. Runs of Actors that may use it get SCRAPELY_SOLVER_URL
+ * and SCRAPELY_SOLVER_API_KEY (the run's own token).
+ *
+ *   const st = await Actor.solverStatus('datadome');      // free, cached 15 s
+ *   if (!st.usable) { ...fallback or fail the item fast... }
+ *
+ *   const clearance = await Actor.solve({
+ *       url, response: { status, body },                  // the blocked response
+ *       fetch: (req) => mySession(req),                   // send step requests on YOUR session
+ *       sessionId: 's-42', identity: 'chrome-146-macos',
+ *   });
+ *   // clearance.cookies -> put them in your cookie jar (fetch already sent the rest)
+ *
+ * Errors: SolveAttemptError (retry on a fresh exit), IpBanned, VendorUnavailable
+ * (fail fast, `code`), SolverRateLimited, SolverAuthError.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorUnavailable = exports.SolverAuthError = exports.SolverRateLimited = exports.IpBanned = exports.SolveAttemptError = exports.DEGRADED_STATUS_MESSAGE = void 0;
+exports.solverConfigured = solverConfigured;
+exports.detectVendor = detectVendor;
+exports.stepAllowed = stepAllowed;
+exports.isBlocked = isBlocked;
+exports.degradedStatusMessage = degradedStatusMessage;
+exports.solverStatus = solverStatus;
+exports.solve = solve;
+exports.reportSolveOutcome = reportSolveOutcome;
+exports.clearSolverStatusCache = clearSolverStatusCache;
+exports.DEGRADED_STATUS_MESSAGE = 'Site protection temporarily unavailable, results may be incomplete';
+const COMPAT_SUFFIX = '/compat/xhrdev';
+const STATUS_TTL_MS = 15_000;
+const MAX_BODY = 4 * 1024 * 1024;
+const UNAVAILABLE_CODES = new Set(['vendor_degraded', 'vendor_down', 'provider_unavailable', 'vendor_unsupported', 'solver_not_enabled']);
+class SolveAttemptError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SolveAttemptError';
+    }
+}
+exports.SolveAttemptError = SolveAttemptError;
+class IpBanned extends SolveAttemptError {
+    constructor(message) {
+        super(message);
+        this.name = 'IpBanned';
+    }
+}
+exports.IpBanned = IpBanned;
+class SolverRateLimited extends SolveAttemptError {
+    retryAfterSecs;
+    constructor(retryAfterSecs = null) {
+        super(`solver rate limit hit (HTTP 429${retryAfterSecs !== null ? `, retry after ${retryAfterSecs}s` : ''})`);
+        this.retryAfterSecs = retryAfterSecs;
+        this.name = 'SolverRateLimited';
+    }
+}
+exports.SolverRateLimited = SolverRateLimited;
+class SolverAuthError extends SolveAttemptError {
+    constructor(message) {
+        super(message);
+        this.name = 'SolverAuthError';
+    }
+}
+exports.SolverAuthError = SolverAuthError;
+/** The platform says this vendor cannot be solved right now. Fail fast; do not retry. */
+class VendorUnavailable extends Error {
+    code;
+    vendor;
+    retryAfterSecs;
+    constructor(code, vendor = null, retryAfterSecs = null, message) {
+        super(message ?? `anti-bot solver unavailable (${code}${vendor ? `, ${vendor}` : ''})`);
+        this.code = code;
+        this.vendor = vendor;
+        this.retryAfterSecs = retryAfterSecs;
+        this.name = 'VendorUnavailable';
+    }
+}
+exports.VendorUnavailable = VendorUnavailable;
+function solverEnv() {
+    const url = (process.env.SCRAPELY_SOLVER_URL ?? '').trim().replace(/\/+$/, '');
+    const key = (process.env.SCRAPELY_SOLVER_API_KEY ?? '').trim();
+    return url && key ? { url, key } : null;
+}
+function gateway() {
+    const env = solverEnv();
+    if (!env || !env.url.endsWith(COMPAT_SUFFIX))
+        return null;
+    return { base: env.url.slice(0, -COMPAT_SUFFIX.length), key: env.key };
+}
+/** True when the platform solver API is available to this run. */
+function solverConfigured() {
+    return gateway() !== null;
+}
+/**
+ * The protection behind a *challenge* response. Ordinary pages that merely load a
+ * vendor script are not challenges: DataDome, PerimeterX and Kasada need a 4xx
+ * status; an SBSD bundle counts only on a short interstitial page.
+ */
+function detectVendor(status, body) {
+    const all = body || '';
+    const sample = all.slice(0, 20000);
+    const head = sample.slice(0, 4000).toLowerCase();
+    const challenged = status >= 400;
+    if (challenged && (head.includes('captcha-delivery.com') || /var\s+dd\s*=\s*\{/.test(sample) || head.includes('datadome')))
+        return 'datadome';
+    if (all.length <= 20000 && /<script[^>]+src="([^"]+\?v=[0-9a-f-]{36}[^"]*)"/i.test(sample))
+        return 'akamai-sbsd';
+    if (challenged && /_pxappid|px-captcha|perimeterx|\/_px\d?\//i.test(sample))
+        return 'perimeterx';
+    if (challenged && /kpsdk/i.test(sample))
+        return 'kasada';
+    return null;
+}
+/** A step may only go to the target page's own host or to captcha-delivery.com, over https. */
+function stepAllowed(stepUrl, targetUrl) {
+    try {
+        const step = new URL(stepUrl);
+        const target = new URL(targetUrl);
+        if (step.protocol !== 'https:')
+            return false;
+        const host = step.hostname.toLowerCase();
+        return host === target.hostname.toLowerCase() || host === 'captcha-delivery.com' || host.endsWith('.captcha-delivery.com');
+    }
+    catch {
+        return false;
+    }
+}
+function isBlocked(response, vendor) {
+    const found = detectVendor(response.status, response.body);
+    return !vendor || vendor === 'auto' ? found !== null : found === vendor;
+}
+function degradedStatusMessage(skipped, total) {
+    return skipped !== undefined && total !== undefined ? `${exports.DEGRADED_STATUS_MESSAGE} (${skipped} of ${total} items skipped)` : exports.DEGRADED_STATUS_MESSAGE;
+}
+const statusCache = new Map();
+function unknownStatus(code = null) {
+    return { status: 'unknown', usable: code === null, code, successRate30m: null, since: null, recheckAfterSecs: 300 };
+}
+/** Vendor status from the platform (free, cached for 15 s). Never throws. */
+async function solverStatus(vendor) {
+    const name = (vendor || '').trim().toLowerCase();
+    const hit = statusCache.get(name);
+    if (hit && Date.now() - hit.at < STATUS_TTL_MS)
+        return hit.value;
+    const gw = gateway();
+    if (!gw)
+        return unknownStatus(solverEnv() ? null : 'solver_not_enabled');
+    try {
+        const res = await fetch(`${gw.base}/status?vendors=${encodeURIComponent(name)}`, {
+            headers: { authorization: `Bearer ${gw.key}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            return unknownStatus();
+        const data = (await res.json());
+        const value = data.vendors?.[name] ?? unknownStatus();
+        statusCache.set(name, { at: Date.now(), value });
+        return value;
+    }
+    catch {
+        return unknownStatus();
+    }
+}
+async function api(path, body, key, base, timeoutMs) {
+    let res;
+    try {
+        res = await fetch(`${base}${path}`, {
+            method: 'POST',
+            headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (err) {
+        // Gateway unreachable or timed out: one failed try, retried on a fresh session.
+        throw new SolveAttemptError(`solver gateway unreachable: ${err.name}`);
+    }
+    let data = {};
+    try {
+        data = await res.json();
+    }
+    catch {
+        data = {};
+    }
+    return { status: res.status, data, retryAfter: res.headers.get('retry-after') };
+}
+function handle(r, vendor) {
+    const { status, data } = r;
+    if (status === 503 && UNAVAILABLE_CODES.has(String(data.code ?? '')))
+        throw new VendorUnavailable(String(data.code), data.vendor ?? vendor, data.retryAfterSecs ?? null);
+    if (status === 429)
+        throw new SolverRateLimited(r.retryAfter ? Number(r.retryAfter) : (data.retryAfterSecs ?? null));
+    if (status === 401 || status === 403) {
+        if (data.code === 'solver_not_enabled')
+            throw new VendorUnavailable('solver_not_enabled', vendor, null, 'the anti-bot solver is not enabled for this Actor');
+        throw new SolverAuthError(`solver refused the run token (HTTP ${status})`);
+    }
+    if (status >= 400)
+        throw new SolveAttemptError(`solver HTTP ${status}: ${data.message ?? ''}`.trim());
+    return data;
+}
+/** Solves one challenge on the Actor's session through the platform. */
+async function solve(options) {
+    const gw = gateway();
+    const vendor = options.vendor ?? 'auto';
+    if (!gw)
+        throw new VendorUnavailable('solver_not_enabled', vendor, null, 'the platform solver is not available to this run');
+    const timeoutMs = (options.timeoutMs ?? 60_000) + 30_000;
+    const identity = typeof options.identity === 'string' ? { profile: options.identity } : (options.identity ?? { profile: 'chrome-146-macos' });
+    const cookieHeader = async () => (options.cookieHeader ? await options.cookieHeader() : null);
+    let data = handle(await api('/solve', {
+        vendor,
+        url: options.url,
+        blocked: { status: options.response.status, body: (options.response.body ?? '').slice(0, MAX_BODY) },
+        identity,
+        timeoutMs: options.timeoutMs ?? 60_000,
+        session: { id: options.sessionId, cookieHeader: await cookieHeader() },
+    }, gw.key, gw.base, timeoutMs), vendor);
+    for (let step = 0; step < 8; step++) {
+        if (data.action === 'done') {
+            const clearance = {
+                solveId: data.solveId ?? null,
+                cookies: data.cookies ?? [],
+                ttlHintSecs: Number(data.ttlHintSecs) || 0,
+                cached: !!data.cached,
+                verified: null,
+            };
+            if (options.verify) {
+                const ok = !!(await options.verify(clearance.cookies));
+                clearance.verified = ok;
+                if (clearance.solveId) {
+                    await api(`/solves/${clearance.solveId}/outcome`, { verified: ok }, gw.key, gw.base, 15_000).catch(() => undefined);
+                }
+                if (!ok)
+                    throw new SolveAttemptError('still blocked after the clearance was applied');
+            }
+            return clearance;
+        }
+        if (data.action === 'failed') {
+            const message = String(data.message ?? data.reason ?? 'solve failed');
+            if (data.reason === 'ip_banned')
+                throw new IpBanned(message);
+            throw new SolveAttemptError(message);
+        }
+        if (data.action !== 'fetch' && data.action !== 'submit')
+            throw new SolveAttemptError(`unexpected solver answer: ${data.action}`);
+        const results = [];
+        for (const req of (data.requests ?? [])) {
+            if (!req || !stepAllowed(String(req.url ?? ''), options.url) || (req.method !== 'GET' && req.method !== 'POST')) {
+                throw new SolveAttemptError('the solver asked for a request outside the target site; refused');
+            }
+            let r;
+            try {
+                r = await options.fetch(req);
+            }
+            catch (err) {
+                throw new SolveAttemptError(`challenge request failed: ${err.name}`);
+            }
+            results.push({ id: req.id, status: r.status, body: (r.body ?? '').slice(0, MAX_BODY) });
+        }
+        data = handle(await api('/solve', { solveId: data.solveId, results, session: { id: options.sessionId, cookieHeader: await cookieHeader() } }, gw.key, gw.base, timeoutMs), vendor);
+    }
+    throw new SolveAttemptError('the solve did not finish');
+}
+/** Reports your own verification of a clearance (when `verify` was not passed to solve). */
+async function reportSolveOutcome(clearance, verified) {
+    const gw = gateway();
+    if (!gw || !clearance.solveId)
+        return;
+    clearance.verified = verified;
+    await api(`/solves/${clearance.solveId}/outcome`, { verified }, gw.key, gw.base, 15_000).catch(() => undefined);
+}
+/** Test hook. */
+function clearSolverStatusCache() {
+    statusCache.clear();
+}

package/dist/storage/api-storage-client.d.ts

@@ -24,11 +24,15 @@ export declare class ApiStorageClientError extends Error {
  */
 export declare function isRetryableResponse(status: number, idempotent: boolean, errorType?: string, bodyText?: string): boolean;
 /** Default time budget for retrying one API call (429, 503, network errors). */
-export declare const DEFAULT_API_RETRY_WINDOW_MS = 120000;
+export declare const DEFAULT_API_RETRY_WINDOW_MS = 300000;
+/** Whether the API at `url` (any URL of it; default: the last one seen) de-duplicates keyed writes. */
+export declare function apiDedupesKeyedWrites(url?: string): boolean;
+/** Test hook: forget what was learned about the API, or force an answer for every origin. */
+export declare function _resetKeyedWriteSupport(value?: boolean): void;
 /**
  * How long one API call keeps retrying before it gives up:
  * SCRAPELY_API_RETRY_WINDOW_SECS when set, else {@link BaseApiClient.retryWindowMs}
- * (2 minutes by default).
+ * (5 minutes by default).
  */
 export declare function apiRetryWindowMs(): number;
 /**
@@ -51,6 +55,13 @@ export interface RetryingFetchOptions {
     retryWindowMs?: number;
     /** Short label for log lines, e.g. "POST /datasets/x/items". */
     label: string;
+    /**
+     * Idempotency-Key for a write (one per logical write, the same on every
+     * attempt). Once the API is known to de-duplicate keyed writes, the write
+     * is retried like an idempotent call: a re-send of an applied write returns
+     * the original answer instead of applying it again.
+     */
+    idempotencyKey?: string;
 }
 export interface RetryingFetchInit {
     method: string;
@@ -59,15 +70,17 @@ export interface RetryingFetchInit {
 }
 /**
  * fetch() with the API retry policy. Retries, with exponential backoff and
- * jitter that honours Retry-After, until the retry window (2 minutes by
+ * jitter that honours Retry-After, until the retry window (5 minutes by
  * default) runs out:
  * - 429 (run API rate limit, dataset backpressure): always; nothing was applied.
  * - 503 from the limiter or HAProxy: always; nothing was forwarded.
- * - 500/502/503/504, timeouts and dropped connections: idempotent calls only.
+ * - 500/502/503/504, timeouts and dropped connections: idempotent calls, and
+ *   writes with an Idempotency-Key once the API is known to de-duplicate them.
  * - Refused/unresolvable connections: always; the request never left.
- * A write (dataset push, KV PUT, metamorph) whose request may have reached the
- * API is never re-sent: there is no idempotency key for it, so a re-send could
- * store the same rows twice. Such failures surface to the caller instead.
+ * Any other write (KV PUT, metamorph, a keyed push to an API that did not say
+ * it de-duplicates) whose request may have reached the API is never re-sent:
+ * a re-send could apply it twice. Such failures surface to the caller instead,
+ * marked `outcomeUnknown` when an attempt may have been applied.
  * Non-2xx answers that are not retried throw ApiStorageClientError.
  */
 export declare function fetchWithRetries<R>(url: string, init: RetryingFetchInit, options: RetryingFetchOptions, decode: (response: Response) => Promise<R>): Promise<R>;
@@ -81,6 +94,8 @@ interface ApiRequestOptions {
     doNotRetryTimeouts?: boolean;
     /** Override the method-based idempotency (e.g. get-or-create by name is safe to repeat). */
     idempotent?: boolean;
+    /** Idempotency-Key for a write; see {@link RetryingFetchOptions.idempotencyKey}. */
+    idempotencyKey?: string;
 }
 /**
  * Base class for API-based storage clients.

package/dist/storage/api-storage-client.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiStorageClientFactory = exports.ApiRequestQueueClient = exports.ApiKeyValueStoreClient = exports.ApiDatasetClient = exports.BaseApiClient = exports.DEFAULT_API_RETRY_WINDOW_MS = exports.ApiStorageClientError = void 0;
 exports.isRetryableResponse = isRetryableResponse;
+exports.apiDedupesKeyedWrites = apiDedupesKeyedWrites;
+exports._resetKeyedWriteSupport = _resetKeyedWriteSupport;
 exports.apiRetryWindowMs = apiRetryWindowMs;
 exports.serverRetryDelayMs = serverRetryDelayMs;
 exports.isConnectFailure = isConnectFailure;
@@ -161,12 +163,72 @@ function isRetryableResponse(status, idempotent, errorType, bodyText) {
     return errorType === 'rate-limit-unavailable' || (bodyText ?? '').includes(NO_BACKEND_MARKER);
 }
 /** Default time budget for retrying one API call (429, 503, network errors). */
-exports.DEFAULT_API_RETRY_WINDOW_MS = 120_000;
+exports.DEFAULT_API_RETRY_WINDOW_MS = 300_000;
+/**
+ * Response header the API sets on every dataset push that sent an
+ * Idempotency-Key, once it de-duplicates such pushes. An older API ignores the
+ * key, and re-sending a push there could store the rows twice, so ambiguous
+ * failures of keyed writes are retried only while the latest keyed answer from
+ * that API origin carried this header. A 2xx without it (an older instance,
+ * e.g. mid-deploy or after a rollback) switches the retries off again.
+ */
+const IDEMPOTENCY_SUPPORT_HEADER = 'x-scrapely-idempotency';
+const keyedWritesDeduped = new Map();
+/** Test override for every origin (undefined: learn from answers). */
+let keyedWritesDedupedOverride;
+function originOf(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return url;
+    }
+}
+/** Whether the API at `url` (any URL of it; default: the last one seen) de-duplicates keyed writes. */
+function apiDedupesKeyedWrites(url) {
+    if (keyedWritesDedupedOverride !== undefined)
+        return keyedWritesDedupedOverride;
+    if (url !== undefined)
+        return keyedWritesDeduped.get(originOf(url)) === true;
+    return [...keyedWritesDeduped.values()].pop() === true;
+}
+/** Test hook: forget what was learned about the API, or force an answer for every origin. */
+function _resetKeyedWriteSupport(value) {
+    keyedWritesDeduped.clear();
+    keyedWritesDedupedOverride = value === true ? true : undefined;
+}
+function noteKeyedAnswer(url, response) {
+    const origin = originOf(url);
+    if (response.headers.has(IDEMPOTENCY_SUPPORT_HEADER)) {
+        keyedWritesDeduped.delete(origin);
+        keyedWritesDeduped.set(origin, true);
+    }
+    else if (response.ok) {
+        // Stored by a handler that ignored the key: this API (instance) does not de-duplicate.
+        keyedWritesDeduped.delete(origin);
+        keyedWritesDeduped.set(origin, false);
+        if (keyedWritesDedupedOverride === true)
+            keyedWritesDedupedOverride = undefined;
+    }
+}
+/** API error types of a keyed write: still being stored (retry), or stored-or-not unknown (final). */
+const KEY_IN_PROGRESS = 'idempotency-key-in-progress';
+const OUTCOME_UNKNOWN = 'push-outcome-unknown';
+/**
+ * Marks an error whose request may have been applied by an earlier attempt
+ * (timeout, dropped connection or 5xx before the final answer), so callers
+ * don't treat it as "nothing was stored".
+ */
+function markOutcomeUnknown(err) {
+    if (err && typeof err === 'object')
+        err.outcomeUnknown = true;
+    return err;
+}
 const MAX_BACKOFF_MS = 30_000;
 /**
  * How long one API call keeps retrying before it gives up:
  * SCRAPELY_API_RETRY_WINDOW_SECS when set, else {@link BaseApiClient.retryWindowMs}
- * (2 minutes by default).
+ * (5 minutes by default).
  */
 function apiRetryWindowMs() {
     const env = Number(process.env.SCRAPELY_API_RETRY_WINDOW_SECS);
@@ -231,22 +293,32 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const sharedRateLimiter = new AdaptiveRateLimiter();
 /**
  * fetch() with the API retry policy. Retries, with exponential backoff and
- * jitter that honours Retry-After, until the retry window (2 minutes by
+ * jitter that honours Retry-After, until the retry window (5 minutes by
  * default) runs out:
  * - 429 (run API rate limit, dataset backpressure): always; nothing was applied.
  * - 503 from the limiter or HAProxy: always; nothing was forwarded.
- * - 500/502/503/504, timeouts and dropped connections: idempotent calls only.
+ * - 500/502/503/504, timeouts and dropped connections: idempotent calls, and
+ *   writes with an Idempotency-Key once the API is known to de-duplicate them.
  * - Refused/unresolvable connections: always; the request never left.
- * A write (dataset push, KV PUT, metamorph) whose request may have reached the
- * API is never re-sent: there is no idempotency key for it, so a re-send could
- * store the same rows twice. Such failures surface to the caller instead.
+ * Any other write (KV PUT, metamorph, a keyed push to an API that did not say
+ * it de-duplicates) whose request may have reached the API is never re-sent:
+ * a re-send could apply it twice. Such failures surface to the caller instead,
+ * marked `outcomeUnknown` when an attempt may have been applied.
  * Non-2xx answers that are not retried throw ApiStorageClientError.
  */
 async function fetchWithRetries(url, init, options, decode) {
-    const { idempotent, timeoutMs, label } = options;
-    const retryTimeouts = options.retryTimeouts !== false && idempotent;
+    const { timeoutMs, label, idempotencyKey } = options;
+    const headers = idempotencyKey ? { ...init.headers, 'Idempotency-Key': idempotencyKey } : init.headers;
+    // Re-sending is safe for idempotent calls, and for keyed writes once the
+    // API showed it de-duplicates them (learned from any keyed answer).
+    const safeToResend = () => options.idempotent || (idempotencyKey !== undefined && apiDedupesKeyedWrites(url));
+    const retryTimeouts = () => options.retryTimeouts !== false && safeToResend();
     const deadline = Date.now() + Math.max(0, options.retryWindowMs ?? apiRetryWindowMs());
     let attempt = 0;
+    // An attempt of a non-idempotent call may have been applied (timeout,
+    // dropped connection, 5xx): the final error must not claim "nothing applied".
+    let maybeApplied = false;
+    const fail = (err) => (maybeApplied && !options.idempotent ? markOutcomeUnknown(err) : err);
     /** Sleeps before the next attempt; false once the retry window is used up. */
     const backoff = async (why, retryAfter) => {
         // Retrying sooner than asked would only be refused again: give up when
@@ -264,8 +336,10 @@ async function fetchWithRetries(url, init, options, decode) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
-            const response = await fetch(url, { method: init.method, headers: init.headers, body: init.body, signal: controller.signal });
+            const response = await fetch(url, { method: init.method, headers, body: init.body, signal: controller.signal });
             sharedRateLimiter.updateFromHeaders(response.headers);
+            if (idempotencyKey)
+                noteKeyedAnswer(url, response);
             if (response.ok) {
                 try {
                     // Decoded inside the retry loop: a body cut off after
@@ -275,19 +349,20 @@ async function fetchWithRetries(url, init, options, decode) {
                 catch (bodyErr) {
                     // The request was applied (2xx); a write whose answer
                     // timed out while being read must not be sent again.
+                    maybeApplied = true;
                     if (bodyErr.name === 'AbortError') {
-                        if (!idempotent || !retryTimeouts) {
-                            const timeoutError = new Error(`Request timed out after ${timeoutMs}ms (response body${idempotent ? '' : '; the request was applied'})`);
+                        if (!retryTimeouts()) {
+                            const timeoutError = new Error(`Request timed out after ${timeoutMs}ms (response body${options.idempotent ? '' : '; the request was applied'})`);
                             timeoutError.isTimeout = true;
-                            throw timeoutError;
+                            throw fail(timeoutError);
                         }
                         if (await backoff(`response body timed out after ${timeoutMs}ms`, null))
                             continue;
-                        throw bodyErr;
+                        throw fail(bodyErr);
                     }
-                    if (idempotent && await backoff(`response body failed (${describeFetchError(bodyErr)})`, null))
+                    if (safeToResend() && await backoff(`response body failed (${describeFetchError(bodyErr)})`, null))
                         continue;
-                    throw bodyErr;
+                    throw fail(bodyErr);
                 }
             }
             const text = await response.text().catch(() => '');
@@ -298,11 +373,27 @@ async function fetchWithRetries(url, init, options, decode) {
             catch {
                 errorBody = undefined;
             }
-            if (isRetryableResponse(response.status, idempotent, errorBody?.error?.type, text)
+            const errorType = errorBody?.error?.type;
+            const apiError = new ApiStorageClientError(errorBody?.error?.message || response.statusText || `API request failed: ${response.status}`, response.status);
+            if (idempotencyKey && errorType === OUTCOME_UNKNOWN) {
+                // Stored or not, nobody knows: the API refuses repeats of this key.
+                maybeApplied = true;
+                throw fail(apiError);
+            }
+            // A 5xx other than the limiter's / HAProxy's 503 may come after the write was applied.
+            if (!options.idempotent && response.status >= 500 && !isRetryableResponse(response.status, false, errorType, text)) {
+                maybeApplied = true;
+            }
+            const resend = safeToResend();
+            // 409 for a keyed write: an earlier attempt is still being stored.
+            const inProgress = idempotencyKey !== undefined && response.status === 409 && errorType === KEY_IN_PROGRESS;
+            if ((inProgress || isRetryableResponse(response.status, resend, errorType, text))
                 && await backoff(`answered ${response.status}`, response.headers.get('retry-after'))) {
                 continue;
             }
-            throw new ApiStorageClientError(errorBody?.error?.message || response.statusText || `API request failed: ${response.status}`, response.status);
+            if (inProgress)
+                maybeApplied = true;
+            throw fail(apiError);
         }
         catch (err) {
             // HTTP errors (already decided above) are final.
@@ -310,19 +401,25 @@ async function fetchWithRetries(url, init, options, decode) {
                 throw err;
             if (err?.isTimeout)
                 throw err;
+            if (err?.outcomeUnknown)
+                throw err;
             if (err.name === 'AbortError') {
+                maybeApplied = true;
                 const timeoutError = new Error(`Request timed out after ${timeoutMs}ms`);
                 timeoutError.isTimeout = true;
-                if (retryTimeouts && await backoff(`timed out after ${timeoutMs}ms`, null))
+                if (retryTimeouts() && await backoff(`timed out after ${timeoutMs}ms`, null))
                     continue;
-                throw timeoutError;
+                throw fail(timeoutError);
             }
             // fetch() failed without a response. A refused/unresolvable
             // connection never reached the API, so it is safe for every
-            // method; anything else (reset mid-request) only for idempotent ones.
-            if ((idempotent || isConnectFailure(err)) && await backoff(`failed (${describeFetchError(err)})`, null))
+            // method; anything else (reset mid-request) only when re-sending is safe.
+            const connectFailure = isConnectFailure(err);
+            if (!connectFailure)
+                maybeApplied = true;
+            if ((safeToResend() || connectFailure) && await backoff(`failed (${describeFetchError(err)})`, null))
                 continue;
-            throw err;
+            throw fail(err);
         }
         finally {
             clearTimeout(timeoutId);
@@ -391,7 +488,7 @@ class BaseApiClient {
     headers;
     // How long one call keeps retrying 429/503/network errors before it gives
     // up (SCRAPELY_API_RETRY_WINDOW_SECS overrides it). Long enough that a
-    // throttled run slows down instead of failing, and covers a main redeploy.
+    // throttled run slows down instead of failing, and covers an API redeploy.
     static retryWindowMs = exports.DEFAULT_API_RETRY_WINDOW_MS;
     // Default timeout for requests (30 seconds)
     static defaultTimeoutMs = 30000;
@@ -427,6 +524,7 @@ class BaseApiClient {
             timeoutMs,
             retryTimeouts: options?.doNotRetryTimeouts !== true,
             label: `${method} ${path}`,
+            idempotencyKey: options?.idempotencyKey,
         }, decode);
     }
     async request(method, path, body, contentType, options) {
@@ -584,7 +682,9 @@ class ApiDatasetClient extends BaseApiClient {
         // must not store unbilled rows in its default dataset.
         if (this.id === (0, charging_js_1.defaultDatasetIdFromEnv)() && (0, charging_js_1.refuseDefaultDatasetPush)(parsed.length))
             return;
-        await this.request('POST', `/datasets/${this.id}/items`, parsed);
+        // One key per push, the same on every attempt: the API stores a
+        // re-sent push once, so a push whose connection dropped can be retried.
+        await this.request('POST', `/datasets/${this.id}/items`, parsed, undefined, { idempotencyKey: (0, node_crypto_1.randomUUID)() });
     }
 }
 exports.ApiDatasetClient = ApiDatasetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "scrapely",
-    "version": "1.2.18",
+    "version": "1.2.20",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
         "test:charging": "npx tsx --test tests/charging-pending.test.ts",
         "test:charge-limit-guard": "npx tsx --test tests/charge-limit-guard.test.ts",
         "test:storage-retries": "npx tsx --test tests/storage-retries.test.ts",
+        "test:push-idempotency": "npx tsx --test tests/push-idempotency.test.ts",
         "test:stdio-drain": "npx tsx --test tests/stdio-drain.test.ts",
         "test:charging-client": "npx tsx --test tests/charging-client.test.ts",
         "test:proxy": "npx tsx --test tests/proxy-configuration.test.ts",
@@ -44,7 +45,8 @@
         "test:terminal-status": "npx tsx --test tests/terminal-status-message.test.ts",
         "test:cdp-retry": "npx tsx --test tests/cdp-retry.test.ts",
         "test:proxy-input-aliases": "npx tsx --test tests/proxy-input-aliases.test.ts",
-        "test:charge-retries": "npx tsx --test tests/charge-retries.test.ts"
+        "test:charge-retries": "npx tsx --test tests/charge-retries.test.ts",
+        "test:solver": "npx tsx --test tests/solver.test.ts"
     },
     "author": "SandeepDev1",
     "license": "ISC AND Apache-2.0",