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

package/internals/adaptive-playwright-crawler.d.ts

@@ -1,8 +1,8 @@
 import type { BrowserHook, LoadedRequest, Request, RouterHandler, RouteSchemas, RoutesFromSchemas } from '@crawlee/browser';
 import type { BasicCrawlerOptions } from '@crawlee/basic';
 import { BasicCrawler } from '@crawlee/basic';
-import type { ContextPipeline, CrawlingContext, EnqueueLinksOptions, GetUserDataFromRequest, RouterRoutes, StatisticsOptions, StatisticState } from '@crawlee/core';
-import { RequestHandlerResult, Statistics } from '@crawlee/core';
+import type { ContextPipeline, CrawlingContext, EnqueueLinksOptions, GetUserDataFromRequest, RouterRoutes, StatisticsOptions, StatisticState, StorageTransactionView } from '@crawlee/core';
+import { Statistics } from '@crawlee/core';
 import type { Dictionary, Awaitable } from '@crawlee/types';
 import { type CheerioRoot } from '@crawlee/utils';
 import { type Cheerio } from 'cheerio';
@@ -25,7 +25,7 @@ declare class AdaptivePlaywrightCrawlerStatistics extends Statistics {
     trackBrowserRequestHandlerRun(): void;
     trackRenderingTypeMisprediction(): void;
 }
-export interface AdaptivePlaywrightCrawlerContext<UserData extends Dictionary = Dictionary> extends CrawlingContext<UserData> {
+export interface AdaptivePlaywrightCrawlerContext<UserData extends Dictionary = any> extends CrawlingContext<UserData> {
     request: LoadedRequest<Request<UserData>>;
     /**
      * The HTTP response, either from the HTTP client or from the initial request from playwright's navigation.
@@ -108,11 +108,12 @@ export interface AdaptivePlaywrightCrawlerOptions<ContextExtension = Dictionary<
      */
     renderingTypeDetectionRatio?: number;
     /**
-     * An optional callback that is called on dataset items found by the request handler in plain HTTP mode.
+     * An optional callback that is called on the storage writes recorded by the request handler in plain
+     * HTTP mode (exposed as a read-only {@link StorageTransactionView}).
      * If it returns false, the request is retried in a browser.
-     * If no callback is specified, every dataset item is considered valid.
+     * If no callback is specified, every result is considered valid.
      */
-    resultChecker?: (result: RequestHandlerResult) => boolean;
+    resultChecker?: (result: StorageTransactionView) => boolean;
     /**
      * An optional callback that decides whether an error thrown during the plain HTTP request handler
      * should be propagated (instead of falling back to browser navigation).
@@ -135,18 +136,13 @@ export interface AdaptivePlaywrightCrawlerOptions<ContextExtension = Dictionary<
      *
      * For a stricter, ready-made comparator that also takes enqueued requests and key-value store changes into account, see {@link fullResultComparator}.
      */
-    resultComparator?: (resultA: RequestHandlerResult, resultB: RequestHandlerResult) => boolean | 'equal' | 'different' | 'inconclusive';
+    resultComparator?: (resultA: StorageTransactionView, resultB: StorageTransactionView) => boolean | 'equal' | 'different' | 'inconclusive';
     /**
      * A custom rendering type predictor. A predictor passed here is borrowed - the crawler never drives its
      * lifecycle, so set it up yourself (the built-in {@link RenderingTypePredictor} needs `initialize()`).
      * Omit the option and the crawler builds its own from `renderingTypeDetectionRatio` - and initializes it.
      */
     renderingTypePredictor?: IRenderingTypePredictor;
-    /**
-     * Prevent direct access to storage in request handlers (only allow using context helpers).
-     * Defaults to `true`
-     */
-    preventDirectStorageAccess?: boolean;
 }
 /**
  * An extension of {@link PlaywrightCrawler} that uses a more limited request handler interface so that it is able to switch to HTTP-only crawling when it detects it may be possible.
@@ -182,13 +178,16 @@ export declare class AdaptivePlaywrightCrawler<ContextExtension = Dictionary<nev
     private resultChecker;
     private shouldPropagateError;
     private resultComparator;
-    private preventDirectStorageAccess;
     private staticContextPipeline;
     private browserContextPipeline;
     private individualRequestHandlerTimeoutMillis;
     get stats(): AdaptivePlaywrightCrawlerStatistics;
-    private resultObjects;
     private inFlightRenderingTypeDetections;
+    /**
+     * The write policy of the per-attempt transactions. Defaults the request queue to `deferred`:
+     * a discarded attempt's enqueues must never reach the queue.
+     */
+    private readonly attemptWritePolicy;
     private teardownHooks;
     constructor(options?: AdaptivePlaywrightCrawlerOptions<ContextExtension, ExtendedContext, Routes>);
     protected _init(): Promise<void>;
@@ -203,16 +202,14 @@ export declare class AdaptivePlaywrightCrawler<ContextExtension = Dictionary<nev
     }>;
     private adaptCheerioContext;
     private adaptPlaywrightContext;
