@crawlee/basic 4.0.0-beta.103 → 4.0.0-beta.105

package/internals/basic-crawler.d.ts

@@ -1,7 +1,8 @@
-import type { AddRequestsBatchedOptions, AddRequestsBatchedResult, ConcurrencySystemOptions, Configuration, CrawleeLogger, CrawlingContext, DatasetExportOptions, EnqueueLinksOptions, EventManager, FinalStatistics, GetUserDataFromRequest, IConcurrencySystem, IProxyConfiguration, IRequestLoader, IRequestManager, IStatistics, Request, RequestsLike, RouterHandler, RouterRoutes, SkippedRequestCallback, Source, StatisticState, StorageIdentifier, TaskLoopPredicates, TypedRequestsLike } from '@crawlee/core';
+import type { AddRequestsBatchedOptions, AddRequestsBatchedResult, ConcurrencySystemOptions, Configuration, CrawleeLogger, CrawlingContext, DatasetExportOptions, EnqueueLinksOptions, EventManager, FinalStatistics, GetUserDataFromRequest, IConcurrencySystem, IProxyConfiguration, IRequestLoader, IRequestManager, IStatistics, Request, RequestsLike, RouterHandler, RouterRoutes, SkippedRequestCallback, Source, StatisticState, StorageIdentifier, StorageWritePolicy, TaskLoopPredicates, TypedRequestsLike } from '@crawlee/core';
 import { ConcurrencySystem, ContextPipeline, Dataset, RequestQueue } from '@crawlee/core';
 import type { Awaitable, BaseHttpClient, BatchAddRequestsResult, Dictionary, ISession, ISessionPool, ProxyInfo, SetStatusMessageOptions, StorageBackend } from '@crawlee/types';
 import { RobotsTxtFile } from '@crawlee/utils';
