apify 4.0.0-beta.33 → 4.0.0-beta.34

package/dist/actor.d.ts

@@ -13,6 +13,14 @@ import type { ProxyConfigurationOptions } from './proxy_configuration.js';
 import { ProxyConfiguration } from './proxy_configuration.js';
 import type { OpenStorageOptions, StorageIdentifier } from './storage.js';
 export interface InitOptions {
+    /**
+     * Storage backend to use, in place of the Apify platform storage (on the platform) or crawlee's
+     * local storage (outside of it).
+     *
+     * Items pushed to the default dataset are then not charged for under the pay-per-event pricing
+     * model: the platform counts an `apify-default-dataset-item` per item it stores itself, and a
+     * backend of your own stores them elsewhere.
+     */
     storage?: StorageBackend;
     /**
      * Determines how request queues opened on the Apify platform are consumed.
@@ -577,6 +585,9 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
      * otherwise the Actor process might finish before the data are stored!
      *
+     * Inside a crawlee storage transaction, the items are stored - and charged for - at commit time,
+     * so the returned counts are zero and charging for an explicit `eventName` is rejected outright.
+     *
      * @param item Object or array of objects containing data to be stored in the default dataset.
      * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
      * @param eventName If provided, the method will attempt to charge for the event for each pushed item.
@@ -1125,6 +1136,10 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
      * otherwise the Actor process might finish before the data are stored!
      *
+     * Charging is rejected inside a crawlee storage transaction, where the items would only be stored
+     * at commit while the charge happens immediately - use `withDirectStorageAccess()` to opt out of
+     * the transaction, or push without an event name and charge separately.
+     *
      * @param item Object or array of objects containing data to be stored in the default dataset.
      * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
      * @param eventName If provided, the method will attempt to charge for the event for each pushed item.
@@ -1366,10 +1381,28 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @internal
      */
     static setDefaultInstance(instance?: Actor): void;
-    private usesPushDataInterception;
-    private pushDataViaInterceptedClient;
-    private pushDataWithExplicitCharging;
+    /**
+     * The backend the Actor installs: the caller's, the platform's, or crawlee's local default.
+     *
+     * Only the last two are wrapped for dataset-item charging. The platform counts an
+     * `apify-default-dataset-item` per item written to the run's default dataset through Apify
+     * storage, so a caller-supplied backend is billed nothing and must not be accounted for -
+     * charging for it would spend a budget nobody is consuming and trim the caller's items to fit
+     * it. crawlee's local default stands in for Apify storage, so it is wrapped to keep local
+     * pay-per-event testing faithful.
+     *
+     * Wrapping means owning the instance, which is why the local default is constructed here
+     * rather than left to be created lazily on first use.
+     */
+    private createStorageBackend;
+    /** Wrapped here rather than at the `init()` call site so that `forceCloud` storages are charged too. */
     private createApifyStorageBackend;
+    /**
+     * crawlee's service locator is set-once, so a backend registered before `init()` wins and the
+     * Actor cannot install its own over it. Replaces the resulting `ServiceConflictError` with the
+     * way out.
+     */
+    private installStorageBackend;
     private ensureActorInit;
     /**
      * Get time remaining from the Actor run timeout in seconds, rounded up to whole seconds with minimum value of 1 second.

package/dist/actor.js

@@ -1,5 +1,5 @@
 import { createPrivateKey } from 'node:crypto';
-import { Dataset, EventType, KeyValueStore, purgeDefaultStorages, RequestQueue, serviceLocator } from '@crawlee/core';
+import { Dataset, EventType, KeyValueStore, purgeDefaultStorages, rejectOperationInTransaction, RequestQueue, ServiceLocator, serviceLocator, } from '@crawlee/core';
 import { sleep } from '@crawlee/utils';
 import { ApifyClient } from 'apify-client';
 import { z } from 'zod';
@@ -8,8 +8,9 @@ import { decryptInputSecrets } from '@apify/input_secrets';
 import log from '@apify/log';
 import { addTimeoutToPromise } from '@apify/timeout';
 import { parseArgument } from '@apify/validations';
-import { ApifyStorageBackend, pushDataChargingContext, USES_PUSH_DATA_INTERCEPTION, } from './apify_storage_backend.js';
-import { ChargingManager, pushDataAndCharge } from './charging.js';
+import { ApifyStorageBackend } from './apify_storage_backend.js';
+import { ChargingManager, DEFAULT_DATASET_ITEM_EVENT } from './charging.js';
+import { ChargingDatasetBackend, ChargingStorageBackend } from './charging_storage_backend.js';
 import { Configuration } from './configuration.js';
 import { getDefaultsFromInputSchema, noActorInputSchemaDefinedMarker, readInputSchema } from './input-schemas.js';
 import { PlatformEventManager } from './platform_event_manager.js';
@@ -208,11 +209,13 @@ export class Actor {
         serviceLocator.setConfiguration(this.configuration);
         this.#requestQueueAccess = options.requestQueueAccess ?? 'single';
         if (this.isAtHome()) {
-            serviceLocator.setStorageBackend(this.createApifyStorageBackend());
             serviceLocator.setEventManager(this.eventManager);
         }
+        if (!serviceLocator.getServicesIfSet().storageBackend) {
+            this.installStorageBackend(this.createStorageBackend(options.storage));
+        }
         else if (options.storage) {
-            serviceLocator.setStorageBackend(options.storage);
+            this.installStorageBackend(options.storage);
         }
         // Init the event manager the config uses
         await serviceLocator.getEventManager().init();
@@ -250,6 +253,13 @@ export class Actor {
         log.debug(`Default storages purged`);
         await this.#chargingManager.init();
         log.debug(`ChargingManager initialized`, this.#chargingManager.getPricingInfo());
+        // Only knowable once the pricing is loaded. Reachable with a caller-supplied backend or one
+        // registered with crawlee directly; the storages the Actor installs itself are wrapped.
+        if (this.#chargingManager.isPayPerEvent &&
+            !(serviceLocator.getStorageBackend() instanceof ChargingStorageBackend)) {
+            log.warning('Items pushed to the default dataset will not be charged for, because this run does not use Apify ' +
+                'storage - the platform only counts items it stores itself.');
+        }
     }
     /**
      * @ignore
@@ -633,6 +643,9 @@ export class Actor {
      * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
      * otherwise the Actor process might finish before the data are stored!
      *
+     * Inside a crawlee storage transaction, the items are stored - and charged for - at commit time,
+     * so the returned counts are zero and charging for an explicit `eventName` is rejected outright.
+     *
      * @param item Object or array of objects containing data to be stored in the default dataset.
      * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
      * @param eventName If provided, the method will attempt to charge for the event for each pushed item.
@@ -643,17 +656,49 @@ export class Actor {
         if (eventName?.startsWith('apify-')) {
             throw new Error(`Cannot charge for synthetic event '${eventName}' manually`);
         }
+        if (eventName !== undefined) {
+            rejectOperationInTransaction(`Actor.pushData() with the event name '${eventName}'`, 'the items are stored when the transaction commits, but the charge happens right away, ' +
+                'so a rolled-back request would be billed for items that were never stored.');
+        }
         const dataset = await this.openDataset();
-        // Two code paths for charging:
-        // 1. Intercepted client: PpeAwareDatasetClient intercepts pushItems() calls, handling charging
-        //    internally. This is needed because Crawlee's Dataset may call pushItems() directly,
-        //    bypassing Actor.pushData(). We propagate eventName via AsyncLocalStorage context.
-        // 2. Direct charging: When using a non-patched client (e.g., forceCloud option or custom client),
-        //    we handle charging here before delegating to the dataset.
-        if (this.usesPushDataInterception(dataset)) {
-            return await this.pushDataViaInterceptedClient(dataset, item, eventName);
+        const items = Array.isArray(item) ? item : [item];
+        // `Actor.pushData()` historically worked even without calling `Actor.init()`.
+        // In that case, charging isn't configured, so just push the data through.
+        if (!this.#chargingManager.isInitialized) {
+            await dataset.pushData(items);
+            return { eventChargeLimitReached: false, chargedCount: 0, chargeableWithinLimit: {} };
         }
-        return await this.pushDataWithExplicitCharging(dataset, item, eventName);
+        // The reservation below and the charge that acts on it have to stay under one lock, so that
+        // a concurrent push cannot charge in between. The dataset backend re-enters the same lock to
+        // charge the synthetic per-item event.
+        return await this.#chargingManager.withChargeLock(async () => {
+            if (eventName === undefined) {
+                // Nothing to charge here - the dataset backend charges the synthetic event for
+                // whatever it stores, so the result is read back off the charging state.
+                const chargedBefore = this.#chargingManager.getChargedEventCount(DEFAULT_DATASET_ITEM_EVENT);
+                await dataset.pushData(items);
+                return {
+                    eventChargeLimitReached: this.#chargingManager.isEventChargeLimitReached(DEFAULT_DATASET_ITEM_EVENT),
+                    chargedCount: this.#chargingManager.getChargedEventCount(DEFAULT_DATASET_ITEM_EVENT) - chargedBefore,
+                    chargeableWithinLimit: this.#chargingManager.calculateChargeableWithinLimit(),
+                };
+            }
+            const limit = this.#chargingManager.calculatePushDataLimit(items.length, {
+                eventName,
+                // Pushing one item charges the synthetic per-item event too when the dataset backend
+                // is the charging one, so that price is part of what an item costs here.
+                isDefaultDataset: dataset.backend instanceof ChargingDatasetBackend,
+            });
+            if (limit === 0) {
+                return {
+                    eventChargeLimitReached: items.length > 0,
+                    chargedCount: 0,
+                    chargeableWithinLimit: this.#chargingManager.calculateChargeableWithinLimit(),
+                };
+            }
+            await dataset.pushData(limit < items.length ? items.slice(0, limit) : items);
+            return await this.#chargingManager.charge({ eventName, count: limit });
+        });
     }
     /**
      * Opens a dataset and returns a promise resolving to an instance of the {@link Dataset} class.
@@ -1600,51 +1645,56 @@ export class Actor {
     static setDefaultInstance(instance) {
         Actor.#instance = instance;
     }
-    usesPushDataInterception(dataset) {
-        return Boolean(dataset.backend[USES_PUSH_DATA_INTERCEPTION]);
-    }
-    async pushDataViaInterceptedClient(dataset, item, eventName) {
-        // PpeAwareDatasetClient will handle charging and item limiting.
-        // We only need to propagate `eventName` and (optionally) return aggregated charge info.
-        const context = {
-            eventName,
-        };
-        await pushDataChargingContext.run(context, async () => {
-            await dataset.pushData(item);
-        });
-        return (context.chargeResult ?? {
-            eventChargeLimitReached: false,
-            chargedCount: 0,
-            chargeableWithinLimit: {},
-        });
-    }
-    async pushDataWithExplicitCharging(dataset, items, explicitEventName) {
-        // `Actor.pushData()` historically worked even without calling `Actor.init()`.
-        // In that case, charging isn't configured, so just push the data through.
-        if (!this.initialized && explicitEventName === undefined) {
-            await dataset.pushData(items);
-            return {
-                eventChargeLimitReached: false,
-                chargedCount: 0,
-                chargeableWithinLimit: {},
-            };
+    /**
+     * The backend the Actor installs: the caller's, the platform's, or crawlee's local default.
+     *
+     * Only the last two are wrapped for dataset-item charging. The platform counts an
+     * `apify-default-dataset-item` per item written to the run's default dataset through Apify
+     * storage, so a caller-supplied backend is billed nothing and must not be accounted for -
+     * charging for it would spend a budget nobody is consuming and trim the caller's items to fit
+     * it. crawlee's local default stands in for Apify storage, so it is wrapped to keep local
+     * pay-per-event testing faithful.
+     *
+     * Wrapping means owning the instance, which is why the local default is constructed here
+     * rather than left to be created lazily on first use.
+     */
+    createStorageBackend(storage) {
+        if (storage) {
+            return storage;
+        }
+        if (this.isAtHome()) {
+            return this.createApifyStorageBackend();
         }
-        const isDefaultDataset = dataset.id === this.configuration.defaultDatasetId;
-        return pushDataAndCharge({
-            chargingManager: this.#chargingManager,
-            items,
-            eventName: explicitEventName,
-            isDefaultDataset,
-            pushFn: async (limitedItems) => dataset.pushData(limitedItems),
+        return new ChargingStorageBackend(new ServiceLocator(this.configuration).getStorageBackend(), {
+            configuration: this.configuration,
+            getChargingManager: () => this.#chargingManager,
         });
     }
+    /** Wrapped here rather than at the `init()` call site so that `forceCloud` storages are charged too. */
     createApifyStorageBackend() {
-        return new ApifyStorageBackend(this.apifyClient, {
+        const backend = new ApifyStorageBackend(this.apifyClient, {
             configuration: this.configuration,
             requestQueueAccess: this.#requestQueueAccess,
+        });
+        return new ChargingStorageBackend(backend, {
+            configuration: this.configuration,
             getChargingManager: () => this.#chargingManager,
         });
     }
+    /**
+     * crawlee's service locator is set-once, so a backend registered before `init()` wins and the
+     * Actor cannot install its own over it. Replaces the resulting `ServiceConflictError` with the
+     * way out.
+     */
+    installStorageBackend(backend) {
+        try {
+            serviceLocator.setStorageBackend(backend);
+        }
+        catch (error) {
+            throw new Error('A storage backend is already registered with crawlee, so the Actor cannot install its own. Pass it ' +
+                'as `Actor.init({ storage })` instead of calling `serviceLocator.setStorageBackend()`.', { cause: error });
+        }
+    }
     ensureActorInit(methodCalled) {
         // If we already warned the user once, don't do it again to prevent spam
         if (this.#warnedAboutMissingInitCall) {

package/dist/apify_storage_backend.d.ts

@@ -1,24 +1,10 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import type { DatasetBackend, KeyValueStoreBackend, RequestQueueBackend, StorageBackend, StorageIdentifier } from '@crawlee/types';
 import type { ApifyClient } from 'apify-client';
 import { type RequestQueueAccessMode } from './apify_request_queue_backend.js';
-import { type ChargeResult, type ChargingManager } from './charging.js';
 import type { Configuration } from './configuration.js';
 type StorageType = 'Dataset' | 'KeyValueStore' | 'RequestQueue';
-/** Marks a dataset backend whose underlying client charges for pushed items (pay-per-event). @internal */
-export declare const USES_PUSH_DATA_INTERCEPTION: unique symbol;
-/**
- * Context of a single `Actor.pushData()` call, shared with the intercepted
- * `pushItems()` calls so they can (1) know which event to charge and
- * (2) aggregate the {@link ChargeResult} across the multiple `pushItems()`
- * calls a single `pushData()` may trigger (the backend splits pushes exceeding
- * the API's payload size limit).
- */
-export interface PpeAwarePushDataContext {
-    eventName: string | undefined;
-    chargeResult?: ChargeResult;
-}
-export declare const pushDataChargingContext: AsyncLocalStorage<PpeAwarePushDataContext>;
+/** The reserved alias crawlee uses for the default (unnamed) storage. */
+export declare const DEFAULT_STORAGE_ALIAS = "__default__";
 export interface ApifyStorageBackendOptions {
     /**
      * SDK configuration providing the run's default storage ids and related environment values.
@@ -32,12 +18,6 @@ export interface ApifyStorageBackendOptions {
      * consumers can process the same queue safely.
      */
     requestQueueAccess?: RequestQueueAccessMode;
-    /**
-     * Supplies the charging manager for pay-per-event runs, enabling the charging-aware default
-     * dataset client.
-     * @internal
-     */
-    getChargingManager?: () => ChargingManager;
 }
 /**
  * Bridges `apify-client`'s synchronous resource accessors (`dataset(id)`,
@@ -45,10 +25,6 @@ export interface ApifyStorageBackendOptions {
  * `StorageBackend` interface (async factory methods accepting an `id`,
  * a `name`, or an `alias`).
  *
- * For the run's default dataset it transparently swaps in a charging-aware
- * dataset client (pay-per-event on `Actor.pushData()`), provided a charging
- * manager is supplied and a default-dataset-item price is configured.
- *
  * `Actor` wires this up automatically; construct it directly only to use Apify
  * platform storage with crawlee's storage classes outside of `Actor` — e.g. to
  * read another run's output with an explicit token:
@@ -82,12 +58,6 @@ export declare class ApifyStorageBackend implements StorageBackend {
      * migrated or resurrected run re-acquire the request locks of its previous incarnation.
      */
     private requestQueueClientKey;
-    /**
-     * Returns a charging-aware dataset client when `id` is the run's default
-     * dataset and a default-dataset-item price is configured; otherwise
-     * `undefined` (caller uses the plain client).
-     */
-    private chargingDatasetClient;
     /**
      * Resolves a crawlee {@link StorageIdentifier} to a platform storage id.
      *

package/dist/apify_storage_backend.js

@@ -1,7 +1,4 @@
-/* eslint-disable max-classes-per-file */
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHash } from 'node:crypto';
-import { DatasetClient as ApifyDatasetClient } from 'apify-client';
 import log from '@apify/log';
 import { cryptoRandomObjectId } from '@apify/utilities';
 import { ApifyDatasetBackend } from './apify_dataset_backend.js';
@@ -9,9 +6,8 @@ import { ApifyKeyValueStoreBackend } from './apify_key_value_store_backend.js';
 import { AsyncLock } from './apify_request_queue_backend.js';
 import { ApifyRequestQueueSharedBackend } from './apify_request_queue_shared_backend.js';
 import { ApifyRequestQueueSingleBackend } from './apify_request_queue_single_backend.js';
-import { DEFAULT_DATASET_ITEM_EVENT, mergeChargeResults, pushDataAndCharge, } from './charging.js';
 /** The reserved alias crawlee uses for the default (unnamed) storage. */
-const DEFAULT_STORAGE_ALIAS = '__default__';
+export const DEFAULT_STORAGE_ALIAS = '__default__';
 /** The key of the default key-value store record holding this run's alias -> storage id mapping. */
 const ALIAS_MAPPING_RECORD_KEY = '__STORAGE_ALIASES_MAPPING';
 async function readAliasMapping(store) {
@@ -30,62 +26,12 @@ const ACTOR_STORAGES_TYPE_KEY = {
     KeyValueStore: 'keyValueStores',
     RequestQueue: 'requestQueues',
 };
-/** Marks a dataset backend whose underlying client charges for pushed items (pay-per-event). @internal */
-export const USES_PUSH_DATA_INTERCEPTION = Symbol('apify:uses-push-data-interception');
-export const pushDataChargingContext = new AsyncLocalStorage();
-/**
- * Default `DatasetClient` that charges for pushed items (pay-per-event). Used
- * only for the run's default dataset when a `apify-default-dataset-item` price
- * is configured; for everything else the plain `apify-client` dataset client is
- * used.
- */
-class PpeAwareDatasetClient extends ApifyDatasetClient {
-    #getChargingManager;
-    constructor(options, getChargingManager) {
-        super(options);
-        this.#getChargingManager = getChargingManager;
-    }
-    normalizeItems(items) {
-        if (typeof items === 'string') {
-            const parsed = JSON.parse(items);
-            return Array.isArray(parsed) ? parsed : [parsed];
-        }
-        if (Array.isArray(items)) {
-            return items.flatMap((item) => typeof item === 'string' ? JSON.parse(item) : item);
-        }
-        return [items];
-    }
-    async pushItems(items) {
-        const context = pushDataChargingContext.getStore();
-        // A single JSON string may encode multiple items (e.g. '[{...},{...}]'),
-        // which the charging logic would miscount — parse strings into arrays so
-        // each logical item is counted individually.
-        const normalizedItems = this.normalizeItems(items);
-        const result = await pushDataAndCharge({
-            chargingManager: this.#getChargingManager(),
-            items: normalizedItems,
-            eventName: context?.eventName,
-            isDefaultDataset: true,
-            // stringify for faster validation in the Apify client
-            pushFn: async (limitedItems) => super.pushItems(JSON.stringify(limitedItems)),
-        });
-        if (!context)
-            return;
-        // One `Actor.pushData()` may map to several `pushItems()` calls — aggregate.
-        context.chargeResult =
-            context.chargeResult === undefined ? result : mergeChargeResults(context.chargeResult, result);
-    }
-}
 /**
  * Bridges `apify-client`'s synchronous resource accessors (`dataset(id)`,
  * `keyValueStore(id)`, `requestQueue(id, options?)`) to crawlee v4's
  * `StorageBackend` interface (async factory methods accepting an `id`,
  * a `name`, or an `alias`).
  *
- * For the run's default dataset it transparently swaps in a charging-aware
- * dataset client (pay-per-event on `Actor.pushData()`), provided a charging
- * manager is supplied and a default-dataset-item price is configured.
- *
  * `Actor` wires this up automatically; construct it directly only to use Apify
  * platform storage with crawlee's storage classes outside of `Actor` — e.g. to
  * read another run's output with an explicit token:
@@ -102,7 +48,6 @@ export class ApifyStorageBackend {
     #client;
     #config;
     #requestQueueAccess;
-    #getChargingManager;
     /** Unnamed storages resolved for aliases in this process, keyed like {@link AliasMapping}. */
     #aliasIdCache = new Map();
     /** The alias mapping read from the run's default key-value store; `undefined` until first read. */
@@ -115,7 +60,6 @@ export class ApifyStorageBackend {
         this.#client = client;
         this.#config = options.configuration;
         this.#requestQueueAccess = options.requestQueueAccess ?? 'single';
-        this.#getChargingManager = options.getChargingManager;
     }
     /**
      * Partitions crawlee's storage-instance cache by API base URL and token, so the same storage
@@ -144,14 +88,7 @@ export class ApifyStorageBackend {
     }
     async createDatasetBackend(options) {
         const id = await this.resolveId(options, 'Dataset');
-        const chargingClient = this.chargingDatasetClient(id);
-        const backend = new ApifyDatasetBackend(chargingClient ?? this.#client.dataset(id));
-        if (chargingClient) {
-            // `Actor.pushData()` looks for this marker on the dataset's backend to know the
-            // pay-per-event charging happens inside the intercepted `pushItems()` calls.
-            Object.assign(backend, { [USES_PUSH_DATA_INTERCEPTION]: true });
-        }
-        return backend;
+        return new ApifyDatasetBackend(this.#client.dataset(id));
     }
     async createKeyValueStoreBackend(options) {
         const id = await this.resolveId(options, 'KeyValueStore');
@@ -172,28 +109,6 @@ export class ApifyStorageBackend {
         const key = this.#config?.actorRunId ?? (this.#fallbackClientKey ??= cryptoRandomObjectId(MAX_CLIENT_KEY_LENGTH));
         return key.slice(0, MAX_CLIENT_KEY_LENGTH);
     }
-    /**
-     * Returns a charging-aware dataset client when `id` is the run's default
-     * dataset and a default-dataset-item price is configured; otherwise
-     * `undefined` (caller uses the plain client).
-     */
-    chargingDatasetClient(id) {
-        const getChargingManager = this.#getChargingManager;
-        if (!getChargingManager)
-            return undefined;
-        if (id !== this.#config?.defaultDatasetId)
-            return undefined;
-        const hasDefaultDatasetItemEvent = DEFAULT_DATASET_ITEM_EVENT in getChargingManager().getPricingInfo().perEventPrices;
-        if (!hasDefaultDatasetItemEvent)
-            return undefined;
-        return new PpeAwareDatasetClient({
-            id,
-            baseUrl: this.#client.baseUrl,
-            publicBaseUrl: this.#client.publicBaseUrl,
-            apifyClient: this.#client,
-            httpClient: this.#client.httpClient,
-        }, getChargingManager);
-    }
     /**
      * Resolves a crawlee {@link StorageIdentifier} to a platform storage id.
      *

package/dist/charging.d.ts

@@ -12,6 +12,11 @@ export interface ChargeOptions {
      * @default 1
      */
     count?: number;
+    /**
+     * Repeated charges sharing a key are billed once - e.g. a request handler rerun by a retry.
+     * Local accounting still counts every call, so the remaining budget comes out underestimated.
+     */
+    idempotencyKey?: string;
 }
 export interface ChargeResult {
     /**
@@ -49,14 +54,14 @@ export interface ActorPricingInfo {
     isPayPerEvent: boolean;
     perEventPrices: Record<string, number>;
 }
-export declare function mergeChargeResults(a: ChargeResult, b: ChargeResult): ChargeResult;
 /**
  * Handles pay-per-event charging.
  */
 export declare class ChargingManager {
     #private;
     constructor(configuration: Configuration, apifyClient: ApifyClient);
-    private get isPayPerEvent();
+    /** A shortcut - true if the Actor runs with the pay-per-event pricing model. */
+    get isPayPerEvent(): boolean;
     private fetchPricingInfo;
     /**
      * Initialize the ChargingManager by loading pricing information and charging state via Apify API.
@@ -88,7 +93,7 @@ export declare class ChargingManager {
      *
      * @param options The name of the event to charge for and the number of events to be charged.
      */
-    charge({ eventName, count }: ChargeOptions): Promise<ChargeResult>;
+    charge({ eventName, count, idempotencyKey }: ChargeOptions): Promise<ChargeResult>;
     /**
      * Get the number of events with given name that the Actor has charged for so far.
      */
@@ -106,31 +111,35 @@ export declare class ChargingManager {
     private calculateEventPrice;
     private calculateMaxChargesByPrice;
     /**
-     * Helper to calculate how many items can be pushed within charging limits.
-     * Returns the limited items and count to charge.
-     */
-    calculatePushDataLimits<T>({ items, eventName, isDefaultDataset, }: {
-        items: T | T[];
-        eventName: string | undefined;
-        isDefaultDataset: boolean;
-    }): {
-        limitedItems: T[];
-        eventsToCharge: Record<string, number>;
-    };
+     * Whether the remaining budget is insufficient to charge even a single event of the given type.
+     * Always false when nothing is charged in the first place.
+     */
+    isEventChargeLimitReached(eventName: string): boolean;
+    /**
+     * How many events of each known type can still be charged within the limit.
+     */
+    calculateChargeableWithinLimit(): Record<string, number>;
+    /**
+     * How many of `itemsCount` items may be pushed to a dataset within the remaining budget.
+     *
+     * The budget is measured against the combined per-item price of the explicit `eventName` and - on
+     * the default dataset - the synthetic {@link DEFAULT_DATASET_ITEM_EVENT}, since pushing one item
+     * charges both.
+     *
+     * When the budget cannot cover a single item, one item is still allowed through so that the
+     * resulting overcharge makes the platform terminate the run - unless the run is already strictly
+     * over budget, in which case nothing is allowed through.
+     */
+    calculatePushDataLimit(itemsCount: number, { eventName, isDefaultDataset }?: {
+        eventName?: string;
+        isDefaultDataset?: boolean;
+    }): number;
+    /**
+     * Runs `fn` under the charge lock, which keeps a limit reservation and the charge that acts on it
+     * atomic against concurrent pushes. Only pay-per-event runs charge anything, so for every other
+     * run there is nothing to serialize and the lock is skipped.
+     *
+     * @internal
+     */
+    withChargeLock<T>(fn: () => Promise<T>): Promise<T>;
 }
-/**
- * Helper for PPE-aware pushing of data to the dataset.
- *
- * 1. Calculate limits based on budget
- * 2. Push limited items via the provided callback
- * 3. Charge for the events
- *
- * @internal
- */
-export declare function pushDataAndCharge<T>({ chargingManager, items, eventName, isDefaultDataset, pushFn, }: {
-    chargingManager: ChargingManager;
-    items: T | T[];
-    eventName: string | undefined;
-    isDefaultDataset: boolean;
-    pushFn: (limitedItems: T | T[]) => Promise<void>;
-}): Promise<ChargeResult>;

package/dist/charging.js

@@ -1,15 +1,23 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Dataset, KeyValueStore } from '@crawlee/core';
 import log from '@apify/log';
 export const DEFAULT_DATASET_ITEM_EVENT = 'apify-default-dataset-item';
-export function mergeChargeResults(a, b) {
-    return {
-        eventChargeLimitReached: a.eventChargeLimitReached || b.eventChargeLimitReached,
-        chargedCount: a.chargedCount + b.chargedCount,
-        chargeableWithinLimit: Object.fromEntries(Object.entries(a.chargeableWithinLimit).map(([key, oldValue]) => [
-            key,
-            Math.min(oldValue, b.chargeableWithinLimit[key]),
-        ])),
-    };
+/**
+ * A FIFO mutex that a critical section may re-enter from a nested call — the charge lock is taken by
+ * `Actor.pushData()` and again, one level down, by the dataset backend it pushes through.
+ */
+class ReentrantAsyncLock {
+    #tail = Promise.resolve();
+    #held = new AsyncLocalStorage();
+    async runExclusive(fn) {
+        if (this.#held.getStore()) {
+            return await fn();
+        }
+        const run = this.#tail.then(async () => this.#held.run(true, fn));
+        // Keep the chain alive even when the critical section throws.
+        this.#tail = run.catch(() => { });
+        return await run;
+    }
 }
 /**
  * Handles pay-per-event charging.
@@ -27,6 +35,7 @@ export class ChargingManager {
     #pricingInfo = {};
     #chargingState;
     #chargingLogDataset;
+    #chargeLock = new ReentrantAsyncLock();
     #apifyClient;
     #configuration;
     constructor(configuration, apifyClient) {
@@ -38,6 +47,7 @@ export class ChargingManager {
         this.#useChargingLogDataset = configuration.useChargingLogDataset;
         this.#apifyClient = apifyClient;
     }
+    /** A shortcut - true if the Actor runs with the pay-per-event pricing model. */
     get isPayPerEvent() {
         return this.#pricingModel === 'PAY_PER_EVENT';
     }
@@ -170,11 +180,7 @@ export class ChargingManager {
      *
      * @param options The name of the event to charge for and the number of events to be charged.
      */
-    async charge({ eventName, count = 1 }) {
-        const calculateChargeableWithinLimit = () => Object.fromEntries(Object.keys(this.#pricingInfo).map((name) => [
-            name,
-            this.calculateMaxEventChargeCountWithinLimit(name),
-        ]));
+    async charge({ eventName, count = 1, idempotencyKey }) {
         if (!this.isPayPerEvent) {
             if (!this.#notPpeWarningPrinted) {
                 log.warning('Ignored attempt to charge for an event - the Actor does not use the pay-per-event pricing');
@@ -183,75 +189,79 @@ export class ChargingManager {
             return {
                 eventChargeLimitReached: false,
                 chargedCount: 0,
-                chargeableWithinLimit: calculateChargeableWithinLimit(),
+                chargeableWithinLimit: this.calculateChargeableWithinLimit(),
             };
         }
-        if (this.#chargingState === undefined) {
+        const chargingState = this.#chargingState;
+        if (chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
-        /* START OF CRITICAL SECTION - no awaits here */
-        const maxEventChargeCount = this.calculateMaxEventChargeCountWithinLimit(eventName);
-        const chargedCount = (() => {
-            if (count <= maxEventChargeCount) {
-                return count;
-            }
-            // If the caller tries to charge more than the budget allows, overcharge by one event
-            // so that the Actor is detected by the platform and terminated.
-            // But don't do this if already strictly over the budget - no point piling on charges.
-            if (this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd) {
-                return maxEventChargeCount + 1;
+        return await this.withChargeLock(async () => {
+            const maxEventChargeCount = this.calculateMaxEventChargeCountWithinLimit(eventName);
+            const chargedCount = (() => {
+                if (count <= maxEventChargeCount) {
+                    return count;
+                }
+                // If the caller tries to charge more than the budget allows, overcharge by one event
+                // so that the Actor is detected by the platform and terminated.
+                // But don't do this if already strictly over the budget - no point piling on charges.
+                if (this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd) {
+                    return maxEventChargeCount + 1;
+                }
+                return 0;
+            })();
+            if (chargedCount === 0) {
+                return {
+                    eventChargeLimitReached: count > 0, // Only true if user wanted to charge but couldn't
+                    chargedCount: 0,
+                    chargeableWithinLimit: this.calculateChargeableWithinLimit(),
+                };
             }
-            return 0;
-        })();
-        if (chargedCount === 0) {
-            return {
-                eventChargeLimitReached: count > 0, // Only true if user wanted to charge but couldn't
-                chargedCount: 0,
-                chargeableWithinLimit: calculateChargeableWithinLimit(),
+            const pricingInfo = this.#pricingInfo[eventName] ?? {
+                price: this.#isAtHome ? 0 : 1, // Use a nonzero price for local development so that the maximum budget can be reached
+                title: `Unknown event '${eventName}'`,
             };
-        }
-        const pricingInfo = this.#pricingInfo[eventName] ?? {
-            price: this.#isAtHome ? 0 : 1, // Use a nonzero price for local development so that the maximum budget can be reached
-            title: `Unknown event '${eventName}'`,
-        };
-        this.#chargingState[eventName] ??= {
-            chargeCount: 0,
-            totalChargedAmount: 0,
-        };
-        this.#chargingState[eventName].chargeCount += chargedCount;
-        this.#chargingState[eventName].totalChargedAmount += chargedCount * pricingInfo.price;
-        /* END OF CRITICAL SECTION */
-        if (this.#isAtHome) {
-            if (eventName.startsWith('apify-')) {
-                // Synthetic events (e.g. apify-default-dataset-item) are tracked locally only,
-                // the platform handles them automatically based on dataset writes.
+            chargingState[eventName] ??= {
+                chargeCount: 0,
+                totalChargedAmount: 0,
+            };
+            chargingState[eventName].chargeCount += chargedCount;
+            chargingState[eventName].totalChargedAmount += chargedCount * pricingInfo.price;
+            if (this.#isAtHome) {
+                if (eventName.startsWith('apify-')) {
+                    // Synthetic events (e.g. apify-default-dataset-item) are tracked locally only,
+                    // the platform handles them automatically based on dataset writes.
+                }
+                else if (this.#pricingInfo[eventName] !== undefined) {
+                    await this.#apifyClient.run(this.#actorRunId).charge({
+                        eventName,
+                        count: chargedCount,
+                        idempotencyKey,
+                    });
+                }
+                else {
+                    log.warning(`Attempting to charge for an unknown event '${eventName}'`);
+                }
             }
-            else if (this.#pricingInfo[eventName] !== undefined) {
-                await this.#apifyClient.run(this.#actorRunId).charge({ eventName, count: chargedCount });
+            if (this.#chargingLogDataset !== undefined) {
+                await this.#chargingLogDataset.pushData({
+                    eventName,
+                    eventTitle: pricingInfo.title,
+                    eventPriceUsd: pricingInfo.price,
+                    chargedCount,
+                    timestamp: new Date().toISOString(),
+                });
             }
-            else {
-                log.warning(`Attempting to charge for an unknown event '${eventName}'`);
+            if (chargedCount < count) {
+                const subject = count === 1 ? 'instance' : 'instances';
+                log.info(`Charging ${count} ${subject} of '${eventName}' event would exceed maxTotalChargeUsd - only ${chargedCount} events were charged`);
             }
-        }
-        const timestamp = new Date().toISOString();
-        if (this.#chargingLogDataset !== undefined) {
-            await this.#chargingLogDataset.pushData({
-                eventName,
-                eventTitle: pricingInfo.title,
-                eventPriceUsd: pricingInfo.price,
+            return {
+                eventChargeLimitReached: this.isEventChargeLimitReached(eventName),
                 chargedCount,
-                timestamp,
-            });
-        }
-        if (chargedCount < count) {
-            const subject = count === 1 ? 'instance' : 'instances';
-            log.info(`Charging ${count} ${subject} of '${eventName}' event would exceed maxTotalChargeUsd - only ${chargedCount} events were charged`);
-        }
-        return {
-            eventChargeLimitReached: this.calculateMaxEventChargeCountWithinLimit(eventName) <= 0,
-            chargedCount,
-            chargeableWithinLimit: calculateChargeableWithinLimit(),
-        };
+                chargeableWithinLimit: this.calculateChargeableWithinLimit(),
+            };
+        });
     }
     /**
      * Get the number of events with given name that the Actor has charged for so far.
@@ -306,86 +316,58 @@ export class ChargingManager {
         return Math.max(0, roundedResult);
     }
     /**
-     * Helper to calculate how many items can be pushed within charging limits.
-     * Returns the limited items and count to charge.
+     * Whether the remaining budget is insufficient to charge even a single event of the given type.
+     * Always false when nothing is charged in the first place.
      */
-    calculatePushDataLimits({ items, eventName, isDefaultDataset, }) {
+    isEventChargeLimitReached(eventName) {
+        return this.isPayPerEvent && this.calculateMaxEventChargeCountWithinLimit(eventName) <= 0;
+    }
+    /**
+     * How many events of each known type can still be charged within the limit.
+     */
+    calculateChargeableWithinLimit() {
+        return Object.fromEntries(Object.keys(this.#pricingInfo).map((name) => [name, this.calculateMaxEventChargeCountWithinLimit(name)]));
+    }
+    /**
+     * How many of `itemsCount` items may be pushed to a dataset within the remaining budget.
+     *
+     * The budget is measured against the combined per-item price of the explicit `eventName` and - on
+     * the default dataset - the synthetic {@link DEFAULT_DATASET_ITEM_EVENT}, since pushing one item
+     * charges both.
+     *
+     * When the budget cannot cover a single item, one item is still allowed through so that the
+     * resulting overcharge makes the platform terminate the run - unless the run is already strictly
+     * over budget, in which case nothing is allowed through.
+     */
+    calculatePushDataLimit(itemsCount, { eventName, isDefaultDataset = false } = {}) {
         if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
-        const itemsArray = Array.isArray(items) ? items : [items];
-        if (!this.isPayPerEvent) {
-            return {
-                limitedItems: itemsArray,
-                eventsToCharge: {},
-            };
+        if (!this.isPayPerEvent || itemsCount === 0) {
+            return itemsCount;
         }
-        const itemPrice = ((eventName !== undefined ? this.calculateEventPrice(eventName) : undefined) ?? 0) +
-            ((isDefaultDataset ? this.calculateEventPrice(DEFAULT_DATASET_ITEM_EVENT) : undefined) ?? 0);
-        const maxChargedCount = itemPrice > 0 ? this.calculateMaxChargesByPrice(itemPrice) : Infinity;
-        const itemsToKeep = (() => {
-            if (maxChargedCount >= itemsArray.length) {
-                return itemsArray.length;
-            }
-            // If the caller tries to push items even though the limit is depleted, overcharge by one
-            // so that the Platform terminates the run.
-            // But don't do this if already strictly over the budget - no point piling on charges.
-            if (itemsArray.length > 0 &&
-                maxChargedCount === 0 &&
-                this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd) {
-                return 1;
-            }
-            return maxChargedCount;
-        })();
-        const eventsToCharge = {};
-        if (eventName !== undefined && itemsToKeep > 0) {
-            eventsToCharge[eventName] = itemsToKeep;
+        const itemPrice = (eventName === undefined ? 0 : (this.calculateEventPrice(eventName) ?? 0)) +
+            (isDefaultDataset ? (this.calculateEventPrice(DEFAULT_DATASET_ITEM_EVENT) ?? 0) : 0);
+        if (itemPrice === 0) {
+            return itemsCount;
         }
-        if (isDefaultDataset && itemsToKeep > 0) {
-            eventsToCharge[DEFAULT_DATASET_ITEM_EVENT] = itemsToKeep;
+        const maxChargedCount = this.calculateMaxChargesByPrice(itemPrice);
+        if (maxChargedCount >= itemsCount) {
+            return itemsCount;
         }
-        return {
-            limitedItems: itemsToKeep >= itemsArray.length ? itemsArray : itemsArray.slice(0, itemsToKeep),
-            eventsToCharge,
-        };
-    }
-}
-/**
- * Helper for PPE-aware pushing of data to the dataset.
- *
- * 1. Calculate limits based on budget
- * 2. Push limited items via the provided callback
- * 3. Charge for the events
- *
- * @internal
- */
-export async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultDataset, pushFn, }) {
-    const { limitedItems, eventsToCharge } = chargingManager.calculatePushDataLimits({
-        items,
-        eventName,
-        isDefaultDataset,
-    });
-    if (limitedItems.length > 0) {
-        // Preserve original call shape for single items
-        await pushFn(Array.isArray(items) ? limitedItems : limitedItems[0]);
+        if (maxChargedCount > 0) {
+            return maxChargedCount;
+        }
+        return this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd ? 1 : 0;
     }
-    if (Object.keys(eventsToCharge).length > 0) {
-        const results = {};
-        await Promise.all(Object.entries(eventsToCharge).map(async ([name, count]) => {
-            results[name] = await chargingManager.charge({
-                eventName: name,
-                count,
-            });
-        }));
-        // Merge all charge results so that eventChargeLimitReached reflects
-        // whether ANY of the charged events hit their limit.
-        return Object.values(results).reduce(mergeChargeResults);
+    /**
+     * Runs `fn` under the charge lock, which keeps a limit reservation and the charge that acts on it
+     * atomic against concurrent pushes. Only pay-per-event runs charge anything, so for every other
+     * run there is nothing to serialize and the lock is skipped.
+     *
+     * @internal
+     */
+    async withChargeLock(fn) {
+        return this.isPayPerEvent ? await this.#chargeLock.runExclusive(fn) : await fn();
     }
-    const itemsArray = Array.isArray(items) ? items : [items];
-    const allItemsTrimmed = itemsArray.length > 0 && limitedItems.length === 0;
-    return {
-        eventChargeLimitReached: allItemsTrimmed,
-        chargedCount: 0,
-        chargeableWithinLimit: {},
-    };
 }

package/dist/charging_storage_backend.d.ts

@@ -0,0 +1,53 @@
+import type { DatasetBackend, DatasetBackendListOptions, DatasetInfo, Dictionary, KeyValueStoreBackend, PaginatedList, RequestQueueBackend, StorageBackend, StorageIdentifier } from '@crawlee/types';
+import type { ChargingManager } from './charging.js';
+import type { Configuration } from './configuration.js';
+export interface ChargingStorageBackendOptions {
+    /** Supplies the run's default dataset id, which is the only dataset charged for. */
+    configuration: Configuration;
+    /** Resolved per push, as the charging manager only knows the pricing once `Actor.init()` has run. */
+    getChargingManager: () => ChargingManager;
+}
+/**
+ * Charges the synthetic `apify-default-dataset-item` event for the items it stores, trimming a push
+ * that the remaining budget cannot cover.
+ *
+ * It wraps the whole dataset backend rather than its API calls, so that a push split into several
+ * payload-sized requests is still counted and charged exactly once.
+ *
+ * @internal
+ */
+export declare class ChargingDatasetBackend implements DatasetBackend {
+    #private;
+    constructor(inner: DatasetBackend, getChargingManager: () => ChargingManager);
+    getMetadata(): Promise<DatasetInfo>;
+    drop(): Promise<void>;
+    purge(): Promise<void>;
+    getData(options?: DatasetBackendListOptions): Promise<PaginatedList<Dictionary>>;
+    pushData(items: Dictionary[]): Promise<void>;
+}
+/**
+ * Wraps another storage backend so that items pushed to the run's default dataset are charged for
+ * under the pay-per-event pricing model.
+ *
+ * Charging belongs here rather than in `Actor.pushData()` because `Dataset.pushData()` is also
+ * called directly - by user code and by crawlee itself (`context.pushData()`) - and every item that
+ * reaches the default dataset is billed by the platform regardless of who pushed it.
+ *
+ * @internal
+ */
+export declare class ChargingStorageBackend implements StorageBackend {
+    #private;
+    storageExists?: StorageBackend['storageExists'];
+    purge?: StorageBackend['purge'];
+    teardown?: StorageBackend['teardown'];
+    constructor(inner: StorageBackend, options: ChargingStorageBackendOptions);
+    get stats(): {
+        rateLimitErrors: number[];
+    } | undefined;
+    /** Repeats crawlee's own fallback, so that wrapping a backend does not change how storages are cached. */
+    getStorageBackendCacheKey(): string;
+    createDatasetBackend(options?: StorageIdentifier): Promise<DatasetBackend>;
+    createKeyValueStoreBackend(options?: StorageIdentifier): Promise<KeyValueStoreBackend>;
+    createRequestQueueBackend(options?: StorageIdentifier): Promise<RequestQueueBackend>;
+    private isDefaultDataset;
+}

package/dist/charging_storage_backend.js

@@ -0,0 +1,105 @@
+import { DEFAULT_DATASET_ITEM_EVENT } from './charging.js';
+import { DEFAULT_STORAGE_ALIAS } from './apify_storage_backend.js';
+/**
+ * Charges the synthetic `apify-default-dataset-item` event for the items it stores, trimming a push
+ * that the remaining budget cannot cover.
+ *
+ * It wraps the whole dataset backend rather than its API calls, so that a push split into several
+ * payload-sized requests is still counted and charged exactly once.
+ *
+ * @internal
+ */
+export class ChargingDatasetBackend {
+    #inner;
+    #getChargingManager;
+    constructor(inner, getChargingManager) {
+        this.#inner = inner;
+        this.#getChargingManager = getChargingManager;
+    }
+    async getMetadata() {
+        return await this.#inner.getMetadata();
+    }
+    async drop() {
+        await this.#inner.drop();
+    }
+    async purge() {
+        await this.#inner.purge();
+    }
+    async getData(options) {
+        return await this.#inner.getData(options);
+    }
+    async pushData(items) {
+        const chargingManager = this.#getChargingManager();
+        // `Dataset.pushData()` also works without `Actor.init()`, where there is no charging state yet.
+        if (items.length === 0 || !chargingManager.isInitialized || !chargingManager.isPayPerEvent) {
+            await this.#inner.pushData(items);
+            return;
+        }
+        await chargingManager.withChargeLock(async () => {
+            const limit = chargingManager.calculatePushDataLimit(items.length, { isDefaultDataset: true });
+            if (limit === 0) {
+                return;
+            }
+            await this.#inner.pushData(limit < items.length ? items.slice(0, limit) : items);
+            await chargingManager.charge({ eventName: DEFAULT_DATASET_ITEM_EVENT, count: limit });
+        });
+    }
+}
+/**
+ * Wraps another storage backend so that items pushed to the run's default dataset are charged for
+ * under the pay-per-event pricing model.
+ *
+ * Charging belongs here rather than in `Actor.pushData()` because `Dataset.pushData()` is also
+ * called directly - by user code and by crawlee itself (`context.pushData()`) - and every item that
+ * reaches the default dataset is billed by the platform regardless of who pushed it.
+ *
+ * @internal
+ */
+export class ChargingStorageBackend {
+    storageExists;
+    purge;
+    teardown;
+    #inner;
+    #options;
+    constructor(inner, options) {
+        this.#inner = inner;
+        this.#options = options;
+        // Crawlee branches on the presence of these, so they have to stay absent when `inner` lacks them.
+        const { storageExists, purge, teardown } = inner;
+        if (storageExists)
+            this.storageExists = async (id, type) => storageExists.call(inner, id, type);
+        if (purge)
+            this.purge = async () => purge.call(inner);
+        if (teardown)
+            this.teardown = async () => teardown.call(inner);
+    }
+    get stats() {
+        return this.#inner.stats;
+    }
+    /** Repeats crawlee's own fallback, so that wrapping a backend does not change how storages are cached. */
+    getStorageBackendCacheKey() {
+        return this.#inner.getStorageBackendCacheKey?.() ?? this.#inner.constructor.name;
+    }
+    async createDatasetBackend(options) {
+        const backend = await this.#inner.createDatasetBackend(options);
+        if (!this.isDefaultDataset(options)) {
+            return backend;
+        }
+        return new ChargingDatasetBackend(backend, this.#options.getChargingManager);
+    }
+    async createKeyValueStoreBackend(options) {
+        return await this.#inner.createKeyValueStoreBackend(options);
+    }
+    async createRequestQueueBackend(options) {
+        return await this.#inner.createRequestQueueBackend(options);
+    }
+    isDefaultDataset(options) {
+        if (!options)
+            return true;
+        if (options.alias !== undefined)
+            return options.alias === DEFAULT_STORAGE_ALIAS;
+        if (options.id !== undefined)
+            return options.id === this.#options.configuration.defaultDatasetId;
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify",
-  "version": "4.0.0-beta.33",
+  "version": "4.0.0-beta.34",
   "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
   "engines": {
     "node": ">=22.0.0"