@crawlee/browser-pool 4.0.0-rc.0 → 4.0.0-rc.1

package/browser-pool.js

@@ -1,5 +1,6 @@
 import { AsyncResource } from 'node:async_hooks';
-import { parseArgument, schemas, SessionError, serviceLocator } from '@crawlee/core';
+import { SessionError, serviceLocator } from '@crawlee/core';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
 import { FingerprintGenerator } from 'fingerprint-generator';
 import { FingerprintInjector } from 'fingerprint-injector';
 import { nanoid } from 'nanoid';
@@ -78,38 +79,43 @@ const browserPoolOptionsSchema = z.strictObject({
  */
 export class BrowserPool extends TypedEmitter {
     browserPlugins;
-    maxOpenPagesPerBrowser;
+    /** @internal */
     maxOpenBrowsers;
-    retireBrowserAfterPageCount;
-    operationTimeoutMillis;
-    closeInactiveBrowserAfterMillis;
-    useFingerprints;
+    /** @internal */
     fingerprintOptions;
-    preLaunchHooks;
-    postLaunchHooks;
-    prePageCreateHooks;
-    postPageCreateHooks;
-    prePageCloseHooks;
-    postPageCloseHooks;
-    pageCounter = 0;
-    pages = new Map();
-    pageIds = new WeakMap();
-    startingBrowserControllers = new Set();
-    activeBrowserControllers = new Set();
-    retiredBrowserControllers = new Set();
-    pageToBrowserController = new WeakMap();
+    /** @internal */
     fingerprintInjector;
     fingerprintGenerator;
+    /** @internal */
     fingerprintCache;
-    // kept as TS-private: tests replace this interval through bracket access
-    browserKillerInterval = setInterval(async () => this.closeInactiveRetiredBrowsers(), BROWSER_KILLER_INTERVAL_MILLIS);
+    #maxOpenPagesPerBrowser;
+    #retireBrowserAfterPageCount;
+    #operationTimeoutMillis;
+    #closeInactiveBrowserAfterMillis;
+    #preLaunchHooks;
+    #postLaunchHooks;
+    #prePageCreateHooks;
+    #postPageCreateHooks;
+    #prePageCloseHooks;
+    #postPageCloseHooks;
+    #pageCounter = 0;
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- tests observe page tracking and controller retirement directly
+    pages = new Map();
+    #pageIds = new WeakMap();
+    #startingBrowserControllers = new Set();
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- accessed by tests
+    activeBrowserControllers = new Set();
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- accessed by tests
+    retiredBrowserControllers = new Set();
+    #pageToBrowserController = new WeakMap();
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- tests replace this interval through bracket access
+    browserKillerInterval;
     #browserRetireInterval;
     #limiter = pLimit(1);
     #log;
     constructor(options) {
         super();
         this.#log = serviceLocator.getLogger().child({ prefix: 'BrowserPool' });
-        this.browserKillerInterval.unref();
         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++) {
@@ -121,13 +127,16 @@ export class BrowserPool extends TypedEmitter {
             }
         }
         this.browserPlugins = browserPlugins;
-        this.maxOpenPagesPerBrowser = maxOpenPagesPerBrowser;
         this.maxOpenBrowsers = Infinity;
-        this.retireBrowserAfterPageCount = retireBrowserAfterPageCount;
-        this.operationTimeoutMillis = operationTimeoutSecs * 1000;
-        this.closeInactiveBrowserAfterMillis = closeInactiveBrowserAfterSecs * 1000;
-        this.useFingerprints = useFingerprints;
         this.fingerprintOptions = fingerprintOptions;
+        this.#maxOpenPagesPerBrowser = maxOpenPagesPerBrowser;
+        this.#retireBrowserAfterPageCount = retireBrowserAfterPageCount;
+        this.#operationTimeoutMillis = operationTimeoutSecs * 1000;
+        this.#closeInactiveBrowserAfterMillis = closeInactiveBrowserAfterSecs * 1000;
+        // Sweeping slower than the window it enforces would round any sub-10s
+        // `closeInactiveBrowserAfterSecs` up to the sweep period.
+        this.browserKillerInterval = setInterval(async () => this.closeInactiveRetiredBrowsers(), Math.min(BROWSER_KILLER_INTERVAL_MILLIS, this.#closeInactiveBrowserAfterMillis));
+        this.browserKillerInterval.unref();
         this.#browserRetireInterval = setInterval(async () => this.activeBrowserControllers.forEach((controller) => {
             if (controller.activePages === 0 &&
                 controller.lastPageOpenedAt < Date.now() - retireInactiveBrowserAfterSecs * 1000) {
@@ -136,15 +145,23 @@ export class BrowserPool extends TypedEmitter {
         }), retireInactiveBrowserAfterSecs * 1000);
         this.#browserRetireInterval.unref();
         // hooks
-        this.preLaunchHooks = preLaunchHooks;
-        this.postLaunchHooks = postLaunchHooks;
-        this.prePageCreateHooks = prePageCreateHooks;
-        this.postPageCreateHooks = postPageCreateHooks;
-        this.prePageCloseHooks = prePageCloseHooks;
-        this.postPageCloseHooks = postPageCloseHooks;
+        this.#preLaunchHooks = preLaunchHooks;
+        this.#postLaunchHooks = postLaunchHooks;
+        this.#prePageCreateHooks = prePageCreateHooks;
+        this.#postPageCreateHooks = postPageCreateHooks;
+        this.#prePageCloseHooks = prePageCloseHooks;
+        this.#postPageCloseHooks = postPageCloseHooks;
         // fingerprinting
-        if (this.useFingerprints) {
-            this.initializeFingerprinting();
+        if (useFingerprints) {
+            this.#initializeFingerprinting();
+            // The fingerprint pre-launch hook goes last because of the fingerprint cache.
+            // It is usual to generate proxy per browser and we want to know the proxyUrl for the caching.
+            this.#preLaunchHooks = [...this.#preLaunchHooks, createFingerprintPreLaunchHook(this)];
+            this.#prePageCreateHooks = [createPrePageCreateHook(), ...this.#prePageCreateHooks];
+            this.#postPageCreateHooks = [
+                createPostPageCreateHook(this.fingerprintInjector),
+                ...this.#postPageCreateHooks,
+            ];
         }
     }
     /**
@@ -165,7 +182,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.`);
         }
@@ -184,15 +201,15 @@ export class BrowserPool extends TypedEmitter {
         // 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 });
+            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);
         }));
     }
     /**
@@ -201,13 +218,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
@@ -253,7 +270,7 @@ export class BrowserPool extends TypedEmitter {
      * @param page - Browser plugin page
      */
     getBrowserControllerByPage(page) {
-        return this.pageToBrowserController.get(page);
+        return this.#pageToBrowserController.get(page);
     }
     /**
      * If you provided a custom ID to one of your pages or saved the
@@ -271,13 +288,12 @@ export class BrowserPool extends TypedEmitter {
      * until it's closed.
      */
     getPageId(page) {
-        return this.pageIds.get(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
-        await browserController['isActivePromise'];
+        await browserController.waitForActive();
         tryCancel();
         const finalPageOptions = browserController.launchContext.useIncognitoPages ? pageOptions : undefined;
         if (finalPageOptions) {
@@ -289,26 +305,26 @@ 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 {
-            page = (await addTimeoutToPromise(async () => browserController.newPage(finalPageOptions), this.operationTimeoutMillis, 'browserController.newPage() timed out.'));
+            page = (await addTimeoutToPromise(async () => browserController.newPage(finalPageOptions), this.#operationTimeoutMillis, 'browserController.newPage() timed out.'));
             tryCancel();
             this.pages.set(pageId, page);
-            this.pageIds.set(page, pageId);
-            this.pageToBrowserController.set(page, browserController);
+            this.#pageIds.set(page, pageId);
+            this.#pageToBrowserController.set(page, browserController);
             // if you synchronously trigger a lot of page launches, browser will not get retired soon enough. Not sure if it's a problem, let's monitor it.
-            if (browserController.totalPages >= this.retireBrowserAfterPageCount) {
+            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(BROWSER_POOL_EVENTS.PAGE_CREATED, page);
         return page;
@@ -319,14 +335,14 @@ export class BrowserPool extends TypedEmitter {
      *
      */
     retireBrowserController(browserController) {
-        const isStarting = this.startingBrowserControllers.has(browserController);
+        const isStarting = this.#startingBrowserControllers.has(browserController);
         const isActive = this.activeBrowserControllers.has(browserController);
         const hasBeenRetiredOrKilled = !isStarting && !isActive;
         if (hasBeenRetiredOrKilled)
             return;
         this.retiredBrowserControllers.add(browserController);
         this.emit(BROWSER_POOL_EVENTS.BROWSER_RETIRED, browserController);
-        this.startingBrowserControllers.delete(browserController);
+        this.#startingBrowserControllers.delete(browserController);
         this.activeBrowserControllers.delete(browserController);
     }
     /**
@@ -340,8 +356,9 @@ export class BrowserPool extends TypedEmitter {
     }
     /**
      * Releases a page back to the pool. The page is closed and, if the
-     * optional `error` is a {@link SessionError}, the browser controller
-     * that served the page is retired so that its tainted state (cookies,
+     * optional `error` is a {@link SessionError} (including
+     * {@link SessionRetiredError}), the browser controller that served
+     * the page is retired so that the finished session's state (cookies,
      * storage, etc.) cannot leak into future sessions.
      *
      * This is the primary way the crawler should return pages to the pool.
@@ -353,8 +370,10 @@ export class BrowserPool extends TypedEmitter {
         if (options?.error instanceof SessionError) {
             this.retireBrowserByPage(page);
         }
-        // Puppeteer 25+ can hang `page.close()` indefinitely when the page's navigation was aborted, don't let it block the crawler.
-        await addTimeoutToPromise(async () => page.close(), PAGE_CLOSE_TIMEOUT_MILLIS, `page.close() timed out after ${PAGE_CLOSE_TIMEOUT_MILLIS / 1000} seconds`);
+        // The bound on this lives in `overridePageClose`, where it covers the pool's own
+        // bookkeeping as well. Wrapping it here instead would time out the override and abandon
+        // that bookkeeping, leaving the browser holding a slot it can never get back.
+        await page.close();
     }
     /**
      * Extracts the relevant state (currently just cookies) from a page via its
@@ -396,7 +415,7 @@ export class BrowserPool extends TypedEmitter {
      * closed after all their pages are closed.
      */
     retireAllBrowsers() {
-        [...this.startingBrowserControllers, ...this.activeBrowserControllers].forEach((controller) => {
+        [...this.#startingBrowserControllers, ...this.activeBrowserControllers].forEach((controller) => {
             this.retireBrowserController(controller);
         });
     }
@@ -405,40 +424,48 @@ 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());
         await Promise.all(promises);
     }
+    async [Symbol.asyncDispose]() {
+        await this.destroy();
+    }
+    /**
+     * Closes every managed browser and empties the pool, which stays usable afterwards — a crawler releases its
+     * browsers when a run ends and may start another run on the same pool.
+     */
+    async releaseAllBrowsers() {
+        await this.closeAllBrowsers();
+        this.#startingBrowserControllers.clear();
+        this.activeBrowserControllers.clear();
+        this.retiredBrowserControllers.clear();
+    }
     /**
-     * Closes all managed browsers and tears down the pool.
+     * Closes all managed browsers and tears the pool down for good: its intervals are cleared without being
+     * re-armed and its listeners are dropped, so it cannot be used again.
      */
     async destroy() {
         clearInterval(this.browserKillerInterval);
         clearInterval(this.#browserRetireInterval);
         this.browserKillerInterval = undefined;
         this.#browserRetireInterval = undefined;
-        await this.closeAllBrowsers();
-        this.teardown();
-    }
-    teardown() {
-        this.startingBrowserControllers.clear();
-        this.activeBrowserControllers.clear();
-        this.retiredBrowserControllers.clear();
+        await this.releaseAllBrowsers();
         this.removeAllListeners();
     }
-    getAllBrowserControllers() {
+    #getAllBrowserControllers() {
         return new Set([
-            ...this.startingBrowserControllers,
+            ...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);
+        this.#startingBrowserControllers.add(browserController);
         const launchContext = browserPlugin.createLaunchContext({
             id: pageId,
             launchOptions,
@@ -456,14 +483,14 @@ 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();
             browserController.assignBrowser(browser, launchContext);
         }
         catch (err) {
-            this.startingBrowserControllers.delete(browserController);
+            this.#startingBrowserControllers.delete(browserController);
             throw err;
         }
         this.#log.debug('Launched new browser.', { id: browserController.id });
@@ -471,10 +498,10 @@ export class BrowserPool extends TypedEmitter {
         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);
+            this.#startingBrowserControllers.delete(browserController);
             browserController.close().catch((closeErr) => {
                 this.#log.error(`Could not close browser whose post-launch hooks failed.\nCause:${closeErr.message}`, {
                     id: browserController.id,
@@ -484,23 +511,22 @@ export class BrowserPool extends TypedEmitter {
         }
         tryCancel();
         browserController.activate();
-        this.startingBrowserControllers.delete(browserController);
+        this.#startingBrowserControllers.delete(browserController);
         this.activeBrowserControllers.add(browserController);
         this.emit(BROWSER_POOL_EVENTS.BROWSER_LAUNCHED, browserController);
         return browserController;
     }
     /**
      * Picks plugins round robin.
-     * @private
      */
-    pickBrowserPlugin() {
-        const pluginIndex = this.pageCounter % this.browserPlugins.length;
-        this.pageCounter++;
+    #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 hasCapacity = controller.activePages < this.#maxOpenPagesPerBrowser;
             const isCorrectPlugin = controller.browserPlugin === browserPlugin;
             const isSameProxyUrl = controller.proxyUrl === options?.proxyUrl;
             return (isCorrectPlugin &&
@@ -510,11 +536,12 @@ export class BrowserPool extends TypedEmitter {
                     (!options?.proxyUrl && !controller.proxyUrl)));
         });
     }
+    // oxlint-disable-next-line crawlee/prefer-private-fields -- accessed by tests
     async closeInactiveRetiredBrowsers() {
         const closedBrowserIds = [];
         for (const controller of this.retiredBrowserControllers) {
             const millisSinceLastPageOpened = Date.now() - controller.lastPageOpenedAt;
-            const isBrowserIdle = millisSinceLastPageOpened >= this.closeInactiveBrowserAfterMillis;
+            const isBrowserIdle = millisSinceLastPageOpened >= this.#closeInactiveBrowserAfterMillis;
             const isBrowserEmpty = controller.activePages === 0;
             if (isBrowserIdle || isBrowserEmpty) {
                 const { id } = controller;
@@ -531,27 +558,61 @@ export class BrowserPool extends TypedEmitter {
             });
         }
     }
-    overridePageClose(page) {
+    #overridePageClose(page) {
         const originalPageClose = page.close;
-        const browserController = this.pageToBrowserController.get(page);
+        const browserController = this.#pageToBrowserController.get(page);
         const pageId = this.getPageId(page);
         page.close = async (...args) => {
-            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 });
-            });
-            await this.executeHooks(this.postPageCloseHooks, pageId, browserController);
+            // A browser can acknowledge the close and then never destroy the target, in which case
+            // this never settles and the page's own `close` event never fires either (Chromium
+            // 536385539). Bound the whole sequence so nothing here can hang the caller, then
+            // reconcile the pool regardless of the outcome, so a page that refuses to close cannot
+            // leave the pool believing it is still open. `Promise.race` rather than
+            // `addTimeoutToPromise`: the latter inherits its AbortController from the calling frame,
+            // so a timeout here would cancel the task of whoever awaited `page.close()`.
+            let pageClosed = false;
+            const closing = (async () => {
+                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 });
+                });
+                // Whether the page itself is gone. Tracked separately from the sequence finishing,
+                // so that a slow hook does not get the browser retired.
+                pageClosed = true;
+                await this.#executeHooks(this.#postPageCloseHooks, pageId, browserController);
+            })();
+            let timeout;
+            const finished = await Promise.race([
+                closing.then(() => true, (err) => {
+                    this.#log.warning(`Closing a page failed, releasing it from the pool anyway.\nCause:${err.message}`, { id: browserController.id, pageId });
+                    return true;
+                }),
+                new Promise((resolve) => {
+                    timeout = setTimeout(() => resolve(false), PAGE_CLOSE_TIMEOUT_MILLIS);
+                }),
+            ]);
+            clearTimeout(timeout);
+            if (!finished) {
+                this.#log.warning(`Closing a page did not finish within ${PAGE_CLOSE_TIMEOUT_MILLIS / 1000} seconds, ` +
+                    'releasing it from the pool anyway.', { id: browserController.id, pageId });
+            }
+            if (!pageClosed) {
+                // The page is still attached, so this browser cannot be trusted with more work.
+                // Retiring it lets the reclamation below close the process once its pages drain.
+                this.retireBrowserController(browserController);
+            }
+            browserController.registerPageClosed(page);
             this.pages.delete(pageId);
-            this.closeRetiredBrowserWithNoPages(browserController);
+            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."
@@ -564,42 +625,40 @@ export class BrowserPool extends TypedEmitter {
         }
     }
     /**
-     * Returns `true` if the pool can accept a new browser launch without exceeding
-     * {@link BrowserPoolOptions.maxOpenBrowsers}. Counts starting, active, and retired browsers.
+     * Returns `true` if the pool can accept a new browser launch without exceeding `maxOpenBrowsers`.
+     * Counts starting, active, and retired browsers.
+     *
+     * A plain `BrowserPool` leaves `maxOpenBrowsers` at `Infinity`, so this only returns `false` when something
+     * has set a cap — {@link RemoteBrowserPool} does, from its own
+     * {@link RemoteBrowserPoolOptions.maxOpenBrowsers|`maxOpenBrowsers`} option. There is no
+     * `BrowserPoolOptions` key for it.
+     *
+     * @internal
      */
     hasFreeBrowserSlot() {
-        const total = this.startingBrowserControllers.size +
+        const total = this.#startingBrowserControllers.size +
             this.activeBrowserControllers.size +
             this.retiredBrowserControllers.size;
         return total < this.maxOpenBrowsers;
     }
     /**
      * Returns `true` if any active browser has room for another page.
+     *
+     * @internal
      */
     hasActiveBrowserWithFreeCapacity() {
         for (const controller of this.activeBrowserControllers) {
-            if (controller.activePages < this.maxOpenPagesPerBrowser)
+            if (controller.activePages < this.#maxOpenPagesPerBrowser)
                 return true;
         }
         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();
-    }
-    addFingerprintHooks() {
-        this.preLaunchHooks = [
-            ...this.preLaunchHooks,
-            // This is flipped because of the fingerprint cache.
-            // It is usual to generate proxy per browser and we want to know the proxyUrl for the caching.
-            createFingerprintPreLaunchHook(this),
-        ];
-        this.prePageCreateHooks = [createPrePageCreateHook(), ...this.prePageCreateHooks];
-        this.postPageCreateHooks = [createPostPageCreateHook(this.fingerprintInjector), ...this.postPageCreateHooks];
     }
 }

package/events.d.ts

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

package/events.js

@@ -2,7 +2,6 @@ export var BROWSER_POOL_EVENTS;
 (function (BROWSER_POOL_EVENTS) {
     BROWSER_POOL_EVENTS["BROWSER_LAUNCHED"] = "browserLaunched";
     BROWSER_POOL_EVENTS["BROWSER_RETIRED"] = "browserRetired";
-    BROWSER_POOL_EVENTS["BROWSER_CLOSED"] = "browserClosed";
     BROWSER_POOL_EVENTS["PAGE_CREATED"] = "pageCreated";
     BROWSER_POOL_EVENTS["PAGE_CLOSED"] = "pageClosed";
 })(BROWSER_POOL_EVENTS || (BROWSER_POOL_EVENTS = {}));

package/fingerprinting/types.d.ts

@@ -1,41 +1,12 @@
-import type { BrowserFingerprintWithHeaders as Fingerprint, FingerprintGeneratorOptions as FingerprintOptionsOriginal } from 'fingerprint-generator';
-export interface FingerprintGenerator {
-    getFingerprint: (fingerprintGeneratorOptions?: FingerprintGeneratorOptions) => GetFingerprintReturn;
-}
-export interface GetFingerprintReturn {
-    fingerprint: Fingerprint;
-}
+import type { FingerprintGeneratorOptions as FingerprintOptionsOriginal } from 'fingerprint-generator';
 export interface FingerprintGeneratorOptions extends Partial<FingerprintOptionsOriginal> {
 }
-declare const SUPPORTED_HTTP_VERSIONS: readonly ["1", "2"];
-/**
- * String specifying the HTTP version to use.
- */
-type HttpVersion = (typeof SUPPORTED_HTTP_VERSIONS)[number];
 export declare enum BrowserName {
     chrome = "chrome",
     firefox = "firefox",
     safari = "safari",
     edge = "edge"
 }
-export interface BrowserSpecification {
-    /**
-     * String representing the browser name.
-     */
-    name: BrowserName;
-    /**
-     * Minimum version of browser used.
-     */
-    minVersion?: number;
-    /**
-     * Maximum version of browser used.
-     */
-    maxVersion?: number;
-    /**
-     * HTTP version to be used for header generation (the headers differ depending on the version).
-     */
-    httpVersion?: HttpVersion;
-}
 export declare enum OperatingSystemsName {
     linux = "linux",
     macos = "macos",
@@ -60,4 +31,3 @@ export declare enum DeviceCategory {
      */
     desktop = "desktop"
 }
-export {};

package/fingerprinting/types.js

@@ -1,4 +1,3 @@
-const SUPPORTED_HTTP_VERSIONS = ['1', '2'];
 export var BrowserName;
 (function (BrowserName) {
     BrowserName["chrome"] = "chrome";

package/index.d.ts

@@ -28,7 +28,7 @@ export * from './browser-pool.js';
 export * from './playwright/playwright-plugin.js';
 export * from './puppeteer/puppeteer-plugin.js';
 export * from './events.js';
-export type { BrowserSpecification, FingerprintGenerator, FingerprintGeneratorOptions, GetFingerprintReturn, } from './fingerprinting/types.js';
+export type { FingerprintGeneratorOptions } from './fingerprinting/types.js';
 export { BrowserName, DeviceCategory, OperatingSystemsName } from './fingerprinting/types.js';
 export type { BrowserControllerEvents, IBrowserController, IBrowserLaunchContext, } from './abstract-classes/browser-controller.js';
 export { BrowserController } from './abstract-classes/browser-controller.js';

package/launch-context.d.ts

@@ -52,6 +52,7 @@ export interface LaunchContextOptions<Library extends CommonLibrary = CommonLibr
      * Whether this launch context represents a connection to a remote browser
      * rather than a locally launched one.
      * @default false
+     * @internal
      */
     isRemote?: boolean;
 }