-    private crawlOne;
-    protected runRequestHandler(crawlingContext: CrawlingContext): Promise<void>;
-    private commitResult;
-    private allowStorageAccess;
     /**
-     * Reading the pending request count queries the underlying request manager, which counts as storage access.
-     * Since this is internal crawler bookkeeping used to compute the `enqueueLinks` limit (not user-initiated storage
-     * access), it must be allowed even while a request handler runs inside the storage-access guard.
+     * Runs one request handler attempt inside its own {@link StorageTransaction}, wrapping the inner
+     * (static or browser) context pipeline. The transaction is pushed to `transactions` *at creation
+     * time, before the `try`* - the `ok: false` branch of the returned {@link Result} carries no
+     * result, and failed attempts are routine here. The caller owns the outcome and disposal.
      */
-    protected getPendingRequestCountApproximation(): Promise<number>;
+    private crawlOne;
+    protected runRequestHandler(crawlingContext: CrawlingContext): Promise<void>;
     private enqueueLinks;
     private createLogProxy;
     teardown(): Promise<void>;
@@ -243,5 +240,5 @@ export declare function createAdaptivePlaywrightRouter<Context extends AdaptiveP
  * });
  * ```
  */
-export declare function fullResultComparator(resultA: RequestHandlerResult, resultB: RequestHandlerResult): boolean;
+export declare function fullResultComparator(resultA: StorageTransactionView, resultB: StorageTransactionView): boolean;
 export {};

package/internals/adaptive-playwright-crawler.js

@@ -2,8 +2,9 @@ import { isDeepStrictEqual } from 'node:util';
 import { BasicCrawler } from '@crawlee/basic';
 import { extractUrlsFromPage } from '@crawlee/browser';
 import { CheerioCrawler } from '@crawlee/cheerio';
-import { OwnedOrInjected, RequestHandlerError, RequestHandlerResult, resolveBaseUrlForEnqueueLinksFiltering, Router, serviceLocator, Statistics, withCheckedStorageAccess, } from '@crawlee/core';
+import { createStorageTransaction, OwnedOrInjected, RequestHandlerError, resolveBaseUrlForEnqueueLinksFiltering, Router, Statistics, } from '@crawlee/core';
 import { extractUrlsFromCheerio } from '@crawlee/utils';
+import ow from 'ow';
 import { addTimeoutToPromise } from '@apify/timeout';
 import { PlaywrightCrawler } from './playwright-crawler.js';
 import { RenderingTypePredictor, } from './utils/rendering-type-prediction.js';
@@ -86,7 +87,6 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
     resultChecker;
     shouldPropagateError;
     resultComparator;
-    preventDirectStorageAccess;
     staticContextPipeline;
     browserContextPipeline;
     individualRequestHandlerTimeoutMillis;
@@ -94,11 +94,25 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
     get stats() {
         return super.stats;
     }
-    resultObjects = new WeakMap();
     inFlightRenderingTypeDetections = 0;
+    /**
+     * The write policy of the per-attempt transactions. Defaults the request queue to `deferred`:
+     * a discarded attempt's enqueues must never reach the queue.
+     */
+    attemptWritePolicy;
     teardownHooks = [];
     constructor(options = {}) {
-        const { requestHandler, renderingTypeDetectionRatio = 0.1, renderingTypePredictor, resultChecker, shouldPropagateError, resultComparator, statistics, preventDirectStorageAccess = true, requestHandlerTimeoutSecs = 60, errorHandler, failedRequestHandler, preNavigationHooks = [], postNavigationHooks = [], extendContext, contextPipelineBuilder, ...rest } = options;
+        const { requestHandler, renderingTypeDetectionRatio = 0.1, renderingTypePredictor, resultChecker, shouldPropagateError, resultComparator, statistics, requestHandlerTimeoutSecs = 60, errorHandler, failedRequestHandler, preNavigationHooks = [], postNavigationHooks = [], extendContext, contextPipelineBuilder, transactionalStorage, ...rest } = options;
+        // The user's value is replaced by `false` in the `super` call below — validate it separately.
+        ow(transactionalStorage, 'transactionalStorage', BasicCrawler.optionsShape.transactionalStorage);
+        // Per-attempt buffering is load-bearing here: the handler runs up to twice per request and the
+        // losing attempt's writes must be discardable.
+        if (transactionalStorage === false) {
+            throw new Error('AdaptivePlaywrightCrawler requires transactional storage - it runs the request handler ' +
+                'multiple times per request and must be able to discard the storage writes of losing ' +
+                'attempts. `transactionalStorage: false` is therefore not supported; a write policy ' +
+                'object is accepted and forwarded to the per-attempt transactions.');
+        }
         if (statistics !== undefined && !(statistics instanceof AdaptivePlaywrightCrawlerStatistics)) {
             throw new Error('AdaptivePlaywrightCrawler tracks extra fields on its own Statistics subclass and cannot use a ' +
                 'plain `statistics` instance. Omit the option to let the crawler build its own.');
@@ -115,11 +129,19 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
                     logMessage: `${AdaptivePlaywrightCrawler.name} request statistics:`,
                 }),
             contextPipelineBuilder: contextPipelineBuilder ?? (() => this.buildContextPipeline()),
+            // The base crawler must not wrap requests in a transaction of its own - this crawler opens
+            // one per request handler attempt in `crawlOne` instead, forwarding the write policy of the
+            // user-facing option (validated above) to those.
+            transactionalStorage: false,
         });
         this.individualRequestHandlerTimeoutMillis = requestHandlerTimeoutSecs * 1000;
         // `renderingTypeDetectionRatio` only configures the default predictor - an injected one brings its own
         // detection ratio (and its own state), so the option is ignored in that case.
         this.renderingTypePredictor = OwnedOrInjected.resolve(renderingTypePredictor, () => new RenderingTypePredictor({ detectionRatio: renderingTypeDetectionRatio }));
+        this.attemptWritePolicy = {
+            requestQueue: 'deferred',
+            ...(typeof transactionalStorage === 'object' ? transactionalStorage : {}),
+        };
         this.resultChecker = resultChecker ?? (() => true);
         this.shouldPropagateError = shouldPropagateError ?? (() => false);
         if (resultComparator !== undefined) {
@@ -166,7 +188,6 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
         this.browserContextPipeline = browserCrawler.contextPipeline.compose({
             action: this.adaptPlaywrightContext.bind(this),
         });
-        this.preventDirectStorageAccess = preventDirectStorageAccess;
     }
     async _init() {
         // Only the predictor we built ourselves is ours to initialize - an injected one is borrowed, so its
@@ -203,11 +224,6 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
         });
     }
     async adaptCheerioContext(cheerioContext) {
-        // Capture the original response to avoid infinite recursion when the getter is copied to the context
-        const result = this.resultObjects.get(cheerioContext);
-        if (result === undefined) {
-            throw new Error('Logical error - `this.resultObjects` does not contain the result object');
-        }
         return {
             get page() {
                 throw new Error('Page object was used in HTTP-only request handler');
@@ -221,17 +237,14 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
             enqueueLinks: async (options = {}) => {
                 const urls = options.urls ??
                     extractUrlsFromCheerio(cheerioContext.$, options.selector, options.baseUrl ?? cheerioContext.request.loadedUrl);
-                return (await this.enqueueLinks({ ...options, urls }, cheerioContext.request, result));
+                return (await this.enqueueLinks({ ...options, urls }, cheerioContext.request));
             },
             response: cheerioContext.response,
         };
     }
     async adaptPlaywrightContext(playwrightContext) {
+        // Capture the original response to avoid infinite recursion when the getter is copied to the context
         const originalResponse = playwrightContext.response;
-        const result = this.resultObjects.get(playwrightContext);
-        if (result === undefined) {
-            throw new Error('Logical error - `this.resultObjects` does not contain the result object');
-        }
         return {
             response: new Response(Uint8Array.from(await originalResponse.body()), {
                 headers: originalResponse.headers(),
@@ -264,29 +277,35 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
                 else {
                     urls = options.urls;
                 }
-                return (await this.enqueueLinks({ ...options, urls }, playwrightContext.request, result));
+                return (await this.enqueueLinks({ ...options, urls }, playwrightContext.request));
             },
         };
     }
-    async crawlOne(renderingType, context, useStateFunction) {
-        const result = new RequestHandlerResult(serviceLocator.getConfiguration(), AdaptivePlaywrightCrawler.CRAWLEE_STATE_KEY);
+    /**
+     * Runs one request handler attempt inside its own {@link StorageTransaction}, wrapping the inner
+     * (static or browser) context pipeline. The transaction is pushed to `transactions` *at creation
+     * time, before the `try`* - the `ok: false` branch of the returned {@link Result} carries no
+     * result, and failed attempts are routine here. The caller owns the outcome and disposal.
+     */
+    async crawlOne(renderingType, context, useStateFunction, transactions) {
+        const transaction = createStorageTransaction({
+            policy: this.attemptWritePolicy,
+            commitTimeoutMillis: this.internalTimeoutMillis,
+        });
+        transactions.push(transaction);
         const logs = [];
         const deferredCleanup = [];
-        const resultBoundContextHelpers = {
-            addRequests: result.addRequests,
-            pushData: result.pushData,
-            useState: this.allowStorageAccess(useStateFunction),
-            getKeyValueStore: this.allowStorageAccess(result.getKeyValueStore),
+        const attemptBoundContextHelpers = {
+            useState: useStateFunction,
             log: this.createLogProxy(context.log, logs),
             registerDeferredCleanup: (cleanup) => deferredCleanup.push(cleanup),
         };
         const subCrawlerContext = Object.defineProperties({}, Object.getOwnPropertyDescriptors(context));
-        // Mark result-bound helpers as non-configurable so they survive the sub-crawler context pipeline
-        // (which would otherwise override them with the sub-crawler's own versions, losing the result binding).
-        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(resultBoundContextHelpers))) {
+        // Mark attempt-bound helpers as non-configurable so they survive the sub-crawler context pipeline
+        // (which would otherwise override them with the sub-crawler's own versions, losing the binding).
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(attemptBoundContextHelpers))) {
             Object.defineProperty(subCrawlerContext, key, { ...descriptor, configurable: false });
         }
-        this.resultObjects.set(subCrawlerContext, result);
         try {
             const callAdaptiveRequestHandler = async () => {
                 if (renderingType === 'static') {
@@ -300,12 +319,8 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
             // to resolve any per-route override too - otherwise routes would be silently ignored here
             const routeTimeoutSecs = this.requestHandler.getTimeoutSecs?.(context.request.label);
             const timeoutMillis = routeTimeoutSecs === undefined ? this.individualRequestHandlerTimeoutMillis : routeTimeoutSecs * 1000;
-            await addTimeoutToPromise(async () => withCheckedStorageAccess(() => {
-                if (this.preventDirectStorageAccess) {
-                    throw new Error('Directly accessing storage in a request handler is not allowed in AdaptivePlaywrightCrawler');
-                }
-            }, callAdaptiveRequestHandler), timeoutMillis, 'Request handler timed out');
-            return { result, ok: true, logs };
+            await addTimeoutToPromise(async () => transaction.run(callAdaptiveRequestHandler), timeoutMillis, 'Request handler timed out');
+            return { result: transaction, ok: true, logs };
         }
         catch (error) {
             return { error, ok: false, logs };
@@ -323,15 +338,19 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
         if (shouldDetectRenderingType) {
             this.inFlightRenderingTypeDetections += 1;
         }
+        // Every transaction created for this request - up to two, since the static-then-browser
+        // fall-through and the browser-then-detection pair are mutually exclusive. Disposed in the
+        // `finally` below, not earlier: the comparators read the journals after `crawlOne` returns.
+        const transactions = [];
         try {
             if (renderingTypePrediction.renderingType === 'static' && !shouldDetectRenderingType) {
                 crawlingContext.log.debug(`Running HTTP-only request handler for ${crawlingContext.request.url}`);
                 this.stats.trackHttpOnlyRequestHandlerRun();
-                const plainHTTPRun = await this.crawlOne('static', crawlingContext, crawlingContext.useState);
+                const plainHTTPRun = await this.crawlOne('static', crawlingContext, crawlingContext.useState, transactions);
                 if (plainHTTPRun.ok && this.resultChecker(plainHTTPRun.result)) {
                     crawlingContext.log.debug(`HTTP-only request handler succeeded for ${crawlingContext.request.url}`);
                     plainHTTPRun.logs?.forEach(([log, method, ...args]) => log[method](...args));
-                    await this.commitResult(crawlingContext, plainHTTPRun.result);
+                    await plainHTTPRun.result.commit();
                     return;
                 }
                 // Execution will "fall through" and try running the request handler in a browser
@@ -371,15 +390,17 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
                     return this.stateCopy;
                 },
             };
-            const browserRun = await this.crawlOne('clientOnly', crawlingContext, stateTracker.getLiveState.bind(stateTracker));
+            const browserRun = await this.crawlOne('clientOnly', crawlingContext, stateTracker.getLiveState.bind(stateTracker), transactions);
             if (!browserRun.ok) {
                 throw browserRun.error;
             }
             browserRun.logs?.forEach(([log, method, ...args]) => log[method](...args));
-            await this.commitResult(crawlingContext, browserRun.result);
+            await browserRun.result.commit();
             if (shouldDetectRenderingType) {
                 crawlingContext.log.debug(`Detecting rendering type for ${crawlingContext.request.url}`);
-                const plainHTTPRun = await this.crawlOne('static', crawlingContext, stateTracker.getStateCopy.bind(stateTracker));
+                // The detection attempt's transaction is never committed - its writes exist only for the
+                // result comparison.
+                const plainHTTPRun = await this.crawlOne('static', crawlingContext, stateTracker.getStateCopy.bind(stateTracker), transactions);
                 const detectionResult = (() => {
                     if (!plainHTTPRun.ok) {
                         return 'clientOnly';
@@ -403,52 +424,23 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
             if (shouldDetectRenderingType) {
                 this.inFlightRenderingTypeDetections -= 1;
             }
+            // A still-open transaction here belongs to a discarded attempt - roll it back, then release.
+            for (const transaction of transactions) {
+                transaction.rollback();
+                transaction.dispose();
+            }
         }
     }
-    async commitResult(crawlingContext, { calls, keyValueStoreChanges }) {
-        await Promise.all([
-            ...calls.pushData.map(async (params) => crawlingContext.pushData(...params)),
-            ...calls.addRequests.map(async (params) => crawlingContext.addRequests(...params)),
-            ...Object.entries(keyValueStoreChanges).map(async ([storeIdOrName, changes]) => {
-                const store = await crawlingContext.getKeyValueStore({ id: storeIdOrName });
-                await Promise.all(Object.entries(changes).map(async ([key, { changedValue, options }]) => store.setValue(key, changedValue, options)));
-            }),
-        ]);
-    }
-    allowStorageAccess(func) {
-        return async (...args) => withCheckedStorageAccess(() => { }, async () => func(...args));
-    }
-    /**
-     * Reading the pending request count queries the underlying request manager, which counts as storage access.
-     * Since this is internal crawler bookkeeping used to compute the `enqueueLinks` limit (not user-initiated storage
-     * access), it must be allowed even while a request handler runs inside the storage-access guard.
-     */
-    async getPendingRequestCountApproximation() {
-        return this.allowStorageAccess(() => super.getPendingRequestCountApproximation())();
-    }
-    async enqueueLinks(options, request, result) {
+    async enqueueLinks(options, request) {
         const baseUrl = resolveBaseUrlForEnqueueLinksFiltering({
             enqueueStrategy: options?.strategy,
             finalRequestUrl: request.loadedUrl,
             originalRequestUrl: request.url,
             userProvidedBaseUrl: options?.baseUrl,
         });
-        const addRequestsBatched = async (requests) => {
-            await result.addRequests(requests);
-            return {
-                addedRequests: requests.map(({ uniqueKey, id }) => ({
-                    uniqueKey,
-                    requestId: id ?? '',
-                    wasAlreadyPresent: false,
-                    wasAlreadyHandled: false,
-                })),
-                waitForAllRequestsToBeAdded: Promise.resolve([]),
-                requestsOverLimit: [],
-            };
-        };
-        // We need to use a mock request queue implementation, in order to add the requests into our result object
-        const mockRequestQueue = { addRequestsBatched };
-        return await this.enqueueLinksWithCrawlDepth({ ...options, baseUrl }, request, mockRequestQueue);
+        // The per-attempt transaction buffers these (the queue policy defaults to `deferred` here),
+        // so a discarded attempt's enqueues never reach the queue.
+        return await this.enqueueLinksWithCrawlDepth({ ...options, baseUrl }, request, await this.getRequestManager());
     }
     createLogProxy(log, logs) {
         return new Proxy(log, {
@@ -498,6 +490,5 @@ export function createAdaptivePlaywrightRouter(routesOrSchemas) {
 export function fullResultComparator(resultA, resultB) {
     return (isDeepStrictEqual(resultA.datasetItems, resultB.datasetItems) &&
         isDeepStrictEqual(resultA.enqueuedUrls, resultB.enqueuedUrls) &&
-        isDeepStrictEqual(resultA.enqueuedUrlLists, resultB.enqueuedUrlLists) &&
         isDeepStrictEqual(resultA.keyValueStoreChanges, resultB.keyValueStoreChanges));
 }

package/internals/playwright-crawler.d.ts

@@ -8,11 +8,9 @@ import type { EnqueueLinksByClickingElementsOptions } from './enqueue-links/clic
 import type { PlaywrightLaunchContext } from './playwright-launcher.js';
 import type { BlockRequestsOptions, DirectNavigationOptions, HandleCloudflareChallengeOptions, InfiniteScrollOptions, InjectFileOptions, PlaywrightContextUtils, SaveSnapshotOptions } from './utils/playwright-utils.js';
 export type PlaywrightGotoOptions = NonNullable<Parameters<Page['goto']>[1]>;
-export interface PlaywrightCrawlingContext<UserData extends Dictionary = Dictionary> extends BrowserCrawlingContext<Page, Response, UserData, PlaywrightGotoOptions>, PlaywrightContextUtils {
-}
-// @ts-ignore optional peer dependency or compatibility with es2022
-export interface PlaywrightHook extends BrowserHook<PlaywrightCrawlingContext> {
+export interface PlaywrightCrawlingContext<UserData extends Dictionary = any> extends BrowserCrawlingContext<Page, Response, UserData, PlaywrightGotoOptions>, PlaywrightContextUtils {
 }
+export type PlaywrightHook<UserData extends Dictionary = any> = BrowserHook<PlaywrightCrawlingContext<UserData>>;
 export interface PlaywrightCrawlerOptions<ContextExtension = Dictionary<never>, ExtendedContext extends PlaywrightCrawlingContext = PlaywrightCrawlingContext & ContextExtension, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<PlaywrightCrawlingContext['request']>>> extends BrowserCrawlerOptions<Page, Response, PlaywrightCrawlingContext, ContextExtension, ExtendedContext, {
     browserPlugins: [PlaywrightPlugin];
 }, Routes> {
@@ -59,7 +57,7 @@ export interface PlaywrightCrawlerOptions<ContextExtension = Dictionary<never>,
      * ]
      * ```
      */
