@crawlee/playwright 4.0.0-beta.12 → 4.0.0-beta.121

package/internals/adaptive-playwright-crawler.js

@@ -2,32 +2,31 @@ import { isDeepStrictEqual } from 'node:util';
 import { BasicCrawler } from '@crawlee/basic';
 import { extractUrlsFromPage } from '@crawlee/browser';
 import { CheerioCrawler } from '@crawlee/cheerio';
-import { Configuration, RequestHandlerError, RequestHandlerResult, Router, Statistics, withCheckedStorageAccess, } from '@crawlee/core';
-import { extractUrlsFromCheerio } from '@crawlee/utils';
+import { createStorageTransaction, OwnedOrInjected, RequestHandlerError, resolveBaseUrlForEnqueueLinksFiltering, Router, Statistics, } from '@crawlee/core';
+import { extractUrlsFromCheerio } from '@crawlee/utils/internal';
+import ow from 'ow';
 import { addTimeoutToPromise } from '@apify/timeout';
 import { PlaywrightCrawler } from './playwright-crawler.js';
-import { RenderingTypePredictor } from './utils/rendering-type-prediction.js';
+import { RenderingTypePredictor, } from './utils/rendering-type-prediction.js';
 class AdaptivePlaywrightCrawlerStatistics extends Statistics {
-    state = null; // this needs to be assigned for a valid override, but the initialization is done by a reset() call from the parent constructor
-    constructor(options = {}) {
-        super(options);
-        this.reset();
+    get state() {
+        return super.state;
     }
-    reset() {
-        super.reset();
-        this.state.httpOnlyRequestHandlerRuns = 0;
-        this.state.browserRequestHandlerRuns = 0;
-        this.state.renderingTypeMispredictions = 0;
+    defaultState() {
+        return {
+            ...super.defaultState(),
+            httpOnlyRequestHandlerRuns: 0,
+            browserRequestHandlerRuns: 0,
+            renderingTypeMispredictions: 0,
+        };
     }
-    async _maybeLoadStatistics() {
-        await super._maybeLoadStatistics();
-        const savedState = await this.keyValueStore?.getValue(this.persistStateKey);
-        if (!savedState) {
-            return;
-        }
-        this.state.httpOnlyRequestHandlerRuns = savedState.httpOnlyRequestHandlerRuns;
-        this.state.browserRequestHandlerRuns = savedState.browserRequestHandlerRuns;
-        this.state.renderingTypeMispredictions = savedState.renderingTypeMispredictions;
+    deserializeState(persistedState) {
+        return {
+            ...super.deserializeState(persistedState),
+            httpOnlyRequestHandlerRuns: persistedState.httpOnlyRequestHandlerRuns,
+            browserRequestHandlerRuns: persistedState.browserRequestHandlerRuns,
+            renderingTypeMispredictions: persistedState.renderingTypeMispredictions,
+        };
     }
     trackHttpOnlyRequestHandlerRun() {
         this.state.httpOnlyRequestHandlerRuns ??= 0;
@@ -82,42 +81,74 @@ const proxyLogMethods = [
  * @experimental
  */
 export class AdaptivePlaywrightCrawler extends BasicCrawler {
-    config;
-    renderingTypePredictor;
-    resultChecker;
-    resultComparator;
-    preventDirectStorageAccess;
-    staticContextPipeline;
-    browserContextPipeline;
-    individualRequestHandlerTimeoutMillis;
-    resultObjects = new WeakMap();
-    teardownHooks = [];
-    constructor(options = {}, config = Configuration.getGlobalConfig()) {
-        const { requestHandler, renderingTypeDetectionRatio = 0.1, renderingTypePredictor, resultChecker, resultComparator, statisticsOptions, preventDirectStorageAccess = true, requestHandlerTimeoutSecs = 60, errorHandler, failedRequestHandler, preNavigationHooks, postNavigationHooks, extendContext, contextPipelineBuilder, ...rest } = options;
+    #renderingTypePredictor;
+    #resultChecker;
+    #shouldPropagateError;
+    #resultComparator;
+    #staticContextPipeline;
+    #browserContextPipeline;
+    #individualRequestHandlerTimeoutMillis;
+    // The constructor always injects an `AdaptivePlaywrightCrawlerStatistics`, so narrowing the cast is sound.
+    get stats() {
+        return super.stats;
+    }
+    /**
+     * 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, 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.');
+        }
         super({
             ...rest,
-            // Pass error handlers to the "main" crawler - we only pluck them from `rest` so that they don't go to the sub crawlers
             errorHandler,
             failedRequestHandler,
-            // Same for request handler
             requestHandler,
-            // The builder intentionally returns null so that it crashes the crawler when it tries to use this instead of one of two the specialized context pipelines
-            // (that would be a logical error in this class)
-            contextPipelineBuilder: () => null,
-        }, config);
-        this.config = config;
-        this.individualRequestHandlerTimeoutMillis = requestHandlerTimeoutSecs * 1000;
-        this.renderingTypePredictor =
-            renderingTypePredictor ?? new RenderingTypePredictor({ detectionRatio: renderingTypeDetectionRatio });
-        this.resultChecker = resultChecker ?? (() => true);
+            requestHandlerTimeoutSecs,
+            // Inject our subclass so the base tracks the extra adaptive fields instead of building a plain `Statistics`.
+            statistics: statistics ??
+                new AdaptivePlaywrightCrawlerStatistics({
+                    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) {
-            this.resultComparator = resultComparator;
+            this.#resultComparator = resultComparator;
         }
         else if (resultChecker !== undefined) {
-            this.resultComparator = (resultA, resultB) => this.resultChecker(resultA) && this.resultChecker(resultB);
+            this.#resultComparator = (resultA, resultB) => this.#resultChecker(resultA) && this.#resultChecker(resultB);
         }
         else {
-            this.resultComparator = (resultA, resultB) => {
+            this.#resultComparator = (resultA, resultB) => {
                 return (resultA.datasetItems.length === resultB.datasetItems.length &&
                     resultA.datasetItems.every((itemA, i) => {
                         const itemB = resultB.datasetItems[i];
@@ -125,167 +156,168 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
                     }));
             };
         }
+        // `extendContext` is forwarded to the inner crawlers, which run it *before* navigation (see
+        // `BasicCrawler`), keeping the behavior consistent with the non-adaptive crawlers: the
+        // extension is visible to the pre/post-navigation hooks and the request handler, but cannot
+        // access navigation-dependent members (`page`, `response`, `$`, ...).
+        //
+        // The adaptive hooks target a subset context (`AdaptiveHookContext`); the casts to the inner
+        // crawlers' `PlaywrightHook` type relax that nominal difference. The `ContextPipeline` merges
+        // each hook's overrides at runtime regardless of the static type.
         const staticCrawler = new CheerioCrawler({
             ...rest,
-            useSessionPool: false,
-            statisticsOptions: {
-                persistenceOptions: { enable: false },
-            },
-            preNavigationHooks: [
-                async (context) => {
-                    for (const hook of preNavigationHooks ?? []) {
-                        await hook(context, undefined);
-                    }
-                },
-            ],
-            postNavigationHooks: [
-                async (context) => {
-                    for (const hook of postNavigationHooks ?? []) {
-                        await hook(context, undefined);
-                    }
-                },
-            ],
-        }, config);
+            statistics: new Statistics({ persistenceOptions: { enable: false } }),
+            preNavigationHooks,
+            postNavigationHooks,
+            extendContext,
+        });
         const browserCrawler = new PlaywrightCrawler({
             ...rest,
-            useSessionPool: false,
-            statisticsOptions: {
-                persistenceOptions: { enable: false },
-            },
-            preNavigationHooks: [
-                async (context, gotoOptions) => {
-                    for (const hook of preNavigationHooks ?? []) {
-                        await hook(context, gotoOptions);
-                    }
-                },
-            ],
-            postNavigationHooks: [
-                async (context, gotoOptions) => {
-                    for (const hook of postNavigationHooks ?? []) {
-                        await hook(context, gotoOptions);
-                    }
-                },
-            ],
-        }, config);
-        this.teardownHooks.push(browserCrawler.teardown.bind(browserCrawler));
-        this.staticContextPipeline = staticCrawler.contextPipeline
-            .compose({
+            statistics: new Statistics({ persistenceOptions: { enable: false } }),
+            preNavigationHooks: preNavigationHooks,
+            postNavigationHooks: postNavigationHooks,
+            extendContext,
+        });
+        this.#teardownHooks.push(browserCrawler.teardown.bind(browserCrawler));
+        this.#staticContextPipeline = staticCrawler.contextPipeline.compose({
             action: this.adaptCheerioContext.bind(this),
-        })
-            .compose({
-            action: async (context) => extendContext ? await extendContext(context) : context,
         });
-        this.browserContextPipeline = browserCrawler.contextPipeline
-            .compose({
+        this.#browserContextPipeline = browserCrawler.contextPipeline.compose({
             action: this.adaptPlaywrightContext.bind(this),
-        })
-            .compose({
-            action: async (context) => extendContext ? await extendContext(context) : context,
         });
-        this.stats = new AdaptivePlaywrightCrawlerStatistics({
-            logMessage: `${this.log.getOptions().prefix} request statistics:`,
-            config,
-            ...statisticsOptions,
+    }
+    async init() {
+        // Only the predictor we built ourselves is ours to initialize - an injected one is borrowed, so its
+        // lifecycle (including restoring persisted state) stays with whoever created it.
+        await this.#renderingTypePredictor.ifOwned((predictor) => predictor.initialize());
+        return await super.init();
+    }
+    buildContextPipeline() {
+        const errorMessage = (prop) => `The \`${prop}\` property is not available on the outer context pipeline of AdaptivePlaywrightCrawler - it is provided by the inner (static/browser) pipelines`;
+        return super.buildContextPipeline().compose({
+            action: async ({ request }) => ({
+                get request() {
+                    return request;
+                },
+                get response() {
+                    throw new Error(errorMessage('response'));
+                },
+                get page() {
+                    throw new Error(errorMessage('page'));
+                },
+                get querySelector() {
+                    throw new Error(errorMessage('querySelector'));
+                },
+                get querySelectorAll() {
+                    throw new Error(errorMessage('querySelectorAll'));
+                },
+                get waitForSelector() {
+                    throw new Error(errorMessage('waitForSelector'));
+                },
+                get parseWithCheerio() {
+                    throw new Error(errorMessage('parseWithCheerio'));
+                },
+            }),
         });
-        this.preventDirectStorageAccess = preventDirectStorageAccess;
     }
     async adaptCheerioContext(cheerioContext) {
-        // Capture the original response to avoid infinite recursion when the getter is copied to the context
-        const originalResponse = cheerioContext.response;
-        const enqueueLinks = this.resultObjects.get(cheerioContext)?.enqueueLinks;
-        if (enqueueLinks === 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');
             },
-            get response() {
-                return {
-                    // TODO remove this once cheerioContext.response is just a Response
-                    complete: true,
-                    headers: originalResponse.headers,
-                    trailers: {},
-                    url: originalResponse.url,
-                    statusCode: originalResponse.statusCode,
-                    redirectUrls: originalResponse.redirectUrls ?? [],
-                };
-            },
             async querySelector(selector) {
+                return cheerioContext.$(selector).first();
+            },
+            async querySelectorAll(selector) {
                 return cheerioContext.$(selector);
             },
-            async enqueueLinks(options = {}) {
+            enqueueLinks: async (options = {}) => {
                 const urls = options.urls ??
                     extractUrlsFromCheerio(cheerioContext.$, options.selector, options.baseUrl ?? cheerioContext.request.loadedUrl);
-                await enqueueLinks({ ...options, urls });
+                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 enqueueLinks = this.resultObjects.get(playwrightContext)?.enqueueLinks;
-        if (enqueueLinks === undefined) {
-            throw new Error('Logical error - `this.resultObjects` does not contain the result object');
-        }
         return {
-            get response() {
-                return {
-                    url: originalResponse.url(),
-                    statusCode: originalResponse.status(),
-                    headers: originalResponse.headers(),
-                    trailers: {},
-                    complete: true,
-                    redirectUrls: [],
-                };
-            },
+            response: new Response(Uint8Array.from(await originalResponse.body()), {
+                headers: originalResponse.headers(),
+                status: originalResponse.status(),
+                statusText: originalResponse.statusText(),
+            }),
             async querySelector(selector, timeoutMs = 5000) {
                 const locator = playwrightContext.page.locator(selector).first();
                 await locator.waitFor({ timeout: timeoutMs, state: 'attached' });
                 const $ = await playwrightContext.parseWithCheerio();
-                return $(selector);
+                return $(selector).first();
             },
-            async enqueueLinks(options = {}, timeoutMs = 5000) {
-                const selector = options.selector ?? 'a';
+            async querySelectorAll(selector, timeoutMs = 5000) {
                 const locator = playwrightContext.page.locator(selector).first();
                 await locator.waitFor({ timeout: timeoutMs, state: 'attached' });
+                const $ = await playwrightContext.parseWithCheerio();
+                return $(selector);
+            },
+            enqueueLinks: async (options = {}, timeoutMs = 5000) => {
                 // TODO consider using `context.parseWithCheerio` to make this universal and avoid code duplication
-                const urls = options.urls ??
-                    (await extractUrlsFromPage(playwrightContext.page, selector, options.baseUrl ?? playwrightContext.request.loadedUrl));
-                await enqueueLinks({ ...options, urls });
+                let urls;
+                if (options.urls === undefined) {
+                    const selector = options.selector ?? 'a';
+                    const locator = playwrightContext.page.locator(selector).first();
+                    await locator.waitFor({ timeout: timeoutMs, state: 'attached' });
+                    urls =
+                        options.urls ??
+                            (await extractUrlsFromPage(playwrightContext.page, selector, options.baseUrl ?? playwrightContext.request.loadedUrl));
+                }
+                else {
+                    urls = options.urls;
+                }
+                return (await this.enqueueLinks({ ...options, urls }, playwrightContext.request));
             },
         };
     }
-    async crawlOne(renderingType, context, useStateFunction) {
-        const result = new RequestHandlerResult(this.config, 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),
-            enqueueLinks: result.enqueueLinks,
+        const attemptBoundContextHelpers = {
+            useState: useStateFunction,
             log: this.createLogProxy(context.log, logs),
             registerDeferredCleanup: (cleanup) => deferredCleanup.push(cleanup),
         };
-        const subCrawlerContext = { ...context, ...resultBoundContextHelpers };
-        this.resultObjects.set(subCrawlerContext, result);
+        const subCrawlerContext = Object.defineProperties({}, Object.getOwnPropertyDescriptors(context));
+        // 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 });
+        }
         try {
             const callAdaptiveRequestHandler = async () => {
                 if (renderingType === 'static') {
-                    await this.staticContextPipeline.call(subCrawlerContext, async (finalContext) => await this.requestHandler(finalContext));
+                    await this.#staticContextPipeline.call(subCrawlerContext, this.requestHandler.bind(this));
                 }
                 else if (renderingType === 'clientOnly') {
-                    await this.browserContextPipeline.call(subCrawlerContext, async (finalContext) => await this.requestHandler(finalContext));
+                    await this.#browserContextPipeline.call(subCrawlerContext, this.requestHandler.bind(this));
                 }
             };
-            await addTimeoutToPromise(async () => withCheckedStorageAccess(() => {
-                if (this.preventDirectStorageAccess) {
-                    throw new Error('Directly accessing storage in a request handler is not allowed in AdaptivePlaywrightCrawler');
-                }
-            }, callAdaptiveRequestHandler), this.individualRequestHandlerTimeoutMillis, 'Request handler timed out');
-            return { result, ok: true, logs };
+            // this crawler overrides `runRequestHandler` and times each rendering-type run itself, so it has
+            // 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 () => transaction.run(callAdaptiveRequestHandler), timeoutMillis, 'Request handler timed out');
+            return { result: transaction, ok: true, logs };
         }
         catch (error) {
             return { error, ok: false, logs };
@@ -295,89 +327,111 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
         }
     }
     async runRequestHandler(crawlingContext) {
-        const renderingTypePrediction = this.renderingTypePredictor.predict(crawlingContext.request);
+        const renderingTypePrediction = this.#renderingTypePredictor.value.predict(crawlingContext.request);
         const shouldDetectRenderingType = Math.random() < renderingTypePrediction.detectionProbabilityRecommendation;
         if (!shouldDetectRenderingType) {
             crawlingContext.log.debug(`Predicted rendering type ${renderingTypePrediction.renderingType} for ${crawlingContext.request.url}`);
         }
-        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);
-            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);
-                return;
-            }
-            // Execution will "fall through" and try running the request handler in a browser
-            if (!plainHTTPRun.ok) {
-                const actualError = plainHTTPRun.error instanceof RequestHandlerError
-                    ? plainHTTPRun.error.cause
-                    : plainHTTPRun.error;
-                crawlingContext.log.exception(actualError, `HTTP-only request handler failed for ${crawlingContext.request.url}`);
-            }
-            else {
-                crawlingContext.log.warning(`HTTP-only request handler returned a suspicious result for ${crawlingContext.request.url}`);
-                this.stats.trackRenderingTypeMisprediction();
-            }
-        }
-        crawlingContext.log.debug(`Running browser request handler for ${crawlingContext.request.url}`);
-        this.stats.trackBrowserRequestHandlerRun();
-        // Run the request handler in a browser. The copy of the crawler state is kept so that we can perform
-        // a rendering type detection if necessary. Without this measure, the HTTP request handler would run
-        // under different conditions, which could change its behavior. Changes done to the crawler state by
-        // the HTTP request handler will not be committed to the actual storage.
-        const stateTracker = {
-            stateCopy: null,
-            async getLiveState(defaultValue = {}) {
-                const state = await crawlingContext.useState(defaultValue);
-                if (this.stateCopy === null) {
-                    this.stateCopy = JSON.parse(JSON.stringify(state));
-                }
-                return state;
-            },
-            async getStateCopy(defaultValue = {}) {
-                if (this.stateCopy === null) {
-                    return defaultValue;
+        // 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, 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 plainHTTPRun.result.commit();
+                    return;
                 }
-                return this.stateCopy;
-            },
-        };
-        const browserRun = await this.crawlOne('clientOnly', crawlingContext, stateTracker.getLiveState.bind(stateTracker));
-        if (!browserRun.ok) {
-            throw browserRun.error;
-        }
-        await this.commitResult(crawlingContext, browserRun.result);
-        if (shouldDetectRenderingType) {
-            crawlingContext.log.debug(`Detecting rendering type for ${crawlingContext.request.url}`);
-            const plainHTTPRun = await this.crawlOne('static', crawlingContext, stateTracker.getStateCopy.bind(stateTracker));
-            const detectionResult = (() => {
+                // Execution will "fall through" and try running the request handler in a browser
                 if (!plainHTTPRun.ok) {
-                    return 'clientOnly';
+                    const actualError = plainHTTPRun.error instanceof RequestHandlerError
+                        ? plainHTTPRun.error.cause
+                        : plainHTTPRun.error;
+                    if (await this.#shouldPropagateError(actualError, crawlingContext)) {
+                        throw actualError;
+                    }
+                    crawlingContext.log.exception(actualError, `HTTP-only request handler failed for ${crawlingContext.request.url}`);
                 }
-                if (this.resultComparator(plainHTTPRun.result, browserRun.result)) {
-                    return 'static';
+                else {
+                    crawlingContext.log.warning(`HTTP-only request handler returned a suspicious result for ${crawlingContext.request.url}`);
+                    this.stats.trackRenderingTypeMisprediction();
                 }
-                return 'clientOnly';
-            })();
-            crawlingContext.log.debug(`Detected rendering type ${detectionResult} for ${crawlingContext.request.url}`);
-            this.renderingTypePredictor.storeResult(crawlingContext.request, detectionResult);
+            }
+            crawlingContext.log.debug(`Running browser request handler for ${crawlingContext.request.url}`);
+            this.stats.trackBrowserRequestHandlerRun();
+            // Run the request handler in a browser. The copy of the crawler state is kept so that we can perform
+            // a rendering type detection if necessary. Without this measure, the HTTP request handler would run
+            // under different conditions, which could change its behavior. Changes done to the crawler state by
+            // the HTTP request handler will not be committed to the actual storage.
+            const stateTracker = {
+                stateCopy: null,
+                async getLiveState(defaultValue = {}) {
+                    const state = await crawlingContext.useState(defaultValue);
+                    if (this.stateCopy === null) {
+                        this.stateCopy = JSON.parse(JSON.stringify(state));
+                    }
+                    return state;
+                },
+                async getStateCopy(defaultValue = {}) {
+                    if (this.stateCopy === null) {
+                        return defaultValue;
+                    }
+                    return this.stateCopy;
+                },
+            };
+            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 browserRun.result.commit();
+            if (shouldDetectRenderingType) {
+                crawlingContext.log.debug(`Detecting rendering type for ${crawlingContext.request.url}`);
+                // 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';
+                    }
+                    const comparisonResult = this.#resultComparator(plainHTTPRun.result, browserRun.result);
+                    if (comparisonResult === true || comparisonResult === 'equal') {
+                        return 'static';
+                    }
+                    if (comparisonResult === false || comparisonResult === 'different') {
+                        return 'clientOnly';
+                    }
+                    return undefined;
+                })();
+                crawlingContext.log.debug(`Detected rendering type ${detectionResult} for ${crawlingContext.request.url}`);
+                if (detectionResult !== undefined) {
+                    this.#renderingTypePredictor.value.storeResult(crawlingContext.request, detectionResult);
+                }
+            }
+        }
+        finally {
+            // 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.enqueueLinks.map(async (params) => await crawlingContext.enqueueLinks(...params)),
-            ...calls.addRequests.map(async (params) => crawlingContext.addRequests(...params)),
-            ...Object.entries(keyValueStoreChanges).map(async ([storeIdOrName, changes]) => {
-                const store = await crawlingContext.getKeyValueStore(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));
+    async enqueueLinks(options, request) {
+        const baseUrl = resolveBaseUrlForEnqueueLinksFiltering({
+            enqueueStrategy: options?.strategy,
+            finalRequestUrl: request.loadedUrl,
+            originalRequestUrl: request.url,
+            userProvidedBaseUrl: options?.baseUrl,
+        });
+        // 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, {
@@ -393,12 +447,39 @@ export class AdaptivePlaywrightCrawler extends BasicCrawler {
     }
     async teardown() {
         await super.teardown();
-        for (const hook of this.teardownHooks) {
+        for (const hook of this.#teardownHooks) {
             await hook();
         }
     }
 }
-export function createAdaptivePlaywrightRouter(routes) {
-    return Router.create(routes);
+export function createAdaptivePlaywrightRouter(routesOrSchemas) {
+    return Router.create(routesOrSchemas);
+}
+/**
+ * An opt-in {@link AdaptivePlaywrightCrawlerOptions.resultComparator|`resultComparator`} that considers two
+ * request handler results equal only if *all* of their observable effects match - the pushed dataset items, the
+ * enqueued requests, and the key-value store changes. This is stricter than the default comparator, which only
+ * compares dataset items.
+ *
+ * **Beware:** enqueued URLs are compared exactly. The same page rendered in a browser and via plain HTTP often
+ * yields links that differ only in tracking query parameters, for example:
+ * - `https://sdk.apify.com/docs/guides/getting-started`
+ * - `https://sdk.apify.com/docs/guides/getting-started?__hsfp=1136113150&__hssc=7591405.1.173549427712`
+ *
+ * Such links are treated as *different*, which will make the crawler favor browser rendering for those pages.
+ *
+ * **Example usage:**
+ * ```ts
+ * const crawler = new AdaptivePlaywrightCrawler({
+ *     resultComparator: fullResultComparator,
+ *     async requestHandler({ pushData, enqueueLinks }) {
+ *         // ...
+ *     },
+ * });
+ * ```
+ */
+export function fullResultComparator(resultA, resultB) {
+    return (isDeepStrictEqual(resultA.datasetItems, resultB.datasetItems) &&
+        isDeepStrictEqual(resultA.enqueuedUrls, resultB.enqueuedUrls) &&
+        isDeepStrictEqual(resultA.keyValueStoreChanges, resultB.keyValueStoreChanges));
 }
-//# sourceMappingURL=adaptive-playwright-crawler.js.map