+import { type BasePredicate } from 'ow';
 import type { ReadonlyDeep, SetRequired } from 'type-fest';
 import { TimeoutError } from '@apify/timeout';
 export interface BasicCrawlingContext<UserData extends Dictionary = Dictionary> extends CrawlingContext<UserData> {
@@ -314,6 +315,20 @@ export interface BasicCrawlerOptions<Context extends CrawlingContext = CrawlingC
      *
      */
     id?: string;
+    /**
+     * Makes the storage writes performed while handling a request atomic with respect to the request
+     * succeeding: they are recorded in a {@link StorageTransaction} spanning the whole request
+     * lifecycle and only applied when the request handler succeeds, so a thrown handler leaves no partial
+     * writes behind and a retry does not double-write. Reads within the handler see its own writes.
+     *
+     * `false` disables the mechanism entirely; an object overrides the per-storage-type
+     * {@link StorageWritePolicy} (e.g. `{ requestQueue: 'deferred' }` for all-or-nothing enqueues).
+     * {@link withDirectStorageAccess} is the per-call-site escape hatch; `useState()` is deliberately
+     * *not* transactional.
+     *
+     * @default true
+     */
+    transactionalStorage?: boolean | Partial<StorageWritePolicy>;
     /**
      * An array of HTTP response [Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) to be excluded from error consideration.
      * By default, status codes >= 500 trigger errors.
@@ -538,6 +553,10 @@ export declare class BasicCrawler<Context extends CrawlingContext = CrawlingCont
     protected readonly httpClient: BaseHttpClient;
     protected readonly retryOnBlocked: boolean;
     private respectRobotsTxtFile;
+    /** Whether `runInStorageTransaction()` opens a transaction at all. */
+    private readonly transactionalStorageEnabled;
+    /** The resolved per-storage-type write policy overrides forwarded to each request's transaction. */
+    private readonly storageWritePolicy;
     protected readonly onSkippedRequest?: SkippedRequestCallback;
     private _closeEvents?;
     private loggedPerRun;
@@ -546,41 +565,41 @@ export declare class BasicCrawler<Context extends CrawlingContext = CrawlingCont
     private readonly contextPipelineOptions;
     protected static optionsShape: {
 // @ts-ignore optional peer dependency or compatibility with es2022
-        contextPipelineBuilder: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        contextPipelineBuilder: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        extendContext: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        extendContext: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        requestList: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        requestList: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        requestQueue: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        requestQueue: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        requestHandler: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        requestHandler: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        requestHandlerTimeoutSecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        requestHandlerTimeoutSecs: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        errorHandler: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        errorHandler: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        failedRequestHandler: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        failedRequestHandler: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        maxRequestRetries: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxRequestRetries: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        sameDomainDelaySecs: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        sameDomainDelaySecs: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        maxRequestsPerCrawl: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxRequestsPerCrawl: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        maxCrawlDepth: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxCrawlDepth: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        taskLoopOptions: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        taskLoopOptions: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        concurrencySystem: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        concurrencySystem: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        sessionPool: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        sessionPool: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        proxyConfiguration: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        proxyConfiguration: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        statusMessageLoggingInterval: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        statusMessageLoggingInterval: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        statusMessageCallback: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        statusMessageCallback: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
         additionalHttpErrorStatusCodes: import("ow").ArrayPredicate<number>;
 // @ts-ignore optional peer dependency or compatibility with es2022
@@ -588,33 +607,34 @@ export declare class BasicCrawler<Context extends CrawlingContext = CrawlingCont
 // @ts-ignore optional peer dependency or compatibility with es2022
         blockedStatusCodes: import("ow").ArrayPredicate<number>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        retryOnBlocked: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        retryOnBlocked: import("ow").BooleanPredicate & BasePredicate<boolean | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
         respectRobotsTxtFile: import("ow").AnyPredicate<boolean | object>;
+        transactionalStorage: BasePredicate<boolean | Partial<StorageWritePolicy> | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        onSkippedRequest: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
+        onSkippedRequest: import("ow").Predicate<Function> & BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        httpClient: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        httpClient: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        configuration: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        configuration: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        storageBackend: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        storageBackend: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        eventManager: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        eventManager: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        logger: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        logger: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        minConcurrency: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        minConcurrency: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        maxConcurrency: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxConcurrency: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        maxRequestsPerMinute: import("ow").NumberPredicate & import("ow").BasePredicate<number | undefined>;
+        maxRequestsPerMinute: import("ow").NumberPredicate & BasePredicate<number | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        keepAlive: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
+        keepAlive: import("ow").BooleanPredicate & BasePredicate<boolean | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        statistics: import("ow").ObjectPredicate<object> & import("ow").BasePredicate<object | undefined>;
+        statistics: import("ow").ObjectPredicate<object> & BasePredicate<object | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        id: import("ow").StringPredicate & import("ow").BasePredicate<string | undefined>;
+        id: import("ow").StringPredicate & BasePredicate<string | undefined>;
     };
     /**
      * All `BasicCrawler` parameters are passed via an options object.
@@ -801,6 +821,12 @@ export declare class BasicCrawler<Context extends CrawlingContext = CrawlingCont
      */
     private getRouteTimeoutMillis;
     protected runRequestHandler(crawlingContext: ExtendedContext): Promise<void>;
+    /**
+     * Runs `callback` inside a {@link StorageTransaction}, unless transactional storage is disabled.
+     * Deliberately does **not** commit on return - `handleRequest` swallows request handler failures, so
+     * a normal return says nothing about success. `handleRequest` owns the outcome.
+     */
+    private runInStorageTransaction;
     /**
      * Handles blocked request
      */

package/internals/basic-crawler.js

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
-import { AutoscaledPool, bindMethodsToServiceLocator, BLOCKED_STATUS_CODES, ConcurrencySystem, ContextPipeline, ContextPipelineCleanupError, ContextPipelineInitializationError, ContextPipelineInterruptedError, CriticalError, Dataset, enqueueLinks, EnqueueStrategy, getObjectType, KeyValueStore, log, LogLevel, mergeCookies, MissingSessionError, NavigationSkippedError, NonRetryableError, OwnedOrInjected, purgeDefaultStorages, RequestHandlerError, RequestManagerTandem, RequestQueue, RequestState, RetryRequestError, Router, ServiceLocator, serviceLocator, Session, SessionError, SessionPool, Statistics, validateUserData, validators, } from '@crawlee/core';
+import { AutoscaledPool, bindMethodsToServiceLocator, BLOCKED_STATUS_CODES, ConcurrencySystem, ContextPipeline, ContextPipelineCleanupError, ContextPipelineInitializationError, ContextPipelineInterruptedError, createStorageTransaction, CriticalError, currentStorageTransaction, Dataset, enqueueLinks, EnqueueStrategy, getObjectType, KeyValueStore, log, LogLevel, mergeCookies, MissingSessionError, NavigationSkippedError, NonRetryableError, OwnedOrInjected, purgeDefaultStorages, RequestHandlerError, RequestManagerTandem, RequestQueue, RequestState, RetryRequestError, Router, ServiceLocator, serviceLocator, Session, SessionError, SessionPool, Statistics, validateUserData, validators, withDirectStorageAccess, } from '@crawlee/core';
 import { FetchHttpClient } from '@crawlee/http-client';
 import { isAsyncIterable, isIterable, RobotsTxtFile, ROTATE_PROXY_ERRORS } from '@crawlee/utils';
 import { stringify } from 'csv-stringify/sync';
@@ -186,6 +186,10 @@ export class BasicCrawler {
     httpClient;
     retryOnBlocked;
     respectRobotsTxtFile;
+    /** Whether `runInStorageTransaction()` opens a transaction at all. */
+    transactionalStorageEnabled;
+    /** The resolved per-storage-type write policy overrides forwarded to each request's transaction. */
+    storageWritePolicy;
     onSkippedRequest;
     _closeEvents;
     loggedPerRun = new Set();
@@ -219,6 +223,9 @@ export class BasicCrawler {
         blockedStatusCodes: ow.optional.array.ofType(ow.number),
         retryOnBlocked: ow.optional.boolean,
         respectRobotsTxtFile: ow.optional.any(ow.boolean, ow.object),
+        transactionalStorage: ow.optional.any(ow.boolean, ow.object.exactShape({
+            requestQueue: ow.optional.string.oneOf(['deferred', 'writeThrough']),
+        })),
         onSkippedRequest: ow.optional.function,
         httpClient: ow.optional.object,
         configuration: ow.optional.object,
@@ -246,7 +253,7 @@ export class BasicCrawler {
         // Service locator options
         configuration, storageBackend, eventManager, logger, 
         // AutoscaledPool shorthands
-        minConcurrency, maxConcurrency, maxRequestsPerMinute, blockedStatusCodes: blockedStatusCodesInput, retryOnBlocked = false, respectRobotsTxtFile = false, onSkippedRequest, requestHandler, requestHandlerTimeoutSecs, errorHandler, failedRequestHandler, statusMessageLoggingInterval = 10, statusMessageCallback, statistics, httpClient, id, } = options;
+        minConcurrency, maxConcurrency, maxRequestsPerMinute, blockedStatusCodes: blockedStatusCodesInput, retryOnBlocked = false, respectRobotsTxtFile = false, transactionalStorage, onSkippedRequest, requestHandler, requestHandlerTimeoutSecs, errorHandler, failedRequestHandler, statusMessageLoggingInterval = 10, statusMessageCallback, statistics, httpClient, id, } = options;
         // All concurrency configuration lives on the `ConcurrencySystem`, so the shortcuts have nowhere to go once
         // one is supplied - and silently dropping a `maxConcurrency` the user asked for is how crawls end up
         // hammering a site.
@@ -320,6 +327,10 @@ export class BasicCrawler {
             }
             this.retryOnBlocked = retryOnBlocked;
             this.respectRobotsTxtFile = respectRobotsTxtFile;
+            // The cast undoes ow's assertion signature, which mangles `boolean | object` unions.
+            const transactionalStorageOption = transactionalStorage;
+            this.transactionalStorageEnabled = transactionalStorageOption !== false;
+            this.storageWritePolicy = typeof transactionalStorageOption === 'object' ? transactionalStorageOption : {};
             this.onSkippedRequest = onSkippedRequest;
             // allow at least 5min for internal timeouts
             this.internalTimeoutMillis =
@@ -376,12 +387,15 @@ export class BasicCrawler {
                     this.stats.startJob(request.id || request.uniqueKey);
                     const crawlingContext = { request };
                     try {
+                        // The transaction spans the whole pipeline call, covering the navigation hooks
+                        // and `extendContext` too; `handleRequest` drives its outcome explicitly.
+                        await this.runInStorageTransaction(async () => 
                         // Navigation, the navigation hooks and the request handler are timed individually, but the
                         // phases between them are not, so a request could still get stuck indefinitely. This is the
                         // catch-all for that - see `raceWithTimeout` for why it is a bare timer, not a timeout frame.
                         await this.withRequestTimeout(crawlingContext, this.basicContextPipeline
                             .chain(this.contextPipeline)
-                            .call(crawlingContext, (ctx) => this.handleRequest(ctx, source, request)));
+                            .call(crawlingContext, (ctx) => this.handleRequest(ctx, source, request))));
                     }
                     catch (error) {
                         // ContextPipelineInterruptedError means the request was intentionally skipped
@@ -944,14 +958,18 @@ export class BasicCrawler {
         return Math.min(limit, explicitLimit ?? Infinity);
     }
     async handleSkippedRequest(options) {
-        if (options.reason === 'limit') {
-            this.logOncePerRun('maxRequestsPerCrawl', 'The number of requests enqueued by the crawler reached the maxRequestsPerCrawl limit of ' +
-                `${this.maxRequestsPerCrawl} requests and no further requests will be added.`);
-        }
-        if (options.reason === 'depth') {
-            this.logOncePerRun('maxCrawlDepth', `The crawler reached the maxCrawlDepth limit of ${this.maxCrawlDepth} and no further requests will be enqueued.`);
-        }
-        await this.onSkippedRequest?.(options);
+        // A skipped request is a *successful* outcome, but the interrupt still unwinds through the
+        // transaction scope, which rolls back - so the skip bookkeeping must write directly.
+        await withDirectStorageAccess(async () => {
+            if (options.reason === 'limit') {
+                this.logOncePerRun('maxRequestsPerCrawl', 'The number of requests enqueued by the crawler reached the maxRequestsPerCrawl limit of ' +
+                    `${this.maxRequestsPerCrawl} requests and no further requests will be added.`);
+            }
+            if (options.reason === 'depth') {
+                this.logOncePerRun('maxCrawlDepth', `The crawler reached the maxCrawlDepth limit of ${this.maxCrawlDepth} and no further requests will be enqueued.`);
+            }
+            await this.onSkippedRequest?.(options);
+        });
     }
     logOncePerRun(key, message) {
         if (!this.loggedPerRun.has(key)) {
@@ -1168,6 +1186,40 @@ export class BasicCrawler {
         const timeoutMillis = this.resolveRequestHandlerTimeoutMillis(crawlingContext.request.label);
         await addTimeoutToPromise(async () => this.requestHandler(crawlingContext), timeoutMillis, `requestHandler timed out after ${timeoutMillis / 1000} seconds (${crawlingContext.request.id}).`);
     }
+    /**
+     * Runs `callback` inside a {@link StorageTransaction}, unless transactional storage is disabled.
+     * Deliberately does **not** commit on return - `handleRequest` swallows request handler failures, so
+     * a normal return says nothing about success. `handleRequest` owns the outcome.
+     */
+    async runInStorageTransaction(callback) {
+        if (!this.transactionalStorageEnabled) {
+            return callback();
+        }
+        const transaction = createStorageTransaction({
+            policy: this.storageWritePolicy,
+            commitTimeoutMillis: this.internalTimeoutMillis,
+        });
+        let threw = true;
+        try {
+            const result = await transaction.run(callback);
+            threw = false;
+            return result;
+        }
+        finally {
+            if (transaction.state === 'open') {
+                // `handleRequest` commits or rolls back on every normal path, so an open transaction on
+                // a normal return is a wiring bug; on a propagating throw (a pipeline-level failure) it is
+                // expected. Either way, discard the unvalidated writes; only the former is worth flagging.
+                if (!threw) {
+                    this.log.error('Internal error: a storage transaction was still open after the request pipeline ' +
+                        'returned normally. Its writes are being discarded. Please report this.');
+                }
+                transaction.rollback();
+            }
+            // Unconditional: `failed` is a terminal state that the branch above never reaches.
+            transaction.dispose();
+        }
+    }
     /**
      * Handles blocked request
      */
@@ -1281,10 +1333,15 @@ export class BasicCrawler {
             return;
         }
         const statisticsId = request.id || request.uniqueKey;
+        // Opened by `runInStorageTransaction`; absent when disabled or when the subclass opens its own.
+        const transaction = currentStorageTransaction();
         let isRequestLocked = true;
         try {
             request.state = RequestState.REQUEST_HANDLER;
             await this.runRequestHandler(crawlingContext);
+            // Commit *before* marking the request as handled, so a commit failure fails the request and
+            // it is retried. This also closes the transaction, so everything below passes through.
+            await transaction?.commit();
             await this.timeoutAndRetry(async () => requestSource.markRequestAsHandled(request), this.internalTimeoutMillis, `Marking request ${request.url} (${request.id}) as handled timed out after ${this.internalTimeoutMillis / 1e3} seconds.`);
             isRequestLocked = false; // markRequestAsHandled succeeded and unlocked the request
             this.stats.finishJob(statisticsId, request.retryCount);
@@ -1293,6 +1350,9 @@ export class BasicCrawler {
             crawlingContext.session.markGood();
         }
         catch (rawError) {
+            // Roll back *before* any error handler runs - error handlers write to real storage precisely
+            // because the transaction is already closed. A no-op when the commit above succeeded.
+            transaction?.rollback();
             const err = this.unwrapError(rawError);
             try {
                 request.state = RequestState.ERROR_HANDLER;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/basic",
-    "version": "4.0.0-beta.103",
+    "version": "4.0.0-beta.105",
     "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"
@@ -42,10 +42,10 @@
         "@apify/datastructures": "^2.0.0",
         "@apify/timeout": "^0.4.4",
         "@apify/utilities": "^2.15.5",
-        "@crawlee/core": "4.0.0-beta.103",
-        "@crawlee/http-client": "4.0.0-beta.103",
-        "@crawlee/types": "4.0.0-beta.103",
-        "@crawlee/utils": "4.0.0-beta.103",
+        "@crawlee/core": "4.0.0-beta.105",
+        "@crawlee/http-client": "4.0.0-beta.105",
+        "@crawlee/types": "4.0.0-beta.105",
+        "@crawlee/utils": "4.0.0-beta.105",
         "csv-stringify": "^6.5.2",
         "ow": "^2.0.0",
         "tldts": "^7.0.6",
@@ -53,7 +53,7 @@
         "type-fest": "^4.41.0"
     },
     "optionalDependencies": {
-        "@crawlee/impit-client": "^4.0.0-beta.103"
+        "@crawlee/impit-client": "^4.0.0-beta.105"
     },
     "lerna": {
         "command": {
@@ -62,5 +62,5 @@
             }
         }
     },
-    "gitHead": "fe5d0ae11067683e27a2d17b4edd226ccf112cf5"
+    "gitHead": "26073a822c7699ac487931383a39192bc3daae7a"
 }