@crawlee/browser-pool 4.0.0-beta.98 → 4.0.0-rc.0

package/abstract-classes/browser-controller.d.ts

@@ -80,6 +80,7 @@ export interface BrowserControllerEvents<Library extends CommonLibrary, LibraryO
  * @hideconstructor
  */
 export declare abstract class BrowserController<Library extends CommonLibrary = CommonLibrary, LibraryOptions extends Dictionary | undefined = Parameters<Library['launch']>[0], LaunchResult extends CommonBrowser = UnwrapPromise<ReturnType<Library['launch']>>, NewPageOptions = Parameters<LaunchResult['newPage']>[0], NewPageResult = UnwrapPromise<ReturnType<LaunchResult['newPage']>>> extends TypedEmitter<BrowserControllerEvents<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>> implements IBrowserController<NewPageResult> {
+    #private;
     readonly id: string;
     protected readonly log: CrawleeLogger;
     /**
@@ -103,10 +104,7 @@ export declare abstract class BrowserController<Library extends CommonLibrary =
     activePages: number;
     totalPages: number;
     lastPageOpenedAt: number;
-    private _activate;
     private isActivePromise;
-    private commitBrowser;
-    private hasBrowserPromise;
     constructor(browserPlugin: BrowserPlugin<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>);
     /**
      * Activates the BrowserController. If you try to open new pages before

package/abstract-classes/browser-controller.js

@@ -2,6 +2,7 @@ import { serviceLocator } from '@crawlee/core';
 import { nanoid } from 'nanoid';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { tryCancel } from '@apify/timeout';
+import { BROWSER_CONTROLLER_EVENTS } from '../events.js';
 const PROCESS_KILL_TIMEOUT_MILLIS = 5000;
 /**
  * The `BrowserController` serves two purposes. First, it is the base class that
@@ -35,13 +36,14 @@ export class BrowserController extends TypedEmitter {
     activePages = 0;
     totalPages = 0;
     lastPageOpenedAt = Date.now();
-    _activate;
+    #activate;
+    // kept as TS-private: `BrowserPool` awaits it through cross-object bracket access
     isActivePromise = new Promise((resolve) => {
-        this._activate = resolve;
+        this.#activate = resolve;
     });
-    commitBrowser;
-    hasBrowserPromise = new Promise((resolve) => {
-        this.commitBrowser = resolve;
+    #commitBrowser;
+    #hasBrowserPromise = new Promise((resolve) => {
+        this.#commitBrowser = resolve;
     });
     constructor(browserPlugin) {
         super();
@@ -58,7 +60,7 @@ export class BrowserController extends TypedEmitter {
         if (!this.browser) {
             throw new Error('Cannot activate BrowserController without an assigned browser.');
         }
-        this._activate();
+        this.#activate();
         this.isActive = true;
     }
     /**
@@ -70,7 +72,7 @@ export class BrowserController extends TypedEmitter {
         }
         this.browser = browser;
         this.launchContext = launchContext;
-        this.commitBrowser();
+        this.#commitBrowser();
     }
     /**
      * Gracefully closes the browser and makes sure
@@ -79,7 +81,7 @@ export class BrowserController extends TypedEmitter {
      * Emits 'browserClosed' event.
      */
     async close() {
-        await this.hasBrowserPromise;
+        await this.#hasBrowserPromise;
         try {
             await this._close();
             // TODO: shouldn't this go in a finally instead?
@@ -88,7 +90,7 @@ export class BrowserController extends TypedEmitter {
         catch (error) {
             this.log.debug(`Could not close browser.\nCause: ${error.message}`, { id: this.id });
         }
-        this.emit("browserClosed" /* BROWSER_CONTROLLER_EVENTS.BROWSER_CLOSED */, this);
+        this.emit(BROWSER_CONTROLLER_EVENTS.BROWSER_CLOSED, this);
         const killTimer = setTimeout(() => {
             this._kill().catch((err) => {
                 this.log.debug(`Could not kill browser.\nCause: ${err.message}`, { id: this.id });
@@ -102,9 +104,9 @@ export class BrowserController extends TypedEmitter {
      * Emits 'browserClosed' event.
      */
     async kill() {
-        await this.hasBrowserPromise;
+        await this.#hasBrowserPromise;
         await this._kill();
-        this.emit("browserClosed" /* BROWSER_CONTROLLER_EVENTS.BROWSER_CLOSED */, this);
+        this.emit(BROWSER_CONTROLLER_EVENTS.BROWSER_CLOSED, this);
     }
     /**
      * Opens new browser page.

package/abstract-classes/browser-plugin.d.ts

@@ -28,11 +28,9 @@ export interface CommonLibrary {
     launch(opts?: Dictionary): Promise<CommonBrowser>;
     name?: () => string;
 }
-/** @internal */
 export interface CommonBrowser {
     newPage(...args: unknown[]): Promise<CommonPage>;
 }
-/** @internal */
 export interface CommonPage {
     close(...args: unknown[]): Promise<unknown>;
     url(): string | Promise<string>;
@@ -121,7 +119,7 @@ export declare abstract class BrowserPlugin<Library extends CommonLibrary = Comm
      * Subclasses implement only the `connect` callback — the resolve / token / release / error-wrap scaffolding
      * lives here so it stays identical across plugins.
      */
-    protected _connectToRemoteBrowser(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>, connect: (url: string) => Promise<LaunchResult>): Promise<LaunchResult>;
+    protected connectToRemoteBrowser(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>, connect: (url: string) => Promise<LaunchResult>): Promise<LaunchResult>;
     /**
      * Creates a `LaunchContext` with all the information needed
      * to launch a browser. Aside from library specific launch options,
@@ -134,13 +132,13 @@ export declare abstract class BrowserPlugin<Library extends CommonLibrary = Comm
      * Launches the browser using provided launch context.
      */
     launch(launchContext?: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>): Promise<LaunchResult>;
-    private _mergeArgsToHideWebdriver;
-    protected _throwAugmentedLaunchError(cause: unknown, executablePath: string | undefined, dockerImage: string, moduleInstallCommand: string): never;
+    private mergeArgsToHideWebdriver;
+    protected throwAugmentedLaunchError(cause: unknown, executablePath: string | undefined, dockerImage: string, moduleInstallCommand: string): never;
     /**
      * @private
      */
-    protected abstract _addProxyToLaunchOptions(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>): Promise<void>;
-    protected abstract _isChromiumBasedBrowser(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>): boolean;
+    protected abstract addProxyToLaunchOptions(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>): Promise<void>;
+    protected abstract isChromiumBasedBrowser(launchContext: LaunchContext<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>): boolean;
     /**
      * @private
      */

package/abstract-classes/browser-plugin.js

@@ -69,7 +69,7 @@ export class BrowserPlugin {
      * Subclasses implement only the `connect` callback — the resolve / token / release / error-wrap scaffolding
      * lives here so it stays identical across plugins.
      */
-    async _connectToRemoteBrowser(launchContext, connect) {
+    async connectToRemoteBrowser(launchContext, connect) {
         const connection = this.remoteConnection;
         let url;
         let token;
@@ -79,7 +79,7 @@ export class BrowserPlugin {
         catch (cause) {
             throw new BrowserLaunchError('Failed to resolve the remote browser endpoint.', { cause });
         }
-        launchContext._remoteToken = token;
+        launchContext.remoteToken = token;
         try {
             return await connect(url);
         }
@@ -117,11 +117,11 @@ export class BrowserPlugin {
         launchContext.launchOptions ??= {};
         const { proxyUrl, launchOptions } = launchContext;
         if (proxyUrl && !launchContext.isRemote) {
-            await this._addProxyToLaunchOptions(launchContext);
+            await this.addProxyToLaunchOptions(launchContext);
         }
-        if (!launchContext.isRemote && this._isChromiumBasedBrowser(launchContext)) {
+        if (!launchContext.isRemote && this.isChromiumBasedBrowser(launchContext)) {
             // This will set the args for chromium based browsers to hide the webdriver.
-            launchOptions.args = this._mergeArgsToHideWebdriver(launchOptions.args);
+            launchOptions.args = this.mergeArgsToHideWebdriver(launchOptions.args);
             // When User-Agent is not set, and we're using Chromium in headless mode,
             // it is better to use DEFAULT_USER_AGENT to reduce chance of detection,
             // as otherwise 'HeadlessChrome' is present in User-Agent string.
@@ -135,7 +135,7 @@ export class BrowserPlugin {
         }
         return this._launch(launchContext);
     }
-    _mergeArgsToHideWebdriver(originalArgs) {
+    mergeArgsToHideWebdriver(originalArgs) {
         if (!originalArgs?.length) {
             return ['--disable-blink-features=AutomationControlled'];
         }
@@ -148,7 +148,7 @@ export class BrowserPlugin {
         }
         return originalArgs;
     }
-    _throwAugmentedLaunchError(cause, executablePath, dockerImage, moduleInstallCommand) {
+    throwAugmentedLaunchError(cause, executablePath, dockerImage, moduleInstallCommand) {
         const errorMessage = ['Failed to launch browser. Please check the following:'];
         if (executablePath) {
             errorMessage.push(`- Check whether the provided executable path "${executablePath}" is correct.`);

package/browser-pool.d.ts

@@ -248,6 +248,7 @@ export interface BrowserPoolHooks<BC extends BrowserController, LC extends Launc
  * ```
  */
 export declare class BrowserPool<Options extends BrowserPoolOptions = BrowserPoolOptions, BrowserPlugins extends BrowserPlugin[] = InferBrowserPluginArray<Options['browserPlugins']>, BrowserControllerReturn extends BrowserController = ReturnType<BrowserPlugins[number]['createController']>, LaunchContextReturn extends LaunchContext = ReturnType<BrowserPlugins[number]['createLaunchContext']>, PageOptions = Parameters<BrowserControllerReturn['newPage']>[0], PageReturn extends UnwrapPromise<ReturnType<BrowserControllerReturn['newPage']>> = UnwrapPromise<ReturnType<BrowserControllerReturn['newPage']>>> extends TypedEmitter<BrowserPoolEvents<BrowserControllerReturn, PageReturn>> implements IBrowserPool<PageReturn> {
+    #private;
     browserPlugins: BrowserPlugins;
     maxOpenPagesPerBrowser: number;
     maxOpenBrowsers: number;
@@ -273,9 +274,6 @@ export declare class BrowserPool<Options extends BrowserPoolOptions = BrowserPoo
     fingerprintGenerator?: FingerprintGenerator;
     fingerprintCache?: QuickLRU<string, BrowserFingerprintWithHeaders>;
     private browserKillerInterval?;
-    private browserRetireInterval?;
-    private limiter;
-    private log;
     constructor(options: Options & BrowserPoolHooks<BrowserControllerReturn, LaunchContextReturn, PageReturn>);
     /**
      * Opens a new page in one of the running browsers or launches
@@ -350,7 +348,7 @@ export declare class BrowserPool<Options extends BrowserPoolOptions = BrowserPoo
      * until it's closed.
      */
     getPageId(page: PageReturn): string | undefined;
-    private _createPageForBrowser;
+    private createPageForBrowser;
     /**
      * Removes a browser controller from the pool. The underlying
      * browser will be closed after all its pages are closed.
@@ -413,19 +411,19 @@ export declare class BrowserPool<Options extends BrowserPoolOptions = BrowserPoo
      * Closes all managed browsers and tears down the pool.
      */
     destroy(): Promise<void>;
-    private _teardown;
-    private _getAllBrowserControllers;
-    private _launchBrowser;
+    private teardown;
+    private getAllBrowserControllers;
+    private launchBrowser;
     /**
      * Picks plugins round robin.
      * @private
      */
-    private _pickBrowserPlugin;
-    private _pickBrowserWithFreeCapacity;
-    private _closeInactiveRetiredBrowsers;
-    private _overridePageClose;
-    private _executeHooks;
-    private _closeRetiredBrowserWithNoPages;
+    private pickBrowserPlugin;
+    private pickBrowserWithFreeCapacity;
+    private closeInactiveRetiredBrowsers;
+    private overridePageClose;
+    private executeHooks;
+    private closeRetiredBrowserWithNoPages;
     /**
      * Returns `true` if the pool can accept a new browser launch without exceeding
      * {@link BrowserPoolOptions.maxOpenBrowsers}. Counts starting, active, and retired browsers.
@@ -435,8 +433,8 @@ export declare class BrowserPool<Options extends BrowserPoolOptions = BrowserPoo
      * Returns `true` if any active browser has room for another page.
      */
     hasActiveBrowserWithFreeCapacity(): boolean;
-    private _initializeFingerprinting;
-    private _addFingerprintHooks;
+    private initializeFingerprinting;
+    private addFingerprintHooks;
 }
 export interface BrowserPoolNewPageOptions<PageOptions, BP extends BrowserPlugin> extends NewPageOptions {
     /**

package/browser-pool.js

@@ -1,17 +1,34 @@
 import { AsyncResource } from 'node:async_hooks';
-import { SessionError, serviceLocator } from '@crawlee/core';
+import { parseArgument, schemas, SessionError, serviceLocator } from '@crawlee/core';
 import { FingerprintGenerator } from 'fingerprint-generator';
 import { FingerprintInjector } from 'fingerprint-injector';
 import { nanoid } from 'nanoid';
-import ow from 'ow';
 import pLimit from 'p-limit';
 import QuickLRU from 'quick-lru';
 import { TypedEmitter } from 'tiny-typed-emitter';
+import { z } from 'zod';
 import { addTimeoutToPromise, tryCancel } from '@apify/timeout';
+import { BROWSER_POOL_EVENTS } from './events.js';
 import { createFingerprintPreLaunchHook, createPostPageCreateHook, createPrePageCreateHook, } from './fingerprinting/hooks.js';
 const PAGE_CLOSE_TIMEOUT_MILLIS = 5000;
 const PAGE_CLOSE_KILL_TIMEOUT_MILLIS = 1000;
 const BROWSER_KILLER_INTERVAL_MILLIS = 10 * 1000;
+const browserPoolOptionsSchema = z.strictObject({
+    browserPlugins: schemas.anyArray.refine((value) => value.length >= 1, 'Expected a non-empty array'),
+    maxOpenPagesPerBrowser: schemas.anyNumber.default(20),
+    retireBrowserAfterPageCount: schemas.anyNumber.default(100),
+    operationTimeoutSecs: schemas.anyNumber.default(15),
+    closeInactiveBrowserAfterSecs: schemas.anyNumber.default(300),
+    retireInactiveBrowserAfterSecs: schemas.anyNumber.default(10),
+    preLaunchHooks: schemas.anyArray.default(() => []),
+    postLaunchHooks: schemas.anyArray.default(() => []),
+    prePageCreateHooks: schemas.anyArray.default(() => []),
+    postPageCreateHooks: schemas.anyArray.default(() => []),
+    prePageCloseHooks: schemas.anyArray.default(() => []),
+    postPageCloseHooks: schemas.anyArray.default(() => []),
+    useFingerprints: z.boolean().default(true),
+    fingerprintOptions: schemas.anyObject.default(() => ({})),
+});
 /**
  * The `BrowserPool` class is the most important class of the `browser-pool` module.
  * It manages opening and closing of browsers and their pages and its constructor
@@ -84,31 +101,16 @@ export class BrowserPool extends TypedEmitter {
     fingerprintInjector;
     fingerprintGenerator;
     fingerprintCache;
-    browserKillerInterval = setInterval(async () => this._closeInactiveRetiredBrowsers(), BROWSER_KILLER_INTERVAL_MILLIS);
-    browserRetireInterval;
-    limiter = pLimit(1);
-    log;
+    // kept as TS-private: tests replace this interval through bracket access
+    browserKillerInterval = setInterval(async () => this.closeInactiveRetiredBrowsers(), BROWSER_KILLER_INTERVAL_MILLIS);
+    #browserRetireInterval;
+    #limiter = pLimit(1);
+    #log;
     constructor(options) {
         super();
-        this.log = serviceLocator.getLogger().child({ prefix: 'BrowserPool' });
+        this.#log = serviceLocator.getLogger().child({ prefix: 'BrowserPool' });
         this.browserKillerInterval.unref();
-        ow(options, ow.object.exactShape({
-            browserPlugins: ow.array.minLength(1),
-            maxOpenPagesPerBrowser: ow.optional.number,
-            retireBrowserAfterPageCount: ow.optional.number,
-            operationTimeoutSecs: ow.optional.number,
-            closeInactiveBrowserAfterSecs: ow.optional.number,
-            retireInactiveBrowserAfterSecs: ow.optional.number,
-            preLaunchHooks: ow.optional.array,
-            postLaunchHooks: ow.optional.array,
-            prePageCreateHooks: ow.optional.array,
-            postPageCreateHooks: ow.optional.array,
-            prePageCloseHooks: ow.optional.array,
-            postPageCloseHooks: ow.optional.array,
-            useFingerprints: ow.optional.boolean,
-            fingerprintOptions: ow.optional.object,
-        }));
-        const { browserPlugins, maxOpenPagesPerBrowser = 20, retireBrowserAfterPageCount = 100, operationTimeoutSecs = 15, closeInactiveBrowserAfterSecs = 300, retireInactiveBrowserAfterSecs = 10, preLaunchHooks = [], postLaunchHooks = [], prePageCreateHooks = [], postPageCreateHooks = [], prePageCloseHooks = [], postPageCloseHooks = [], useFingerprints = true, fingerprintOptions = {}, } = options;
+        const { browserPlugins, maxOpenPagesPerBrowser, retireBrowserAfterPageCount, operationTimeoutSecs, closeInactiveBrowserAfterSecs, retireInactiveBrowserAfterSecs, preLaunchHooks, postLaunchHooks, prePageCreateHooks, postPageCreateHooks, prePageCloseHooks, postPageCloseHooks, useFingerprints, fingerprintOptions, } = parseArgument(options, browserPoolOptionsSchema);
         const firstPluginConstructor = browserPlugins[0].constructor;
         for (let i = 1; i < browserPlugins.length; i++) {
             const providedPlugin = browserPlugins[i];
@@ -126,13 +128,13 @@ export class BrowserPool extends TypedEmitter {
         this.closeInactiveBrowserAfterMillis = closeInactiveBrowserAfterSecs * 1000;
         this.useFingerprints = useFingerprints;
         this.fingerprintOptions = fingerprintOptions;
-        this.browserRetireInterval = setInterval(async () => this.activeBrowserControllers.forEach((controller) => {
+        this.#browserRetireInterval = setInterval(async () => this.activeBrowserControllers.forEach((controller) => {
             if (controller.activePages === 0 &&
                 controller.lastPageOpenedAt < Date.now() - retireInactiveBrowserAfterSecs * 1000) {
                 this.retireBrowserController(controller);
             }
         }), retireInactiveBrowserAfterSecs * 1000);
-        this.browserRetireInterval.unref();
+        this.#browserRetireInterval.unref();
         // hooks
         this.preLaunchHooks = preLaunchHooks;
         this.postLaunchHooks = postLaunchHooks;
@@ -142,7 +144,7 @@ export class BrowserPool extends TypedEmitter {
         this.postPageCloseHooks = postPageCloseHooks;
         // fingerprinting
         if (this.useFingerprints) {
-            this._initializeFingerprinting();
+            this.initializeFingerprinting();
         }
     }
     /**
@@ -163,7 +165,7 @@ export class BrowserPool extends TypedEmitter {
      * crawler's responsibility.
      */
     async newPage(options = {}) {
-        const { id = nanoid(), pageOptions, browserPlugin = this._pickBrowserPlugin(), session, proxyUrl = session?.proxyInfo?.url, ignoreTlsErrors = session?.proxyInfo?.ignoreTlsErrors, } = options;
+        const { id = nanoid(), pageOptions, browserPlugin = this.pickBrowserPlugin(), session, proxyUrl = session?.proxyInfo?.url, ignoreTlsErrors = session?.proxyInfo?.ignoreTlsErrors, } = options;
         if (this.pages.has(id)) {
             throw new Error(`Page with ID: ${id} already exists.`);
         }
@@ -176,18 +178,21 @@ export class BrowserPool extends TypedEmitter {
         // requests (https://github.com/apify/crawlee/issues/3670). Mirrors the
         // fix p-limit landed upstream in v5 (sindresorhus/p-limit#71); v5 is an
         // ESM-only rewrite, so we can't bump it in Crawlee v3.
+        // Besides the cancelTask leak, the wrapper also keeps the per-request *storage transaction*
+        // ALS-scoped: without it, a queued callback would resume in the previous request's async
+        // context and run request B's storage writes inside request A's transaction.
         // TODO(crawlee@v4): bump p-limit to v5 and drop this AsyncResource.bind wrapper.
         // Limiter is necessary - https://github.com/apify/crawlee/issues/1126
-        return this.limiter(AsyncResource.bind(async () => {
-            let browserController = this._pickBrowserWithFreeCapacity(browserPlugin, { proxyUrl });
+        return this.#limiter(AsyncResource.bind(async () => {
+            let browserController = this.pickBrowserWithFreeCapacity(browserPlugin, { proxyUrl });
             if (!browserController)
-                browserController = await this._launchBrowser(id, {
+                browserController = await this.launchBrowser(id, {
                     browserPlugin,
                     proxyUrl,
                     ignoreTlsErrors,
                 });
             tryCancel();
-            return await this._createPageForBrowser(id, browserController, pageOptions, proxyUrl, ignoreTlsErrors);
+            return await this.createPageForBrowser(id, browserController, pageOptions, proxyUrl, ignoreTlsErrors);
         }));
     }
     /**
@@ -196,13 +201,13 @@ export class BrowserPool extends TypedEmitter {
      * configure the new browser.
      */
     async newPageInNewBrowser(options = {}) {
-        const { id = nanoid(), pageOptions, launchOptions, browserPlugin = this._pickBrowserPlugin() } = options;
+        const { id = nanoid(), pageOptions, launchOptions, browserPlugin = this.pickBrowserPlugin() } = options;
         if (this.pages.has(id)) {
             throw new Error(`Page with ID: ${id} already exists.`);
         }
-        const browserController = await this._launchBrowser(id, { launchOptions, browserPlugin });
+        const browserController = await this.launchBrowser(id, { launchOptions, browserPlugin });
         tryCancel();
-        return await this._createPageForBrowser(id, browserController, pageOptions);
+        return await this.createPageForBrowser(id, browserController, pageOptions);
     }
     /**
      * Opens new pages with all available plugins and returns an array
@@ -268,7 +273,7 @@ export class BrowserPool extends TypedEmitter {
     getPageId(page) {
         return this.pageIds.get(page);
     }
-    async _createPageForBrowser(pageId, browserController, pageOptions = {}, proxyUrl, ignoreTlsErrors) {
+    async createPageForBrowser(pageId, browserController, pageOptions = {}, proxyUrl, ignoreTlsErrors) {
         // This is needed for concurrent newPage calls to wait for the browser launch.
         // It's not ideal though, we need to come up with a better API.
         // eslint-disable-next-line dot-notation -- accessing private property
@@ -284,7 +289,7 @@ export class BrowserPool extends TypedEmitter {
                 });
             }
         }
-        await this._executeHooks(this.prePageCreateHooks, pageId, browserController, finalPageOptions);
+        await this.executeHooks(this.prePageCreateHooks, pageId, browserController, finalPageOptions);
         tryCancel();
         let page;
         try {
@@ -297,15 +302,15 @@ export class BrowserPool extends TypedEmitter {
             if (browserController.totalPages >= this.retireBrowserAfterPageCount) {
                 this.retireBrowserController(browserController);
             }
-            this._overridePageClose(page);
+            this.overridePageClose(page);
         }
         catch (err) {
             this.retireBrowserController(browserController);
             throw new Error(`browserController.newPage() failed: ${browserController.id}\nCause:${err.message}.`);
         }
-        await this._executeHooks(this.postPageCreateHooks, page, browserController);
+        await this.executeHooks(this.postPageCreateHooks, page, browserController);
         tryCancel();
-        this.emit("pageCreated" /* BROWSER_POOL_EVENTS.PAGE_CREATED */, page);
+        this.emit(BROWSER_POOL_EVENTS.PAGE_CREATED, page);
         return page;
     }
     /**
@@ -320,7 +325,7 @@ export class BrowserPool extends TypedEmitter {
         if (hasBeenRetiredOrKilled)
             return;
         this.retiredBrowserControllers.add(browserController);
-        this.emit("browserRetired" /* BROWSER_POOL_EVENTS.BROWSER_RETIRED */, browserController);
+        this.emit(BROWSER_POOL_EVENTS.BROWSER_RETIRED, browserController);
         this.startingBrowserControllers.delete(browserController);
         this.activeBrowserControllers.delete(browserController);
     }
@@ -400,7 +405,7 @@ export class BrowserPool extends TypedEmitter {
      * @return {Promise<void>}
      */
     async closeAllBrowsers() {
-        const controllers = this._getAllBrowserControllers();
+        const controllers = this.getAllBrowserControllers();
         const promises = [...controllers]
             .filter((controller) => controller.isActive)
             .map(async (controller) => controller.close());
@@ -411,26 +416,26 @@ export class BrowserPool extends TypedEmitter {
      */
     async destroy() {
         clearInterval(this.browserKillerInterval);
-        clearInterval(this.browserRetireInterval);
+        clearInterval(this.#browserRetireInterval);
         this.browserKillerInterval = undefined;
-        this.browserRetireInterval = undefined;
+        this.#browserRetireInterval = undefined;
         await this.closeAllBrowsers();
-        this._teardown();
+        this.teardown();
     }
-    _teardown() {
+    teardown() {
         this.startingBrowserControllers.clear();
         this.activeBrowserControllers.clear();
         this.retiredBrowserControllers.clear();
         this.removeAllListeners();
     }
-    _getAllBrowserControllers() {
+    getAllBrowserControllers() {
         return new Set([
             ...this.startingBrowserControllers,
             ...this.activeBrowserControllers,
             ...this.retiredBrowserControllers,
         ]);
     }
-    async _launchBrowser(pageId, options) {
+    async launchBrowser(pageId, options) {
         const { browserPlugin, launchOptions, proxyUrl, ignoreTlsErrors } = options;
         const browserController = browserPlugin.createController();
         this.startingBrowserControllers.add(browserController);
@@ -451,7 +456,7 @@ export class BrowserPool extends TypedEmitter {
         try {
             // If the hooks or the launch fails, we need to delete the controller,
             // because otherwise it would be stuck in limbo without a browser.
-            await this._executeHooks(this.preLaunchHooks, pageId, launchContext);
+            await this.executeHooks(this.preLaunchHooks, pageId, launchContext);
             tryCancel();
             const browser = await browserPlugin.launch(launchContext);
             tryCancel();
@@ -461,17 +466,17 @@ export class BrowserPool extends TypedEmitter {
             this.startingBrowserControllers.delete(browserController);
             throw err;
         }
-        this.log.debug('Launched new browser.', { id: browserController.id });
+        this.#log.debug('Launched new browser.', { id: browserController.id });
         browserController.proxyUrl = proxyUrl;
         try {
             // If the launch fails on the post-launch hooks, we need to clean up
             // both the controller and the browser before throwing.
-            await this._executeHooks(this.postLaunchHooks, pageId, browserController);
+            await this.executeHooks(this.postLaunchHooks, pageId, browserController);
         }
         catch (err) {
             this.startingBrowserControllers.delete(browserController);
             browserController.close().catch((closeErr) => {
-                this.log.error(`Could not close browser whose post-launch hooks failed.\nCause:${closeErr.message}`, {
+                this.#log.error(`Could not close browser whose post-launch hooks failed.\nCause:${closeErr.message}`, {
                     id: browserController.id,
                 });
             });
@@ -481,19 +486,19 @@ export class BrowserPool extends TypedEmitter {
         browserController.activate();
         this.startingBrowserControllers.delete(browserController);
         this.activeBrowserControllers.add(browserController);
-        this.emit("browserLaunched" /* BROWSER_POOL_EVENTS.BROWSER_LAUNCHED */, browserController);
+        this.emit(BROWSER_POOL_EVENTS.BROWSER_LAUNCHED, browserController);
         return browserController;
     }
     /**
      * Picks plugins round robin.
      * @private
      */
-    _pickBrowserPlugin() {
+    pickBrowserPlugin() {
         const pluginIndex = this.pageCounter % this.browserPlugins.length;
         this.pageCounter++;
         return this.browserPlugins[pluginIndex];
     }
-    _pickBrowserWithFreeCapacity(browserPlugin, options) {
+    pickBrowserWithFreeCapacity(browserPlugin, options) {
         return [...this.activeBrowserControllers].find((controller) => {
             const hasCapacity = controller.activePages < this.maxOpenPagesPerBrowser;
             const isCorrectPlugin = controller.browserPlugin === browserPlugin;
@@ -505,7 +510,7 @@ export class BrowserPool extends TypedEmitter {
                     (!options?.proxyUrl && !controller.proxyUrl)));
         });
     }
-    async _closeInactiveRetiredBrowsers() {
+    async closeInactiveRetiredBrowsers() {
         const closedBrowserIds = [];
         for (const controller of this.retiredBrowserControllers) {
             const millisSinceLastPageOpened = Date.now() - controller.lastPageOpenedAt;
@@ -513,45 +518,45 @@ export class BrowserPool extends TypedEmitter {
             const isBrowserEmpty = controller.activePages === 0;
             if (isBrowserIdle || isBrowserEmpty) {
                 const { id } = controller;
-                this.log.debug('Closing retired browser.', { id });
+                this.#log.debug('Closing retired browser.', { id });
                 await controller.close();
                 this.retiredBrowserControllers.delete(controller);
                 closedBrowserIds.push(id);
             }
         }
         if (closedBrowserIds.length) {
-            this.log.debug('Closed retired browsers.', {
+            this.#log.debug('Closed retired browsers.', {
                 count: closedBrowserIds.length,
                 closedBrowserIds,
             });
         }
     }
-    _overridePageClose(page) {
+    overridePageClose(page) {
         const originalPageClose = page.close;
         const browserController = this.pageToBrowserController.get(page);
         const pageId = this.getPageId(page);
         page.close = async (...args) => {
-            await this._executeHooks(this.prePageCloseHooks, page, browserController);
+            await this.executeHooks(this.prePageCloseHooks, page, browserController);
             await originalPageClose.apply(page, args).catch((err) => {
-                this.log.debug(`Could not close page.\nCause:${err.message}`, { id: browserController.id });
+                this.#log.debug(`Could not close page.\nCause:${err.message}`, { id: browserController.id });
             });
-            await this._executeHooks(this.postPageCloseHooks, pageId, browserController);
+            await this.executeHooks(this.postPageCloseHooks, pageId, browserController);
             this.pages.delete(pageId);
-            this._closeRetiredBrowserWithNoPages(browserController);
-            this.emit("pageClosed" /* BROWSER_POOL_EVENTS.PAGE_CLOSED */, page);
+            this.closeRetiredBrowserWithNoPages(browserController);
+            this.emit(BROWSER_POOL_EVENTS.PAGE_CLOSED, page);
         };
     }
-    async _executeHooks(hooks, ...args) {
+    async executeHooks(hooks, ...args) {
         for (const hook of hooks) {
             await hook(...args);
         }
     }
-    _closeRetiredBrowserWithNoPages(browserController) {
+    closeRetiredBrowserWithNoPages(browserController) {
         if (browserController.activePages === 0 && this.retiredBrowserControllers.has(browserController)) {
             // Run this with a delay, otherwise page.close()
             // might fail with "Protocol error (Target.closeTarget): Target closed."
             setTimeout(() => {
-                this.log.debug('Closing retired browser because it has no active pages', { id: browserController.id });
+                this.#log.debug('Closing retired browser because it has no active pages', { id: browserController.id });
                 void browserController.close().finally(() => {
                     this.retiredBrowserControllers.delete(browserController);
                 });
@@ -578,16 +583,16 @@ export class BrowserPool extends TypedEmitter {
         }
         return false;
     }
-    _initializeFingerprinting() {
+    initializeFingerprinting() {
         const { useFingerprintCache = true, fingerprintCacheSize = 10_000 } = this.fingerprintOptions;
         this.fingerprintGenerator = new FingerprintGenerator(this.fingerprintOptions.fingerprintGeneratorOptions);
         this.fingerprintInjector = new FingerprintInjector();
         if (useFingerprintCache) {
             this.fingerprintCache = new QuickLRU({ maxSize: fingerprintCacheSize });
         }
-        this._addFingerprintHooks();
+        this.addFingerprintHooks();
     }
-    _addFingerprintHooks() {
+    addFingerprintHooks() {
         this.preLaunchHooks = [
             ...this.preLaunchHooks,
             // This is flipped because of the fingerprint cache.

package/events.d.ts

@@ -1,10 +1,10 @@
-export declare const enum BROWSER_POOL_EVENTS {
+export declare enum BROWSER_POOL_EVENTS {
     BROWSER_LAUNCHED = "browserLaunched",
     BROWSER_RETIRED = "browserRetired",
     BROWSER_CLOSED = "browserClosed",
     PAGE_CREATED = "pageCreated",
     PAGE_CLOSED = "pageClosed"
 }
-export declare const enum BROWSER_CONTROLLER_EVENTS {
+export declare enum BROWSER_CONTROLLER_EVENTS {
     BROWSER_CLOSED = "browserClosed"
 }

package/fingerprinting/hooks.js

@@ -35,7 +35,8 @@ export function createFingerprintPreLaunchHook(browserPool) {
             if (cacheKey)
                 fingerprintCache?.set(cacheKey, fingerprint);
         }
-        launchContext.extend({ fingerprint });
+        // `fingerprint` is a declared field, so it cannot go through `extend()` (which rejects reserved names)
+        launchContext.fingerprint = fingerprint;
         if (useIncognitoPages) {
             return;
         }