@crawlee/browser-pool 4.0.0-beta.105 → 4.0.0-beta.107

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

@@ -35,13 +35,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 +59,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 +71,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 +80,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?
@@ -102,7 +103,7 @@ 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);
     }

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

@@ -119,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,
@@ -132,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

@@ -84,13 +84,14 @@ 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),
@@ -126,13 +127,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 +143,7 @@ export class BrowserPool extends TypedEmitter {
         this.postPageCloseHooks = postPageCloseHooks;
         // fingerprinting
         if (this.useFingerprints) {
-            this._initializeFingerprinting();
+            this.initializeFingerprinting();
         }
     }
     /**
@@ -163,7 +164,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.`);
         }
@@ -181,16 +182,16 @@ export class BrowserPool extends TypedEmitter {
         // 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);
         }));
     }
     /**
@@ -199,13 +200,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
@@ -271,7 +272,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
@@ -287,7 +288,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 {
@@ -300,13 +301,13 @@ 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);
         return page;
@@ -403,7 +404,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());
@@ -414,26 +415,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);
@@ -454,7 +455,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();
@@ -464,17 +465,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,
                 });
             });
@@ -491,12 +492,12 @@ export class BrowserPool extends TypedEmitter {
      * 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;
@@ -508,7 +509,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;
@@ -516,45 +517,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.closeRetiredBrowserWithNoPages(browserController);
             this.emit("pageClosed" /* 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);
                 });
@@ -581,16 +582,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/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;
         }

package/launch-context.d.ts

@@ -56,6 +56,7 @@ export interface LaunchContextOptions<Library extends CommonLibrary = CommonLibr
     isRemote?: boolean;
 }
 export declare class LaunchContext<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']>>> {
+    #private;
     id?: string;
     browserPlugin: BrowserPlugin<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>;
     launchOptions: LibraryOptions;
@@ -64,15 +65,13 @@ export declare class LaunchContext<Library extends CommonLibrary = CommonLibrary
     userDataDir: string;
     readonly isRemote: boolean;
     ignoreProxyCertificate?: boolean;
-    private _proxyUrl?;
-    private readonly _reservedFieldNames;
     fingerprint?: BrowserFingerprintWithHeaders;
     /**
      * Token identifying the remote browser session this context connected to, set by the plugin and read by
      * the {@link RemoteBrowserPool} to release the session on close. Only present for remote connections.
      * @internal
      */
-    _remoteToken?: number;
+    remoteToken?: number;
     [K: PropertyKey]: unknown;
     constructor(options: LaunchContextOptions<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>);
     /**

package/launch-context.js

@@ -7,15 +7,15 @@ export class LaunchContext {
     userDataDir;
     isRemote;
     ignoreProxyCertificate;
-    _proxyUrl;
-    _reservedFieldNames = [...Reflect.ownKeys(this), 'extend'];
+    #proxyUrl;
+    #reservedFieldNames;
     fingerprint;
     /**
      * Token identifying the remote browser session this context connected to, set by the plugin and read by
      * the {@link RemoteBrowserPool} to release the session on close. Only present for remote connections.
      * @internal
      */