-    preNavigationHooks?: BrowserHook<PlaywrightCrawlingContext, ContextExtension>[];
+    preNavigationHooks?: BrowserHook<PlaywrightCrawlingContext<GetUserDataFromRequest<ExtendedContext['request']>>, ContextExtension>[];
     /**
      * Async functions that are sequentially evaluated after the navigation. Good for checking if the navigation was successful.
      * The function accepts `crawlingContext` as the only parameter. A hook may optionally return a partial object
@@ -76,7 +74,7 @@ export interface PlaywrightCrawlerOptions<ContextExtension = Dictionary<never>,
      * ]
      * ```
      */
-    postNavigationHooks?: BrowserHook<PlaywrightCrawlingContext, ContextExtension>[];
+    postNavigationHooks?: BrowserHook<PlaywrightCrawlingContext<GetUserDataFromRequest<ExtendedContext['request']>>, ContextExtension>[];
 }
 /**
  * Provides a simple framework for parallel crawling of web pages
@@ -217,6 +215,8 @@ export declare class PlaywrightCrawler<ContextExtension = Dictionary<never>, Ext
         retryOnBlocked: import("ow").BooleanPredicate & import("ow").BasePredicate<boolean | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
         respectRobotsTxtFile: import("ow").AnyPredicate<boolean | object>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+        transactionalStorage: import("ow").BasePredicate<boolean | Partial<import("@crawlee/browser").StorageWritePolicy> | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022
         onSkippedRequest: import("ow").Predicate<Function> & import("ow").BasePredicate<Function | undefined>;
 // @ts-ignore optional peer dependency or compatibility with es2022

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/playwright",
-    "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"
@@ -49,13 +49,13 @@
     "dependencies": {
         "@apify/datastructures": "^2.0.3",
         "@apify/timeout": "^0.4.4",
-        "@crawlee/basic": "4.0.0-beta.103",
-        "@crawlee/browser": "4.0.0-beta.103",
-        "@crawlee/browser-pool": "4.0.0-beta.103",
-        "@crawlee/cheerio": "4.0.0-beta.103",
-        "@crawlee/core": "4.0.0-beta.103",
-        "@crawlee/types": "4.0.0-beta.103",
-        "@crawlee/utils": "4.0.0-beta.103",
+        "@crawlee/basic": "4.0.0-beta.105",
+        "@crawlee/browser": "4.0.0-beta.105",
+        "@crawlee/browser-pool": "4.0.0-beta.105",
+        "@crawlee/cheerio": "4.0.0-beta.105",
+        "@crawlee/core": "4.0.0-beta.105",
+        "@crawlee/types": "4.0.0-beta.105",
+        "@crawlee/utils": "4.0.0-beta.105",
         "cheerio": "^1.0.0",
         "idcac-playwright": "^0.1.3",
         "jquery": "^3.7.1",
@@ -85,5 +85,5 @@
             }
         }
     },
-    "gitHead": "fe5d0ae11067683e27a2d17b4edd226ccf112cf5"
+    "gitHead": "26073a822c7699ac487931383a39192bc3daae7a"
 }