@crawlee/puppeteer 4.0.0-rc.0 → 4.0.0-rc.1

package/README.md

@@ -34,7 +34,7 @@ Crawlee is available as the [`crawlee`](https://www.npmjs.com/package/crawlee) N
 
 We recommend visiting the [Introduction tutorial](https://crawlee.dev/js/docs/introduction) in Crawlee documentation for more information.
 
-> Crawlee requires **Node.js 16 or higher**.
+> Crawlee requires **Node.js 22.13 or higher**.
 
 ### With Crawlee CLI
 

package/index.d.ts

@@ -2,9 +2,7 @@ export * from '@crawlee/browser';
 export * from './internals/puppeteer-browser-pool.js';
 export * from './internals/puppeteer-crawler.js';
 export * from './internals/puppeteer-launcher.js';
-export * as puppeteerRequestInterception from './internals/utils/puppeteer_request_interception.js';
 export type { InterceptHandler } from './internals/utils/puppeteer_request_interception.js';
 export * as puppeteerUtils from './internals/utils/puppeteer_utils.js';
-export type { BlockRequestsOptions, CompiledScriptFunction, CompiledScriptParams, DirectNavigationOptions as PuppeteerDirectNavigationOptions, InfiniteScrollOptions, InjectFileOptions, SaveSnapshotOptions, } from './internals/utils/puppeteer_utils.js';
-export * as puppeteerClickElements from './internals/enqueue-links/click-elements.js';
+export type { DirectNavigationOptions as PuppeteerDirectNavigationOptions } from './internals/utils/puppeteer_utils.js';
 export type { EnqueueLinksByClickingElementsOptions } from './internals/enqueue-links/click-elements.js';

package/index.js

@@ -2,6 +2,4 @@ export * from '@crawlee/browser';
 export * from './internals/puppeteer-browser-pool.js';
 export * from './internals/puppeteer-crawler.js';
 export * from './internals/puppeteer-launcher.js';
-export * as puppeteerRequestInterception from './internals/utils/puppeteer_request_interception.js';
 export * as puppeteerUtils from './internals/utils/puppeteer_utils.js';
-export * as puppeteerClickElements from './internals/enqueue-links/click-elements.js';

package/internals/enqueue-links/click-elements.d.ts

@@ -1,7 +1,7 @@
 import type { IRequestManager, RequestTransform, SkippedRequestCallback, UrlPatternInput } from '@crawlee/browser';
 import type { BatchAddRequestsResult, Dictionary } from '@crawlee/types';
 // @ts-ignore optional peer dependency or compatibility with es2022
-import type { ClickOptions, Page, Target } from 'puppeteer';
+import type { ClickOptions, Page } from 'puppeteer';
 export interface EnqueueLinksByClickingElementsOptions {
     /**
      * Puppeteer [`Page`](https://pptr.dev/#?product=Puppeteer&show=api-class-page) object.
@@ -142,7 +142,7 @@ export interface EnqueueLinksByClickingElementsOptions {
  * **Example usage**
  *
  * ```javascript
- * await utils.puppeteer.enqueueLinksByClickingElements({
+ * await puppeteerUtils.enqueueLinksByClickingElements({
  *   page,
  *   requestManager,
  *   selector: 'a.product-detail',
@@ -169,20 +169,19 @@ interface ClickElementsAndInterceptNavigationRequestsOptions extends WaitForPage
  * Clicks all elements of given page matching given selector.
  * Catches and intercepts all initiated navigation requests and opened pages.
  * Returns a list of all target URLs.
+ *
+ * Not part of the public API — exported only so tests can import this module directly.
  * @ignore
  */
 export declare function clickElementsAndInterceptNavigationRequests(options: ClickElementsAndInterceptNavigationRequestsOptions): Promise<Dictionary[]>;
-/**
- * We're only interested in pages created by the page we're currently clicking in.
- * There will generally be a lot of other targets being created in the browser.
- */
-export declare function isTargetRelevant(page: Page, target: Target): boolean;
 /**
  * Click all elements matching the given selector. To be able to do this using
  * Puppeteer's `.click()` we need to make sure the elements are reachable by mouse,
  * so we first move them to the top of the page's stacking context and then click.
  * We do all in series to prevent elements from hiding one another. Therefore,
  * for large element sets, this will take considerable amount of time.
+ *
+ * Not part of the public API — exported only so tests can import this module directly.
  * @ignore
  */
 export declare function clickElements(page: Page, selector: string, clickOptions?: ClickOptions & {

package/internals/enqueue-links/click-elements.js

@@ -1,5 +1,6 @@
 import { URL } from 'node:url';
-import { applyRequestTransform, constructUrlPatternObjects, createRequestOptions, filterRequestOptionsByPatterns, parseArgument, urlPatternSchema, Request, schemas, serviceLocator, } from '@crawlee/browser';
+import { applyRequestTransform, constructUrlPatternObjects, createRequestOptions, createSkippedRequestArgs, filterRequestOptionsByPatterns, urlPatternSchema, Request, serviceLocator, } from '@crawlee/browser';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
 import { z } from 'zod';
 import { addInterceptRequestHandler, removeInterceptRequestHandler } from '../utils/puppeteer_request_interception.js';
 const STARTING_Z_INDEX = 2147400000;
@@ -47,7 +48,7 @@ const enqueueLinksByClickingElementsOptionsSchema = z.strictObject({
  * **Example usage**
  *
  * ```javascript
- * await utils.puppeteer.enqueueLinksByClickingElements({
+ * await puppeteerUtils.enqueueLinksByClickingElements({
  *   page,
  *   requestManager,
  *   selector: 'a.product-detail',
@@ -65,6 +66,7 @@ export async function enqueueLinksByClickingElements(options) {
     const { page, requestManager, selector, clickOptions, include, exclude, transformRequestFunction, waitForPageIdleSecs, maxWaitForPageIdleSecs, forefront, onSkippedRequest, } = parsedOptions;
     const waitForPageIdleMillis = waitForPageIdleSecs * 1000;
     const maxWaitForPageIdleMillis = maxWaitForPageIdleSecs * 1000;
+    const hasOnSkippedRequest = onSkippedRequest !== undefined;
     const urlExcludePatternObjects = exclude?.length ? constructUrlPatternObjects(exclude) : [];
     const urlPatternObjects = include?.length ? constructUrlPatternObjects(include) : [];
     const interceptedRequests = await clickElementsAndInterceptNavigationRequests({
@@ -76,15 +78,15 @@ export async function enqueueLinksByClickingElements(options) {
     });
     const requestOptions = createRequestOptions(interceptedRequests, parsedOptions);
     const skippedByFilters = [];
-    let filteredOptions = filterRequestOptionsByPatterns(requestOptions, urlPatternObjects.length > 0 ? urlPatternObjects : undefined, urlExcludePatternObjects, undefined, (url) => skippedByFilters.push(url));
+    let filteredOptions = filterRequestOptionsByPatterns(requestOptions, urlPatternObjects.length > 0 ? urlPatternObjects : undefined, urlExcludePatternObjects, undefined, hasOnSkippedRequest ? (opts) => skippedByFilters.push(opts) : undefined);
     if (onSkippedRequest && skippedByFilters.length > 0) {
-        await Promise.all(skippedByFilters.map(async (url) => onSkippedRequest({ url, reason: 'filters' })));
+        await Promise.all(skippedByFilters.map(async (opts) => onSkippedRequest(createSkippedRequestArgs(opts, 'filters'))));
     }
     if (transformRequestFunction) {
         const skippedByTransform = [];
-        filteredOptions = applyRequestTransform(filteredOptions, transformRequestFunction, (r) => skippedByTransform.push(r));
+        filteredOptions = applyRequestTransform(filteredOptions, transformRequestFunction, hasOnSkippedRequest ? (r) => skippedByTransform.push(r) : undefined);
         if (onSkippedRequest && skippedByTransform.length > 0) {
-            await Promise.all(skippedByTransform.map(async (r) => onSkippedRequest({ url: r.url, reason: 'transform' })));
+            await Promise.all(skippedByTransform.map(async (r) => onSkippedRequest(createSkippedRequestArgs(r, 'transform'))));
         }
     }
     const requests = filteredOptions.map((opts) => new Request(opts));
@@ -95,6 +97,8 @@ export async function enqueueLinksByClickingElements(options) {
  * Clicks all elements of given page matching given selector.
  * Catches and intercepts all initiated navigation requests and opened pages.
  * Returns a list of all target URLs.
+ *
+ * Not part of the public API — exported only so tests can import this module directly.
  * @ignore
  */
 export async function clickElementsAndInterceptNavigationRequests(options) {
@@ -173,7 +177,7 @@ function createTargetCreatedHandler(page, requests) {
  * We're only interested in pages created by the page we're currently clicking in.
  * There will generally be a lot of other targets being created in the browser.
  */
-export function isTargetRelevant(page, target) {
+function isTargetRelevant(page, target) {
     // oxlint-disable-next-line typescript/no-deprecated -- the non-deprecated replacement (opener.page()) is async and would force every call site to await, including EventEmitter callbacks
     return target.type() === 'page' && page.target() === target.opener();
 }
@@ -218,6 +222,8 @@ async function preventHistoryNavigation(page) {
  * so we first move them to the top of the page's stacking context and then click.
  * We do all in series to prevent elements from hiding one another. Therefore,
  * for large element sets, this will take considerable amount of time.
+ *
+ * Not part of the public API — exported only so tests can import this module directly.
  * @ignore
  */
 export async function clickElements(page, selector, clickOptions) {

package/internals/puppeteer-crawler.d.ts

@@ -2,12 +2,10 @@ import type { BrowserCrawlerOptions, BrowserCrawlingContext, BrowserHook, GetUse
 import { BrowserCrawler } from '@crawlee/browser';
 import type { Dictionary } from '@crawlee/types';
 // @ts-ignore optional peer dependency or compatibility with es2022
-import type { HTTPResponse, LaunchOptions, Page } from 'puppeteer';
+import type { HTTPResponse, Page } from 'puppeteer';
 import { z } from 'zod';
-import type { EnqueueLinksByClickingElementsOptions } from './enqueue-links/click-elements.js';
 import type { PuppeteerLaunchContext } from './puppeteer-launcher.js';
-import type { InterceptHandler } from './utils/puppeteer_request_interception.js';
-import type { BlockRequestsOptions, DirectNavigationOptions, InfiniteScrollOptions, InjectFileOptions, PuppeteerContextUtils, SaveSnapshotOptions } from './utils/puppeteer_utils.js';
+import type { DirectNavigationOptions, PuppeteerContextUtils } from './utils/puppeteer_utils.js';
 export type PuppeteerGoToOptions = NonNullable<Parameters<Page['goto']>[1]>;
 export interface PuppeteerCrawlingContext<UserData extends Dictionary = any> extends BrowserCrawlingContext<Page, HTTPResponse, UserData, PuppeteerGoToOptions>, PuppeteerContextUtils {
 }
@@ -122,20 +120,12 @@ export interface PuppeteerCrawlerOptions<ContextExtension = Dictionary<never>, E
  * ```
  * @category Crawlers
  */
-export declare class PuppeteerCrawler<ContextExtension = Dictionary<never>, ExtendedContext extends PuppeteerCrawlingContext = PuppeteerCrawlingContext & ContextExtension, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<PuppeteerCrawlingContext['request']>>, StatisticStateExtension extends object = {}> extends BrowserCrawler<Page, HTTPResponse, LaunchOptions, PuppeteerCrawlingContext, ContextExtension, ExtendedContext, Routes, StatisticStateExtension> {
+export declare class PuppeteerCrawler<ContextExtension = Dictionary<never>, ExtendedContext extends PuppeteerCrawlingContext = PuppeteerCrawlingContext & ContextExtension, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<PuppeteerCrawlingContext['request']>>, StatisticStateExtension extends object = {}> extends BrowserCrawler<Page, HTTPResponse, PuppeteerCrawlingContext, ContextExtension, ExtendedContext, Routes, StatisticStateExtension> {
+    #private;
+    /**
+     * @internal
+     */
     protected static optionsShape: {
-        headless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
-        navigationTimeoutSecs: z.ZodDefault<z.ZodCustom<number, number>>;
-        preNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
-        postNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
-        launchContext: z.ZodDefault<z.ZodCustom<Dictionary, Dictionary>>;
-        browserPool: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
-        browserPoolBuilder: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
-        remoteBrowser: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
-        saveResponseCookies: z.ZodDefault<z.ZodBoolean>;
-        proxyConfiguration: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
-        ignoreIframes: z.ZodDefault<z.ZodBoolean>;
-        ignoreShadowRoots: z.ZodDefault<z.ZodBoolean>;
         contextPipelineBuilder: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
         extendContext: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
         requestList: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
@@ -167,26 +157,23 @@ export declare class PuppeteerCrawler<ContextExtension = Dictionary<never>, Exte
         }, z.core.$strict>]>>;
         onSkippedRequest: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        httpClient: z.ZodOptional<z.ZodCustom<import("@crawlee/http-client").BaseHttpClient, import("@crawlee/http-client").BaseHttpClient>>;
+        httpClient: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/http-client").BaseHttpClient>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        configuration: z.ZodOptional<z.ZodCustom<import("@crawlee/browser").Configuration, import("@crawlee/browser").Configuration>>;
+        configuration: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/browser").Configuration>>;
         storageBackend: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        eventManager: z.ZodOptional<z.ZodCustom<import("@crawlee/browser").EventManager, import("@crawlee/browser").EventManager>>;
+        eventManager: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/browser").EventManager>>;
         logger: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
         minConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
         maxConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
+        initialConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
         maxRequestsPerMinute: z.ZodOptional<z.ZodCustom<number, number>>;
         keepAlive: z.ZodOptional<z.ZodBoolean>;
         statistics: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
         id: z.ZodOptional<z.ZodString>;
-    };
-    protected static optionsSchema: z.ZodObject<{
-        headless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
         navigationTimeoutSecs: z.ZodDefault<z.ZodCustom<number, number>>;
         preNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
         postNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
-        launchContext: z.ZodDefault<z.ZodCustom<Dictionary, Dictionary>>;
         browserPool: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
         browserPoolBuilder: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
         remoteBrowser: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
@@ -194,6 +181,11 @@ export declare class PuppeteerCrawler<ContextExtension = Dictionary<never>, Exte
         proxyConfiguration: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
         ignoreIframes: z.ZodDefault<z.ZodBoolean>;
         ignoreShadowRoots: z.ZodDefault<z.ZodBoolean>;
+        launchContext: z.ZodDefault<z.ZodCustom<Dictionary, Dictionary>>;
+        headless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    };
+    /** @internal */
+    protected static optionsSchema: z.ZodObject<{
         contextPipelineBuilder: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
         extendContext: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
         requestList: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
@@ -225,43 +217,37 @@ export declare class PuppeteerCrawler<ContextExtension = Dictionary<never>, Exte
         }, z.core.$strict>]>>;
         onSkippedRequest: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        httpClient: z.ZodOptional<z.ZodCustom<import("@crawlee/http-client").BaseHttpClient, import("@crawlee/http-client").BaseHttpClient>>;
+        httpClient: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/http-client").BaseHttpClient>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        configuration: z.ZodOptional<z.ZodCustom<import("@crawlee/browser").Configuration, import("@crawlee/browser").Configuration>>;
+        configuration: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/browser").Configuration>>;
         storageBackend: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
 // @ts-ignore optional peer dependency or compatibility with es2022
-        eventManager: z.ZodOptional<z.ZodCustom<import("@crawlee/browser").EventManager, import("@crawlee/browser").EventManager>>;
+        eventManager: z.ZodOptional<z.ZodInstanceOf<import("@crawlee/browser").EventManager>>;
         logger: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
         minConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
         maxConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
+        initialConcurrency: z.ZodOptional<z.ZodCustom<number, number>>;
         maxRequestsPerMinute: z.ZodOptional<z.ZodCustom<number, number>>;
         keepAlive: z.ZodOptional<z.ZodBoolean>;
         statistics: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
         id: z.ZodOptional<z.ZodString>;
+        navigationTimeoutSecs: z.ZodDefault<z.ZodCustom<number, number>>;
+        preNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
+        postNavigationHooks: z.ZodDefault<z.ZodCustom<unknown[], unknown[]>>;
+        browserPool: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
+        browserPoolBuilder: z.ZodOptional<z.ZodCustom<(...args: any[]) => unknown, (...args: any[]) => unknown>>;
+        remoteBrowser: z.ZodOptional<z.ZodCustom<Dictionary, Dictionary>>;
+        saveResponseCookies: z.ZodDefault<z.ZodBoolean>;
+        proxyConfiguration: z.ZodOptional<z.ZodType<Dictionary<any>, unknown, z.core.$ZodTypeInternals<Dictionary<any>, unknown>>>;
+        ignoreIframes: z.ZodDefault<z.ZodBoolean>;
+        ignoreShadowRoots: z.ZodDefault<z.ZodBoolean>;
+        launchContext: z.ZodDefault<z.ZodCustom<Dictionary, Dictionary>>;
+        headless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     }, z.core.$strict>;
     /**
      * All `PuppeteerCrawler` parameters are passed via an options object.
      */
     constructor(options?: PuppeteerCrawlerOptions<ContextExtension, ExtendedContext, Routes, StatisticStateExtension>);
-// @ts-ignore optional peer dependency or compatibility with es2022
-    protected buildContextPipeline(): import("@crawlee/browser").ContextPipeline<import("@crawlee/browser").CrawlingContext<Dictionary>, BrowserCrawlingContext<Page, HTTPResponse, Dictionary, Dictionary> & {
-        injectFile: (filePath: string, options?: InjectFileOptions) => Promise<unknown>;
-        injectJQuery: () => Promise<void>;
-        waitForSelector: (selector: string, timeoutMs?: number) => Promise<void>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        parseWithCheerio: (selector?: string, timeoutMs?: number) => Promise<import("@crawlee/browser").CheerioAPI>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        enqueueLinksByClickingElements: (options: Omit<EnqueueLinksByClickingElementsOptions, "page" | "requestManager">) => Promise<import("@crawlee/types").BatchAddRequestsResult>;
-        blockRequests: (options?: BlockRequestsOptions) => Promise<void>;
-// @ts-ignore optional peer dependency or compatibility with es2022
-        compileScript: (scriptString: string, ctx?: Dictionary) => import("./utils/puppeteer_utils.js").CompiledScriptFunction;
-        addInterceptRequestHandler: (handler: InterceptHandler) => Promise<void>;
-        removeInterceptRequestHandler: (handler: InterceptHandler) => Promise<void>;
-        infiniteScroll: (options?: InfiniteScrollOptions) => Promise<void>;
-        saveSnapshot: (options?: SaveSnapshotOptions) => Promise<void>;
-        closeCookieModals: () => Promise<void>;
-    }>;
-    private enhanceContext;
     protected navigationHandler(crawlingContext: PuppeteerCrawlingContext, gotoOptions: DirectNavigationOptions): Promise<HTTPResponse | null>;
 }
 /**

package/internals/puppeteer-crawler.js

@@ -1,8 +1,9 @@
-import { assertBrowserPoolNotConfigured, BrowserCrawler, RequestState, Router } from '@crawlee/browser';
-import { parseArgument, serviceLocator } from '@crawlee/core';
+import { BrowserCrawler, RequestState, Router } from '@crawlee/browser';
+import { serviceLocator } from '@crawlee/core';
+import { assertBrowserPoolNotConfigured, parseArgument, schemas } from '@crawlee/utils/internal';
 import { z } from 'zod';
 import { puppeteerBrowserPool, remotePuppeteerBrowserPool } from './puppeteer-browser-pool.js';
-import { gotoExtended, puppeteerUtils } from './utils/puppeteer_utils.js';
+import * as puppeteerUtils from './utils/puppeteer_utils.js';
 /**
  * Provides a simple framework for parallel crawling of web pages
  * using headless Chrome with [Puppeteer](https://github.com/puppeteer/puppeteer).
@@ -69,19 +70,24 @@ import { gotoExtended, puppeteerUtils } from './utils/puppeteer_utils.js';
  * @category Crawlers
  */
 export class PuppeteerCrawler extends BrowserCrawler {
+    /**
+     * @internal
+     */
     static optionsShape = {
         ...BrowserCrawler.optionsShape,
+        launchContext: schemas.anyObject.default(() => ({})),
         // Deliberately looser than the declared type: Puppeteer's own accepted string values have moved over
         // time (`'new'`/`'old'`, now `'shell'`), and the value is forwarded to it verbatim.
         headless: z.union([z.boolean(), z.string()]).optional(),
     };
+    /** @internal */
     static optionsSchema = z.strictObject(PuppeteerCrawler.optionsShape);
     /**
      * All `PuppeteerCrawler` parameters are passed via an options object.
      */
     constructor(options = {}) {
         const parsedOptions = parseArgument(options, PuppeteerCrawler.optionsSchema, 'PuppeteerCrawlerOptions');
-        const { launchContext, headless, configuration, proxyConfiguration, contextPipelineBuilder, ...browserCrawlerOptions } = parsedOptions;
+        const { launchContext, headless, configuration, proxyConfiguration, ...browserCrawlerOptions } = parsedOptions;
         if (launchContext.proxyUrl) {
             throw new Error('PuppeteerCrawlerOptions.launchContext.proxyUrl is not allowed in PuppeteerCrawler.' +
                 'Use PuppeteerCrawlerOptions.proxyConfiguration');
@@ -95,19 +101,18 @@ export class PuppeteerCrawler extends BrowserCrawler {
         }
         super({
             ...browserCrawlerOptions,
-            launchContext,
             configuration,
             proxyConfiguration,
             browserPoolBuilder: (remoteBrowser) => remoteBrowser
                 ? remotePuppeteerBrowserPool({ ...remoteBrowser, launchContext, headless, configuration })
                 : puppeteerBrowserPool({ launchContext, headless, configuration }),
-            contextPipelineBuilder: contextPipelineBuilder ?? (() => this.buildContextPipeline()),
+            contextPipelineBuilder: () => this.#buildContextPipeline(),
         });
     }
-    buildContextPipeline() {
-        return super.buildContextPipeline().compose({ action: this.enhanceContext.bind(this) });
+    #buildContextPipeline() {
+        return this.buildContextPipeline().compose(this.#enhanceContext.bind(this));
     }
-    async enhanceContext(context) {
+    async #enhanceContext(context) {
         const waitForSelector = async (selector, timeoutMs = 5_000) => {
             await context.page.waitForSelector(selector, { timeout: timeoutMs });
         };
@@ -142,11 +147,10 @@ export class PuppeteerCrawler extends BrowserCrawler {
                 ...options,
                 configuration: serviceLocator.getConfiguration(),
             }),
-            closeCookieModals: async () => puppeteerUtils.closeCookieModals(context.page),
         };
     }
     async navigationHandler(crawlingContext, gotoOptions) {
-        return gotoExtended(crawlingContext.page, crawlingContext.request, gotoOptions);
+        return puppeteerUtils.gotoExtended(crawlingContext.page, crawlingContext.request, gotoOptions);
     }
 }
 export function createPuppeteerRouter(routesOrSchemas) {

package/internals/puppeteer-launcher.d.ts

@@ -68,9 +68,10 @@ export interface PuppeteerLaunchContext extends BrowserLaunchContext<PuppeteerPl
  */
 export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin, unknown> {
     readonly configuration: Configuration;
+    /**
+     * @internal
+     */
     protected static optionsShape: {
-// @ts-ignore optional peer dependency or compatibility with es2022
-        launcher: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
         proxyUrl: z.ZodOptional<z.ZodURL>;
         useChrome: z.ZodOptional<z.ZodBoolean>;
         useIncognitoPages: z.ZodOptional<z.ZodBoolean>;
@@ -80,10 +81,11 @@ export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin,
 // @ts-ignore optional peer dependency or compatibility with es2022
         launchOptions: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
         userAgent: z.ZodOptional<z.ZodString>;
-    };
-    protected static optionsSchema: z.ZodObject<{
 // @ts-ignore optional peer dependency or compatibility with es2022
         launcher: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
+    };
+    /** @internal */
+    protected static optionsSchema: z.ZodObject<{
         proxyUrl: z.ZodOptional<z.ZodURL>;
         useChrome: z.ZodOptional<z.ZodBoolean>;
         useIncognitoPages: z.ZodOptional<z.ZodBoolean>;
@@ -93,6 +95,8 @@ export declare class PuppeteerLauncher extends BrowserLauncher<PuppeteerPlugin,
 // @ts-ignore optional peer dependency or compatibility with es2022
         launchOptions: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
         userAgent: z.ZodOptional<z.ZodString>;
+// @ts-ignore optional peer dependency or compatibility with es2022
+        launcher: z.ZodOptional<z.ZodCustom<import("@crawlee/types").Dictionary, import("@crawlee/types").Dictionary>>;
     }, z.core.$strict>;
     /**
      * All `PuppeteerLauncher` parameters are passed via an launchContext object.

package/internals/puppeteer-launcher.js

@@ -1,5 +1,6 @@
-import { BrowserLauncher, Configuration, parseArgument, schemas } from '@crawlee/browser';
+import { BrowserLauncher, Configuration } from '@crawlee/browser';
 import { PuppeteerPlugin } from '@crawlee/browser-pool';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
 import { z } from 'zod';
 /**
  * `PuppeteerLauncher` is based on the `BrowserLauncher`. It launches `puppeteer` browser instance.
@@ -7,10 +8,14 @@ import { z } from 'zod';
  */
 export class PuppeteerLauncher extends BrowserLauncher {
     configuration;
+    /**
+     * @internal
+     */
     static optionsShape = {
         ...BrowserLauncher.optionsShape,
         launcher: schemas.anyObject.optional(),
     };
+    /** @internal */
     static optionsSchema = z.strictObject(PuppeteerLauncher.optionsShape);
     /**
      * All `PuppeteerLauncher` parameters are passed via an launchContext object.

package/internals/utils/puppeteer_request_interception.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { parseArgument, schemas, serviceLocator } from '@crawlee/browser';
+import { serviceLocator } from '@crawlee/browser';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
 const pageSchema = schemas.objectWithKeys(['goto', 'evaluate']);
 // We use weak maps here so that the content gets discarded after page gets closed.
 const pageInterceptRequestHandlersMap = new WeakMap(); // Maps page to an array of request interception handlers.

package/internals/utils/puppeteer_utils.d.ts

@@ -5,7 +5,7 @@
  * **Example usage:**
  *
  * ```javascript
- * import { launchPuppeteer, utils } from 'crawlee';
+ * import { launchPuppeteer, puppeteerUtils } from 'crawlee';
  *
  * // Open https://www.example.com in Puppeteer
  * const browser = await launchPuppeteer();
@@ -13,17 +13,16 @@
  * await page.goto('https://www.example.com');
  *
  * // Inject jQuery into a page
- * await utils.puppeteer.injectJQuery(page);
+ * await puppeteerUtils.injectJQuery(page);
  * ```
  * @module puppeteerUtils
  */
 import type { Request } from '@crawlee/browser';
 import { Configuration } from '@crawlee/browser';
 import type { BatchAddRequestsResult, Dictionary } from '@crawlee/types';
-import { type CheerioRoot } from '@crawlee/utils/internal';
-import type { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping.js';
+import type { CheerioAPI } from 'cheerio';
 // @ts-ignore optional peer dependency or compatibility with es2022
-import type { HTTPResponse, Page, ResponseForRequest } from 'puppeteer';
+import type { HTTPResponse, Page } from 'puppeteer';
 import type { EnqueueLinksByClickingElementsOptions } from '../enqueue-links/click-elements.js';
 import { enqueueLinksByClickingElements } from '../enqueue-links/click-elements.js';
 import type { InterceptHandler } from './puppeteer_request_interception.js';
@@ -101,7 +100,7 @@ export declare function injectFile(page: Page, filePath: string, options?: Injec
  *
  * **Example usage:**
  * ```javascript
- * await utils.puppeteer.injectJQuery(page);
+ * await puppeteerUtils.injectJQuery(page);
  * const title = await page.evaluate(() => {
  *   return $('head title').text();
  * });
@@ -122,14 +121,14 @@ export declare function injectJQuery(page: Page, options?: {
  *
  * **Example usage:**
  * ```javascript
- * const $ = await utils.puppeteer.parseWithCheerio(page);
+ * const $ = await puppeteerUtils.parseWithCheerio(page);
  * const title = $('title').text();
  * ```
  *
  * @param page Puppeteer [`Page`](https://pptr.dev/api/puppeteer.page) object.
  * @param ignoreShadowRoots
  */
-export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean, ignoreIframes?: boolean): Promise<CheerioRoot>;
+export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean, ignoreIframes?: boolean): Promise<CheerioAPI>;
 /**
  * Forces the Puppeteer browser tab to block loading URLs that match a provided pattern.
  * This is useful to speed up crawling of websites, since it reduces the amount
@@ -156,13 +155,13 @@ export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean
  *
  * **Example usage**
  * ```javascript
- * import { launchPuppeteer, utils } from 'crawlee';
+ * import { launchPuppeteer, puppeteerUtils } from 'crawlee';
  *
  * const browser = await launchPuppeteer();
  * const page = await browser.newPage();
  *
  * // Block all requests to URLs that include `adsbygoogle.js` and also all defaults.
- * await utils.puppeteer.blockRequests(page, {
+ * await puppeteerUtils.blockRequests(page, {
  *     extraUrlPatterns: ['adsbygoogle.js'],
  * });
  *
@@ -173,33 +172,6 @@ export declare function parseWithCheerio(page: Page, ignoreShadowRoots?: boolean
  * @param [options]
  */
 export declare function blockRequests(page: Page, options?: BlockRequestsOptions): Promise<void>;
-/**
- * @internal
- */
-export declare function sendCDPCommand<T extends keyof ProtocolMapping.Commands>(page: Page, command: T, ...args: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
-/**
- * `blockResources()` has a high impact on performance in recent versions of Puppeteer.
- * Until this resolves, please use `utils.puppeteer.blockRequests()`.
- * @deprecated
- */
-export declare const blockResources: (page: Page, resourceTypes?: string[]) => Promise<void>;
-/**
- * *NOTE:* In recent versions of Puppeteer using this function entirely disables browser cache which resolves in sub-optimal
- * performance. Until this resolves, we suggest just relying on the in-browser cache unless absolutely necessary.
- *
- * Enables caching of intercepted responses into a provided object. Automatically enables request interception in Puppeteer.
- * *IMPORTANT*: Caching responses stores them to memory, so too loose rules could cause memory leaks for longer running crawlers.
- *   This issue should be resolved or atleast mitigated in future iterations of this feature.
- * @param page
- *   Puppeteer [`Page`](https://pptr.dev/api/puppeteer.page) object.
- * @param cache
- *   Object in which responses are stored
- * @param responseUrlRules
- *   List of rules that are used to check if the response should be cached.
- *   String rules are compared as page.url().includes(rule) while RegExp rules are evaluated as rule.test(page.url()).
- * @deprecated
- */
-export declare function cacheResponses(page: Page, cache: Dictionary<Partial<ResponseForRequest>>, responseUrlRules: (string | RegExp)[]): Promise<void>;
 /**
  * Compiles a Puppeteer script into an async function that may be executed at any time
  * by providing it with the following object:
@@ -315,7 +287,6 @@ export interface SaveSnapshotOptions {
  * @param [options]
  */
 export declare function saveSnapshot(page: Page, options?: SaveSnapshotOptions): Promise<void>;
-export declare function closeCookieModals(page: Page): Promise<void>;
 export interface PuppeteerContextUtils {
     /**
      * Injects a JavaScript file into current `page`.
@@ -377,7 +348,7 @@ export interface PuppeteerContextUtils {
      * });
      * ```
      */
-    parseWithCheerio(selector?: string, timeoutMs?: number): Promise<CheerioRoot>;
+    parseWithCheerio(selector?: string, timeoutMs?: number): Promise<CheerioAPI>;
     /**
      * The function finds elements matching a specific CSS selector in a Puppeteer page,
      * clicks all those elements using a mouse move and a left mouse button click and intercepts
@@ -548,33 +519,5 @@ export interface PuppeteerContextUtils {
      * Saves a full screenshot and HTML of the current page into a Key-Value store.
      */
     saveSnapshot(options?: SaveSnapshotOptions): Promise<void>;
-    /**
-     * Tries to close cookie consent modals on the page. Based on the I Don't Care About Cookies browser extension.
-     *
-     * Note that this method requires the idcac-playwright package to be installed.
-     * Crawlee does not include it by default due to licensing issues.
-     *
-     * To use this method, please install the package manually by running:
-     *
-     * ```bash
-     * npm install idcac-playwright
-     * ```
-     */
-    closeCookieModals(): Promise<void>;
 }
 export { enqueueLinksByClickingElements, addInterceptRequestHandler, removeInterceptRequestHandler };
-/** @internal */
-export declare const puppeteerUtils: {
-    injectFile: typeof injectFile;
-    injectJQuery: typeof injectJQuery;
-    enqueueLinksByClickingElements: typeof enqueueLinksByClickingElements;
-    blockRequests: typeof blockRequests;
-    compileScript: typeof compileScript;
-    gotoExtended: typeof gotoExtended;
-    addInterceptRequestHandler: typeof addInterceptRequestHandler;
-    removeInterceptRequestHandler: typeof removeInterceptRequestHandler;
-    infiniteScroll: typeof infiniteScroll;
-    saveSnapshot: typeof saveSnapshot;
-    parseWithCheerio: typeof parseWithCheerio;
-    closeCookieModals: typeof closeCookieModals;
-};

package/internals/utils/puppeteer_utils.js

@@ -5,7 +5,7 @@
  * **Example usage:**
  *
  * ```javascript
- * import { launchPuppeteer, utils } from 'crawlee';
+ * import { launchPuppeteer, puppeteerUtils } from 'crawlee';
  *
  * // Open https://www.example.com in Puppeteer
  * const browser = await launchPuppeteer();
@@ -13,15 +13,16 @@
  * await page.goto('https://www.example.com');
  *
  * // Inject jQuery into a page
- * await utils.puppeteer.injectJQuery(page);
+ * await puppeteerUtils.injectJQuery(page);
  * ```
  * @module puppeteerUtils
  */
 import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import vm from 'node:vm';
-import { Configuration, KeyValueStore, parseArgument, schemas, serviceLocator, validators } from '@crawlee/browser';
-import { expandShadowRoots, sleep } from '@crawlee/utils';
+import { Configuration, KeyValueStore, serviceLocator, validators } from '@crawlee/browser';
+import { sleep } from '@crawlee/utils';
+import { expandShadowRoots, parseArgument, schemas } from '@crawlee/utils/internal';
 import { z } from 'zod';
 import { LruCache } from '@apify/datastructures';
 import { enqueueLinksByClickingElements } from '../enqueue-links/click-elements.js';
@@ -34,7 +35,6 @@ const filePathSchema = z.string();
 const injectFileOptionsSchema = z.strictObject({
     surviveNavigations: z.boolean().optional(),
 });
-const responseUrlRulesSchema = schemas.arrayOf(z.union([z.string(), z.instanceof(RegExp)]), 'strings or RegExps');
 const gotoExtendedRequestSchema = z.looseObject({
     url: z.url(),
     method: z.string().optional(),
@@ -107,7 +107,7 @@ export async function injectFile(page, filePath, options = {}) {
  *
  * **Example usage:**
  * ```javascript
- * await utils.puppeteer.injectJQuery(page);
+ * await puppeteerUtils.injectJQuery(page);
  * const title = await page.evaluate(() => {
  *   return $('head title').text();
  * });
@@ -129,7 +129,7 @@ export async function injectJQuery(page, options) {
  *
  * **Example usage:**
  * ```javascript
- * const $ = await utils.puppeteer.parseWithCheerio(page);
+ * const $ = await puppeteerUtils.parseWithCheerio(page);
  * const title = $('title').text();
  * ```
  *
@@ -170,6 +170,7 @@ export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIf
         ? null
         : (await page.evaluate(`(${expandShadowRoots.toString()})(document)`));
     const pageContent = html || (await page.content());
+    // Full cheerio (parse5) import for browser compliant parser
     const { load } = await import('cheerio');
     return load(pageContent);
 }
@@ -199,13 +200,13 @@ export async function parseWithCheerio(page, ignoreShadowRoots = false, ignoreIf
  *
  * **Example usage**
  * ```javascript
- * import { launchPuppeteer, utils } from 'crawlee';
+ * import { launchPuppeteer, puppeteerUtils } from 'crawlee';
  *
  * const browser = await launchPuppeteer();
  * const page = await browser.newPage();
  *
  * // Block all requests to URLs that include `adsbygoogle.js` and also all defaults.
- * await utils.puppeteer.blockRequests(page, {
+ * await puppeteerUtils.blockRequests(page, {
  *     extraUrlPatterns: ['adsbygoogle.js'],
  * });
  *
@@ -225,7 +226,7 @@ export async function blockRequests(page, options = {}) {
 /**
  * @internal
  */
-export async function sendCDPCommand(page, command, ...args) {
+async function sendCDPCommand(page, command, ...args) {
     // In puppeteer 16.x and 17.x, the `_client` method is completely omitted from the types. It's still there and works the same way, but it is hidden.
     // Puppeteer <= 17
     if (Reflect.has(page, '_client')) {
@@ -239,83 +240,6 @@ export async function sendCDPCommand(page, command, ...args) {
     const parsed = JSON.parse(await readFile(jsonPath, 'utf-8'));
     throw new Error(`Cannot detect CDP client for Puppeteer ${parsed.version}. You should report this to Crawlee, mentioning the puppeteer version you are using.`);
 }
-/**
- * `blockResources()` has a high impact on performance in recent versions of Puppeteer.
- * Until this resolves, please use `utils.puppeteer.blockRequests()`.
- * @deprecated
- */
-export const blockResources = async (page, resourceTypes = ['stylesheet', 'font', 'image', 'media']) => {
-    serviceLocator
-        .getLogger()
-        .deprecated('utils.puppeteer.blockResources() has a high impact on performance in recent versions of Puppeteer. ' +
-        'Until this resolves, please use utils.puppeteer.blockRequests()');
-    await addInterceptRequestHandler(page, async (request) => {
-        const type = request.resourceType();
-        if (resourceTypes.includes(type))
-            await request.abort();
-        else
-            await request.continue();
-    });
-};
-/**
- * *NOTE:* In recent versions of Puppeteer using this function entirely disables browser cache which resolves in sub-optimal
- * performance. Until this resolves, we suggest just relying on the in-browser cache unless absolutely necessary.
- *
- * Enables caching of intercepted responses into a provided object. Automatically enables request interception in Puppeteer.
- * *IMPORTANT*: Caching responses stores them to memory, so too loose rules could cause memory leaks for longer running crawlers.
- *   This issue should be resolved or atleast mitigated in future iterations of this feature.
- * @param page
- *   Puppeteer [`Page`](https://pptr.dev/api/puppeteer.page) object.
- * @param cache
- *   Object in which responses are stored
- * @param responseUrlRules
- *   List of rules that are used to check if the response should be cached.
- *   String rules are compared as page.url().includes(rule) while RegExp rules are evaluated as rule.test(page.url()).
- * @deprecated
- */
-export async function cacheResponses(page, cache, responseUrlRules) {
-    parseArgument(page, validators.browserPage);
-    parseArgument(cache, schemas.anyObject);
-    parseArgument(responseUrlRules, responseUrlRulesSchema);
-    serviceLocator
-        .getLogger()
-        .deprecated('utils.puppeteer.cacheResponses() has a high impact on performance ' +
-        "in recent versions of Puppeteer so it's use is discouraged until this issue resolves.");
-    await addInterceptRequestHandler(page, async (request) => {
-        const url = request.url();
-        if (cache[url]) {
-            await request.respond(cache[url]);
-            return;
-        }
-        await request.continue();
-    });
-    page.on('response', async (response) => {
-        const url = response.url();
-        // Response is already cached, do nothing
-        if (cache[url])
-            return;
-        const shouldCache = responseUrlRules.some((rule) => {
-            if (typeof rule === 'string')
-                return url.includes(rule);
-            if (rule instanceof RegExp)
-                return rule.test(url);
-            return false;
-        });
-        try {
-            if (shouldCache) {
-                const buffer = await response.buffer();
-                cache[url] = {
-                    status: response.status(),
-                    headers: response.headers(),
-                    body: buffer,
-                };
-            }
-        }
-        catch {
-            // ignore errors, usually means that buffer is empty or broken connection
-        }
-    });
-}
 /**
  * Compiles a Puppeteer script into an async function that may be executed at any time
  * by providing it with the following object:
@@ -545,48 +469,4 @@ export async function saveSnapshot(page, options = {}) {
         throw new Error(`saveSnapshot with key ${key} failed.\nCause:${err.message}`);
     }
 }
-let idcacPlaywright = null;
-async function getIdcacPlaywright() {
-    if (idcacPlaywright)
-        return idcacPlaywright;
-    try {
-        idcacPlaywright = await import('idcac-playwright');
-    }
-    catch (error) {
-        getLog().warning(`Failed to import 'idcac-playwright'.
-
-We recently made idcac-playwright an optional dependency due to licensing issues.
-To use this feature, please install it manually by running
-
-npm install idcac-playwright
-
-Original error message follows:
-
-${error.message}
-`);
-    }
-    return idcacPlaywright;
-}
-export async function closeCookieModals(page) {
-    parseArgument(page, validators.browserPage);
-    const idcac = await getIdcacPlaywright();
-    if (idcac?.getInjectableScript()) {
-        await page.evaluate(idcac.getInjectableScript());
-    }
-}
 export { enqueueLinksByClickingElements, addInterceptRequestHandler, removeInterceptRequestHandler };
-/** @internal */
-export const puppeteerUtils = {
-    injectFile,
-    injectJQuery,
-    enqueueLinksByClickingElements,
-    blockRequests,
-    compileScript,
-    gotoExtended,
-    addInterceptRequestHandler,
-    removeInterceptRequestHandler,
-    infiniteScroll,
-    saveSnapshot,
-    parseWithCheerio,
-    closeCookieModals,
-};

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "@crawlee/puppeteer",
-    "version": "4.0.0-rc.0",
+    "version": "4.0.0-rc.1",
     "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"
+        "node": ">=22.13.0"
     },
     "type": "module",
     "exports": {
@@ -47,26 +47,22 @@
         "access": "public"
     },
     "dependencies": {
-        "@apify/datastructures": "^2.0.3",
-        "@crawlee/browser": "4.0.0-rc.0",
-        "@crawlee/browser-pool": "4.0.0-rc.0",
-        "@crawlee/core": "4.0.0-rc.0",
-        "@crawlee/types": "4.0.0-rc.0",
-        "@crawlee/utils": "4.0.0-rc.0",
+        "@apify/datastructures": "^3.0.1",
+        "@crawlee/browser": "4.0.0-rc.1",
+        "@crawlee/browser-pool": "4.0.0-rc.1",
+        "@crawlee/core": "4.0.0-rc.1",
+        "@crawlee/types": "4.0.0-rc.1",
+        "@crawlee/utils": "4.0.0-rc.1",
         "cheerio": "^1.0.0",
         "devtools-protocol": "*",
         "jquery": "^3.7.1",
         "tslib": "^2.8.1",
-        "zod": "^4.4.3"
+        "zod": "^4.5.4"
     },
     "peerDependencies": {
-        "idcac-playwright": "^0.2.0",
         "puppeteer": "*"
     },
     "peerDependenciesMeta": {
-        "idcac-playwright": {
-            "optional": true
-        },
         "puppeteer": {
             "optional": true
         }
@@ -78,5 +74,5 @@
             }
         }
     },
-    "gitHead": "79ab33dacdacb83e0197e6516d145f3aceef80c7"
+    "gitHead": "f354ca5e943bed1a5c657a1fce1974c053f9fff0"
 }