-    _remoteToken;
+    remoteToken;
     constructor(options) {
         const { id, browserPlugin, launchOptions, proxyUrl, useIncognitoPages, browserPerProxy, userDataDir = '', ignoreProxyCertificate, isRemote, } = options;
         this.id = id;
@@ -26,7 +26,10 @@ export class LaunchContext {
         this.userDataDir = userDataDir;
         this.ignoreProxyCertificate = ignoreProxyCertificate ?? false;
         this.isRemote = isRemote ?? false;
-        this._proxyUrl = proxyUrl;
+        this.#proxyUrl = proxyUrl;
+        // Computed here (not in a field initializer) so that all fields already exist; the accessors live on
+        // the prototype, so they are never own keys and have to be listed explicitly.
+        this.#reservedFieldNames = [...Reflect.ownKeys(this), 'proxyUrl', 'remoteToken', 'extend'];
     }
     /**
      * Extend the launch context with any extra fields.
@@ -37,7 +40,7 @@ export class LaunchContext {
      */
     extend(fields) {
         Object.entries(fields).forEach(([key, value]) => {
-            if (this._reservedFieldNames.includes(key)) {
+            if (this.#reservedFieldNames.includes(key)) {
                 throw new Error(`Cannot extend LaunchContext with key: ${key}, because it's reserved.`);
             }
             else {
@@ -51,7 +54,7 @@ export class LaunchContext {
      */
     set proxyUrl(url) {
         if (!url) {
-            this._proxyUrl = undefined;
+            this.#proxyUrl = undefined;
             return;
         }
         const urlInstance = new URL(url);
@@ -59,12 +62,12 @@ export class LaunchContext {
         urlInstance.search = '';
         urlInstance.hash = '';
         // https://www.chromium.org/developers/design-documents/network-settings/#command-line-options-for-proxy-settings
-        this._proxyUrl = urlInstance.href.slice(0, -1);
+        this.#proxyUrl = urlInstance.href.slice(0, -1);
     }
     /**
      * Returns the proxy URL of the browser.
      */
     get proxyUrl() {
-        return this._proxyUrl;
+        return this.#proxyUrl;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/browser-pool",
-    "version": "4.0.0-beta.105",
+    "version": "4.0.0-beta.107",
     "description": "Rotate multiple browsers using popular automation libraries such as Playwright or Puppeteer.",
     "engines": {
         "node": ">=22.0.0"
@@ -31,8 +31,8 @@
     },
     "dependencies": {
         "@apify/timeout": "^0.4.4",
-        "@crawlee/core": "4.0.0-beta.105",
-        "@crawlee/types": "4.0.0-beta.105",
+        "@crawlee/core": "4.0.0-beta.107",
+        "@crawlee/types": "4.0.0-beta.107",
         "fingerprint-generator": "^2.1.68",
         "fingerprint-injector": "^2.1.68",
         "lodash.merge": "^4.6.2",
@@ -63,5 +63,5 @@
             }
         }
     },
-    "gitHead": "26073a822c7699ac487931383a39192bc3daae7a"
+    "gitHead": "5a3cb6242d0ae261df93c5e03cfebbb9b736e6b7"
 }

package/playwright/playwright-browser.d.ts

@@ -9,10 +9,7 @@ export interface BrowserOptions {
  * Browser wrapper created to have consistent API with persistent and non-persistent contexts.
  */
 export declare class PlaywrightBrowser extends EventEmitter {
-    private _browserContext;
-    private _version;
-    private _isConnected;
-    private _browserType?;
+    #private;
     constructor(options: BrowserOptions);
     [Symbol.asyncDispose](): Promise<void>;
     close(): Promise<void>;
@@ -20,7 +17,7 @@ export declare class PlaywrightBrowser extends EventEmitter {
     isConnected(): boolean;
     version(): string;
     /** @internal */
-    _setBrowserType(browserType: BrowserType): void;
+    setBrowserType(browserType: BrowserType): void;
     browserType(): BrowserType;
     newPage(...args: Parameters<BrowserContext['newPage']>): ReturnType<BrowserContext['newPage']>;
     newContext(): Promise<never>;

package/playwright/playwright-browser.js

@@ -3,17 +3,17 @@ import { EventEmitter } from 'node:events';
  * Browser wrapper created to have consistent API with persistent and non-persistent contexts.
  */
 export class PlaywrightBrowser extends EventEmitter {
-    _browserContext;
-    _version;
-    _isConnected = true;
-    _browserType;
+    #browserContext;
+    #version;
+    #isConnected = true;
+    #browserType;
     constructor(options) {
         super();
         const { browserContext, version } = options;
-        this._browserContext = browserContext;
-        this._version = version;
-        this._browserContext.once('close', () => {
-            this._isConnected = false;
+        this.#browserContext = browserContext;
+        this.#version = version;
+        this.#browserContext.once('close', () => {
+            this.#isConnected = false;
             this.emit('disconnected');
         });
     }
@@ -21,26 +21,26 @@ export class PlaywrightBrowser extends EventEmitter {
         await this.close();
     }
     async close() {
-        await this._browserContext.close();
+        await this.#browserContext.close();
     }
     contexts() {
-        return [this._browserContext];
+        return [this.#browserContext];
     }
     isConnected() {
-        return this._isConnected;
+        return this.#isConnected;
     }
     version() {
-        return this._version;
+        return this.#version;
     }
     /** @internal */
-    _setBrowserType(browserType) {
-        this._browserType = browserType;
+    setBrowserType(browserType) {
+        this.#browserType = browserType;
     }
     browserType() {
-        return this._browserType;
+        return this.#browserType;
     }
     async newPage(...args) {
-        return this._browserContext.newPage(...args);
+        return this.#browserContext.newPage(...args);
     }
     async newContext() {
         throw new Error('Function `newContext()` is not available in incognito mode');

package/playwright/playwright-plugin.d.ts

@@ -6,15 +6,15 @@ import type { RemoteConnection, RemoteConnectionParameters } from '../remote-bro
 import type { SafeParameters } from '../utils.js';
 import { PlaywrightController } from './playwright-controller.js';
 export declare class PlaywrightPlugin extends BrowserPlugin<BrowserType, SafeParameters<BrowserType['launch']>[0], PlaywrightBrowser> {
-    private _browserVersion?;
+    #private;
     /**
      * Playwright remote connections only support incognito pages — `connect()` / `connectOverCDP()` don't
      * accept persistent contexts. Force it on (and inform the user) when wired for a remote connection.
      */
     useRemoteConnection(connection: RemoteConnection, parameters?: RemoteConnectionParameters): void;
     protected _launch(launchContext: LaunchContext<BrowserType>): Promise<PlaywrightBrowser>;
-    private _throwOnFailedLaunch;
+    private throwOnFailedLaunch;
     createController(): PlaywrightController;
-    protected _addProxyToLaunchOptions(launchContext: LaunchContext<BrowserType>): Promise<void>;
-    protected _isChromiumBasedBrowser(): boolean;
+    protected addProxyToLaunchOptions(launchContext: LaunchContext<BrowserType>): Promise<void>;
+    protected isChromiumBasedBrowser(): boolean;
 }

package/playwright/playwright-plugin.js

@@ -5,7 +5,7 @@ import { getLocalProxyAddress } from '../proxy-server.js';
 import { PlaywrightBrowser as PlaywrightBrowserWithPersistentContext } from './playwright-browser.js';
 import { PlaywrightController } from './playwright-controller.js';
 export class PlaywrightPlugin extends BrowserPlugin {
-    _browserVersion;
+    #browserVersion;
     /**
      * Playwright remote connections only support incognito pages — `connect()` / `connectOverCDP()` don't
      * accept persistent contexts. Force it on (and inform the user) when wired for a remote connection.
@@ -20,7 +20,7 @@ export class PlaywrightPlugin extends BrowserPlugin {
     }
     async _launch(launchContext) {
         if (this.remoteConnection) {
-            return this._connectToRemoteBrowser(launchContext, async (url) => {
+            return this.connectToRemoteBrowser(launchContext, async (url) => {
                 const connectOptions = (this.remoteConnectionParameters?.connectOptions ?? {});
                 if (this.remoteConnectionParameters?.protocol === 'playwright') {
                     this.log.info('Connecting to remote browser via connect (Playwright WebSocket).');
@@ -53,7 +53,7 @@ export class PlaywrightPlugin extends BrowserPlugin {
         try {
             if (useIncognitoPages) {
                 browser = await this.library.launch(launchOptions).catch((error) => {
-                    return this._throwOnFailedLaunch(launchContext, error);
+                    return this.throwOnFailedLaunch(launchContext, error);
                 });
                 if (anonymizedProxyUrl) {
                     browser.on('disconnected', async () => {
@@ -65,7 +65,7 @@ export class PlaywrightPlugin extends BrowserPlugin {
                 const browserContext = await this.library
                     .launchPersistentContext(userDataDir, launchOptions)
                     .catch((error) => {
-                    return this._throwOnFailedLaunch(launchContext, error);
+                    return this.throwOnFailedLaunch(launchContext, error);
                 });
                 browserContext.once('close', () => {
                     if (userDataDir.includes('apify-playwright-firefox-taac-')) {
@@ -80,17 +80,17 @@ export class PlaywrightPlugin extends BrowserPlugin {
                         await close();
                     });
                 }
-                if (!this._browserVersion) {
+                if (!this.#browserVersion) {
                     // Launches unused browser just to get the browser version.
                     const inactiveBrowser = await this.library.launch(launchOptions);
-                    this._browserVersion = inactiveBrowser.version();
+                    this.#browserVersion = inactiveBrowser.version();
                     inactiveBrowser.close().catch((error) => {
                         this.log.exception(error, 'Failed to close browser.');
                     });
                 }
                 browser = new PlaywrightBrowserWithPersistentContext({
                     browserContext,
-                    version: this._browserVersion,
+                    version: this.#browserVersion,
                 });
             }
         }
@@ -100,13 +100,13 @@ export class PlaywrightPlugin extends BrowserPlugin {
         }
         return browser;
     }
-    _throwOnFailedLaunch(launchContext, cause) {
-        this._throwAugmentedLaunchError(cause, launchContext.launchOptions?.executablePath, '`apify/actor-node-playwright-*` (with a correct browser name)', 'Try installing the required dependencies by running `npx playwright install --with-deps` (https://playwright.dev/docs/browsers).');
+    throwOnFailedLaunch(launchContext, cause) {
+        this.throwAugmentedLaunchError(cause, launchContext.launchOptions?.executablePath, '`apify/actor-node-playwright-*` (with a correct browser name)', 'Try installing the required dependencies by running `npx playwright install --with-deps` (https://playwright.dev/docs/browsers).');
     }
     createController() {
         return new PlaywrightController(this);
     }
-    async _addProxyToLaunchOptions(launchContext) {
+    async addProxyToLaunchOptions(launchContext) {
         launchContext.launchOptions ??= {};
         const { launchOptions, proxyUrl } = launchContext;
         if (proxyUrl) {
@@ -118,7 +118,7 @@ export class PlaywrightPlugin extends BrowserPlugin {
             };
         }
     }
-    _isChromiumBasedBrowser() {
+    isChromiumBasedBrowser() {
         const name = this.library.name();
         return name === 'chromium';
     }

package/puppeteer/puppeteer-plugin.d.ts

@@ -12,6 +12,6 @@ export declare class PuppeteerPlugin extends BrowserPlugin<typeof Puppeteer, Pup
     useRemoteConnection(connection: RemoteConnection, parameters?: RemoteConnectionParameters): void;
     protected _launch(launchContext: LaunchContext<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): Promise<PuppeteerTypes.Browser>;
     createController(): PuppeteerController;
-    protected _addProxyToLaunchOptions(_launchContext: LaunchContext<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): Promise<void>;
-    protected _isChromiumBasedBrowser(_launchContext: LaunchContext<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): boolean;
+    protected addProxyToLaunchOptions(_launchContext: LaunchContext<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): Promise<void>;
+    protected isChromiumBasedBrowser(_launchContext: LaunchContext<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): boolean;
 }

package/puppeteer/puppeteer-plugin.js

@@ -27,7 +27,7 @@ export class PuppeteerPlugin extends BrowserPlugin {
         const { useIncognitoPages, proxyUrl, ignoreProxyCertificate } = launchContext;
         let browser;
         if (this.remoteConnection) {
-            browser = await this._connectToRemoteBrowser(launchContext, async (url) => {
+            browser = await this.connectToRemoteBrowser(launchContext, async (url) => {
                 const connectOptions = this.remoteConnectionParameters?.connectOptions ?? {};
                 this.log.info('Connecting to remote browser via connect (CDP).');
                 return this.library.connect({ ...connectOptions, browserWSEndpoint: url });
@@ -73,7 +73,7 @@ export class PuppeteerPlugin extends BrowserPlugin {
                 }
                 catch (error) {
                     await close();
-                    this._throwAugmentedLaunchError(error, launchContext.launchOptions?.executablePath, '`apify/actor-node-puppeteer-chrome`', "Try installing a browser, if it's missing, by running `npx @puppeteer/browsers install chromium --path [path]` and pointing `executablePath` to the downloaded executable (https://pptr.dev/browsers-api)");
+                    this.throwAugmentedLaunchError(error, launchContext.launchOptions?.executablePath, '`apify/actor-node-puppeteer-chrome`', "Try installing a browser, if it's missing, by running `npx @puppeteer/browsers install chromium --path [path]` and pointing `executablePath` to the downloaded executable (https://pptr.dev/browsers-api)");
                 }
             }
         }
@@ -177,7 +177,7 @@ export class PuppeteerPlugin extends BrowserPlugin {
     createController() {
         return new PuppeteerController(this);
     }
-    async _addProxyToLaunchOptions(_launchContext) {
+    async addProxyToLaunchOptions(_launchContext) {
         /*
         // DO NOT USE YET! DOING SO DISABLES CACHE WHICH IS 50% PERFORMANCE HIT!
         launchContext.launchOptions ??= {};
@@ -204,7 +204,7 @@ export class PuppeteerPlugin extends BrowserPlugin {
         }
         */
     }
-    _isChromiumBasedBrowser(_launchContext) {
+    isChromiumBasedBrowser(_launchContext) {
         return true;
     }
 }

package/remote-browser-pool.d.ts

@@ -134,15 +134,9 @@ export type CrawlerRemoteBrowserOptions = Omit<RemoteBrowserPoolOptions, 'browse
  * @category Browser management
  */
 export declare class RemoteBrowserPool<Page = unknown> implements IBrowserPool<Page> {
+    #private;
     /** The wrapped pool that performs the remote connections and serves pages. */
     readonly browserPool: BrowserPool;
-    /** The wrapped pool viewed through the {@link IBrowserPool} contract (the bare type widens pages to `never`). */
-    private readonly pool;
-    private readonly registry;
-    private readonly slotPollIntervalMillis;
-    private readonly log;
-    /** Shared by all `newPage` callers waiting for a free slot, so they don't each register their own listeners. */
-    private _capacityChange?;
     constructor(options: RemoteBrowserPoolOptions);
     /** Maximum number of remote browsers that may be open at the same time. */
     get maxOpenBrowsers(): number;
@@ -160,11 +154,11 @@ export declare class RemoteBrowserPool<Page = unknown> implements IBrowserPool<P
     /** Closes all browsers, releases any still-open remote sessions, and tears down the wrapped pool. */
     destroy(): Promise<void>;
     /** Resolves once the wrapped pool can serve another page without exceeding `maxOpenBrowsers`. */
-    private _waitForFreeSlot;
+    private waitForFreeSlot;
     /**
      * Resolves on the next browser-retired / page-closed event, or after `slotPollIntervalMillis`. All
      * concurrently-waiting `newPage` calls share a single promise (and a single pair of event listeners)
      * per tick, so a fleet of saturated callers doesn't fan out into N listener pairs on the pool.
      */
-    private _nextCapacityChange;
+    private nextCapacityChange;
 }

package/remote-browser-pool.js

@@ -7,18 +7,18 @@ import { RemoteBrowserProvider } from './remote-browser-provider.js';
  * {@link RemoteConnection} so it can be injected into a plugin.
  */
 class RemoteSessionRegistry {
-    endpoint;
-    onRelease;
-    log;
-    sessions = new Map();
-    nextToken = 0;
+    #sessions = new Map();
+    #nextToken = 0;
+    #endpoint;
+    #onRelease;
+    #log;
     constructor(endpoint, onRelease, log) {
-        this.endpoint = endpoint;
-        this.onRelease = onRelease;
-        this.log = log;
+        this.#endpoint = endpoint;
+        this.#onRelease = onRelease;
+        this.#log = log;
     }
     async resolve(options) {
-        const resolved = typeof this.endpoint === 'function' ? await this.endpoint(options) : this.endpoint;
+        const resolved = typeof this.#endpoint === 'function' ? await this.#endpoint(options) : this.#endpoint;
         let result;
         if (typeof resolved === 'string') {
             if (!resolved)
@@ -31,30 +31,30 @@ class RemoteSessionRegistry {
         else {
             result = resolved;
         }
-        const token = this.nextToken++;
-        this.sessions.set(token, { url: result.url, context: result.context, released: false });
+        const token = this.#nextToken++;
+        this.#sessions.set(token, { url: result.url, context: result.context, released: false });
         return { url: result.url, token };
     }
     async release(token) {
-        const session = this.sessions.get(token);
+        const session = this.#sessions.get(token);
         // Release at most once per session — guards a close()/teardown race (the `released` flag is set
         // synchronously before the awaited onRelease, so releaseAll() can't double-fire an in-flight release).
         if (!session || session.released)
             return;
         session.released = true;
         try {
-            await this.onRelease?.({ endpoint: session.url, context: session.context });
+            await this.#onRelease?.({ endpoint: session.url, context: session.context });
         }
         catch (err) {
-            this.log.warning('Remote browser release() failed.', { error: err?.message });
+            this.#log.warning('Remote browser release() failed.', { error: err?.message });
         }
         finally {
-            this.sessions.delete(token);
+            this.#sessions.delete(token);
         }
     }
     /** Releases every session that is still open. Called on pool teardown so no remote session leaks. */
     async releaseAll() {
-        await Promise.all([...this.sessions.keys()].map(async (token) => this.release(token)));
+        await Promise.all([...this.#sessions.keys()].map(async (token) => this.release(token)));
     }
 }
 /**
@@ -92,16 +92,16 @@ export class RemoteBrowserPool {
     /** The wrapped pool that performs the remote connections and serves pages. */
     browserPool;
     /** The wrapped pool viewed through the {@link IBrowserPool} contract (the bare type widens pages to `never`). */
-    pool;
-    registry;
-    slotPollIntervalMillis;
-    log;
+    #pool;
+    #registry;
+    #slotPollIntervalMillis;
+    #log;
     /** Shared by all `newPage` callers waiting for a free slot, so they don't each register their own listeners. */
-    _capacityChange;
+    #capacityChange;
     constructor(options) {
         const { browserPlugins, endpoint, release, maxOpenBrowsers, connection = {}, browserPoolOptions = {}, slotPollIntervalMillis = 500, } = options;
-        this.log = serviceLocator.getLogger().child({ prefix: 'RemoteBrowserPool' });
-        this.slotPollIntervalMillis = slotPollIntervalMillis;
+        this.#log = serviceLocator.getLogger().child({ prefix: 'RemoteBrowserPool' });
+        this.#slotPollIntervalMillis = slotPollIntervalMillis;
         // A RemoteBrowserProvider carries its own endpoint, release, and maxOpenBrowsers.
         const provider = endpoint instanceof RemoteBrowserProvider ? endpoint : undefined;
         const resolvedEndpoint = provider
@@ -111,20 +111,20 @@ export class RemoteBrowserPool {
             ? ({ context }) => provider.release(context)
             : release;
         const resolvedMax = maxOpenBrowsers ?? provider?.maxOpenBrowsers;
-        this.registry = new RemoteSessionRegistry(resolvedEndpoint, resolvedRelease, this.log);
+        this.#registry = new RemoteSessionRegistry(resolvedEndpoint, resolvedRelease, this.#log);
         // Wire every plugin for remote connection.
         for (const plugin of browserPlugins) {
-            plugin.useRemoteConnection(this.registry, connection);
+            plugin.useRemoteConnection(this.#registry, connection);
         }
         this.browserPool = new BrowserPool({ ...browserPoolOptions, browserPlugins });
-        this.pool = this.browserPool;
+        this.#pool = this.browserPool;
         // Release a browser's remote session once it closes. The registry dedupes (close() schedules a delayed
         // kill(), so BROWSER_CLOSED can fire twice), and destroy()'s releaseAll() backstops any that never close.
         this.browserPool.on("browserLaunched" /* BROWSER_POOL_EVENTS.BROWSER_LAUNCHED */, (controller) => {
             controller.once("browserClosed" /* BROWSER_CONTROLLER_EVENTS.BROWSER_CLOSED */, () => {
-                const token = controller.launchContext._remoteToken;
+                const token = controller.launchContext.remoteToken;
                 if (token !== undefined)
-                    void this.registry.release(token);
+                    void this.#registry.release(token);
             });
         });
         if (resolvedMax !== undefined) {
@@ -143,28 +143,28 @@ export class RemoteBrowserPool {
      * allows it (either a new browser slot is free, or an active browser still has page capacity).
      */
     async newPage(options) {
-        await this._waitForFreeSlot();
-        return this.pool.newPage(options);
+        await this.waitForFreeSlot();
+        return this.#pool.newPage(options);
     }
     async closePage(page, options) {
-        return this.pool.closePage(page, options);
+        return this.#pool.closePage(page, options);
     }
     async extractPageState(page) {
-        return this.pool.extractPageState(page);
+        return this.#pool.extractPageState(page);
     }
     async injectPageState(page, state) {
-        return this.pool.injectPageState(page, state);
+        return this.#pool.injectPageState(page, state);
     }
     /** Closes all browsers, releases any still-open remote sessions, and tears down the wrapped pool. */
     async destroy() {
         await this.browserPool.destroy();
         // Backstop: release any sessions whose browser never emitted a close (e.g. dropped on teardown).
-        await this.registry.releaseAll();
+        await this.#registry.releaseAll();
     }
     /** Resolves once the wrapped pool can serve another page without exceeding `maxOpenBrowsers`. */
-    async _waitForFreeSlot() {
+    async waitForFreeSlot() {
         while (!this.browserPool.hasFreeBrowserSlot() && !this.browserPool.hasActiveBrowserWithFreeCapacity()) {
-            await this._nextCapacityChange();
+            await this.nextCapacityChange();
         }
     }
     /**
@@ -172,20 +172,20 @@ export class RemoteBrowserPool {
      * concurrently-waiting `newPage` calls share a single promise (and a single pair of event listeners)
      * per tick, so a fleet of saturated callers doesn't fan out into N listener pairs on the pool.
      */
-    _nextCapacityChange() {
-        this._capacityChange ??= new Promise((resolve) => {
+    nextCapacityChange() {
+        this.#capacityChange ??= new Promise((resolve) => {
             const done = () => {
                 clearTimeout(timer);
                 this.browserPool.off("browserRetired" /* BROWSER_POOL_EVENTS.BROWSER_RETIRED */, done);
                 this.browserPool.off("pageClosed" /* BROWSER_POOL_EVENTS.PAGE_CLOSED */, done);
-                this._capacityChange = undefined;
+                this.#capacityChange = undefined;
                 resolve();
             };
-            const timer = setTimeout(done, this.slotPollIntervalMillis);
+            const timer = setTimeout(done, this.#slotPollIntervalMillis);
             timer.unref?.();
             this.browserPool.once("browserRetired" /* BROWSER_POOL_EVENTS.BROWSER_RETIRED */, done);
             this.browserPool.once("pageClosed" /* BROWSER_POOL_EVENTS.PAGE_CLOSED */, done);
         });
-        return this._capacityChange;
+        return this.#capacityChange;
     }
 }