@crawlee/browser-pool 4.0.0-beta.223 → 4.0.0-beta.225

package/puppeteer/puppeteer-plugin.js

@@ -5,82 +5,69 @@ import { noop } from '../utils.js';
 import { PuppeteerController } from './puppeteer-controller.js';
 const PROXY_SERVER_ARG = '--proxy-server=';
 export class PuppeteerPlugin extends BrowserPlugin {
-    /**
-     * Pages share cookies/storage on the remote browser (Puppeteer defaults to non-incognito).
-     *
-     * @internal
-     */
-    useRemoteConnection(connection, parameters = {}) {
-        super.useRemoteConnection(connection, parameters);
-        if (!this.useIncognitoPages) {
-            this.log.info('Remote Puppeteer connection — pages will share cookies and storage on the remote ' +
-                'browser instance (useIncognitoPages defaults to false).');
-        }
-    }
     async _launch(launchContext) {
-        let oldPuppeteerVersion = false;
-        try {
-            const jsonPath = require.resolve('puppeteer/package.json');
-            const parsed = JSON.parse(await readFile(jsonPath, 'utf-8'));
-            const version = +parsed.version.split('.')[0];
-            oldPuppeteerVersion = version < 22;
+        const oldPuppeteerVersion = await this.isOldPuppeteerVersion();
+        const { launchOptions, userDataDir, experimentalContainers, proxyUrl } = launchContext;
+        if (experimentalContainers) {
+            throw new Error('Experimental containers are only available with Playwright');
         }
-        catch {
-            // ignore
+        launchOptions.userDataDir = launchOptions.userDataDir ?? userDataDir;
+        if (launchOptions.headless === false) {
+            if (Array.isArray(launchOptions.args)) {
+                launchOptions.args.push('--disable-site-isolation-trials');
+            }
+            else {
+                launchOptions.args = ['--disable-site-isolation-trials'];
+            }
         }
-        const { useIncognitoPages, proxyUrl, ignoreProxyCertificate } = launchContext;
-        let browser;
-        if (this.remoteConnection) {
-            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 });
-            });
+        if (launchOptions.headless === true && oldPuppeteerVersion) {
+            launchOptions.headless = 'new';
         }
-        else {
-            const { launchOptions, userDataDir, experimentalContainers } = launchContext;
-            if (experimentalContainers) {
-                throw new Error('Experimental containers are only available with Playwright');
-            }
-            launchOptions.userDataDir = launchOptions.userDataDir ?? userDataDir;
-            if (launchOptions.headless === false) {
-                if (Array.isArray(launchOptions.args)) {
-                    launchOptions.args.push('--disable-site-isolation-trials');
-                }
-                else {
-                    launchOptions.args = ['--disable-site-isolation-trials'];
-                }
+        const [anonymizedProxyUrl, close] = await anonymizeProxySugar(proxyUrl, undefined, undefined, {
+            ignoreProxyCertificate: launchContext.ignoreProxyCertificate,
+        });
+        if (proxyUrl) {
+            const proxyArg = `${PROXY_SERVER_ARG}${anonymizedProxyUrl ?? proxyUrl}`;
+            if (Array.isArray(launchOptions.args)) {
+                launchOptions.args.push(proxyArg);
             }
-            if (launchOptions.headless === true && oldPuppeteerVersion) {
-                launchOptions.headless = 'new';
+            else {
+                launchOptions.args = [proxyArg];
             }
-            {
-                const [anonymizedProxyUrl, close] = await anonymizeProxySugar(proxyUrl, undefined, undefined, {
-                    ignoreProxyCertificate: launchContext.ignoreProxyCertificate,
-                });
-                if (proxyUrl) {
-                    const proxyArg = `${PROXY_SERVER_ARG}${anonymizedProxyUrl ?? proxyUrl}`;
-                    if (Array.isArray(launchOptions.args)) {
-                        launchOptions.args.push(proxyArg);
-                    }
-                    else {
-                        launchOptions.args = [proxyArg];
-                    }
-                }
-                try {
-                    browser = await this.library.launch(launchOptions);
-                    if (anonymizedProxyUrl) {
-                        browser.on('disconnected', async () => {
-                            await close();
-                        });
-                    }
-                }
-                catch (error) {
+        }
+        let browser;
+        try {
+            browser = await this.library.launch(launchOptions);
+            if (anonymizedProxyUrl) {
+                browser.on('disconnected', async () => {
                     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)");
-                }
+                });
             }
         }
+        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)");
+        }
+        return this.wrapBrowser(browser, launchContext, oldPuppeteerVersion);
+    }
+    /** @internal */
+    async isOldPuppeteerVersion() {
+        try {
+            const jsonPath = require.resolve('puppeteer/package.json');
+            const parsed = JSON.parse(await readFile(jsonPath, 'utf-8'));
+            return +parsed.version.split('.')[0] < 22;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Attaches page crash handling and the incognito-context-per-page `newPage` proxy. Shared by the local launch
+     * and {@link RemotePuppeteerPlugin}.
+     * @internal
+     */
+    wrapBrowser(browser, launchContext, oldPuppeteerVersion) {
+        const { useIncognitoPages, proxyUrl, ignoreProxyCertificate, isRemote } = launchContext;
         const targetCreatedHandler = async (target) => {
             try {
                 const page = await target.page();
@@ -96,8 +83,7 @@ export class PuppeteerPlugin extends BrowserPlugin {
             }
         };
         browser.on('targetcreated', targetCreatedHandler);
-        // Clean up the listener when a remote browser disconnects to prevent leaks
-        if (this.remoteConnection) {
+        if (isRemote) {
             browser.once('disconnected', () => {
                 browser.off('targetcreated', targetCreatedHandler);
             });
@@ -123,8 +109,8 @@ export class PuppeteerPlugin extends BrowserPlugin {
                     return async (...args) => {
                         let page;
                         if (useIncognitoPages) {
-                            // Skip proxy setup for remote connections — proxy is managed by the remote service.
-                            const effectiveProxyUrl = this.remoteConnection ? undefined : proxyUrl;
+                            // Proxy is managed by the remote service.
+                            const effectiveProxyUrl = isRemote ? undefined : proxyUrl;
                             const [anonymizedProxyUrl, close] = effectiveProxyUrl
                                 ? await anonymizeProxySugar(effectiveProxyUrl, undefined, undefined, {
                                     ignoreProxyCertificate,

package/puppeteer/remote-puppeteer-plugin.d.ts

@@ -0,0 +1,22 @@
+// @ts-ignore optional peer dependency or compatibility with es2022
+import type Puppeteer from 'puppeteer';
+// @ts-ignore optional peer dependency or compatibility with es2022
+import type * as PuppeteerTypes from 'puppeteer';
+import type { BrowserPluginOptions, CreateLaunchContextOptions } from '../abstract-classes/browser-plugin.js';
+import { type RemoteBrowserOptions } from '../remote-browser-plugin.js';
+import type { PuppeteerNewPageOptions } from './puppeteer-controller.js';
+import { type PuppeteerLaunchContext, PuppeteerPlugin } from './puppeteer-plugin.js';
+export interface RemotePuppeteerPluginOptions extends BrowserPluginOptions<PuppeteerTypes.LaunchOptions>, RemoteBrowserOptions {
+}
+/**
+ * A {@link PuppeteerPlugin} that connects to a remote browser service (Browserbase, Browserless, Steel, …)
+ * over CDP instead of launching locally. `launchOptions` are ignored — the remote service owns the browser.
+ */
+export declare class RemotePuppeteerPlugin extends PuppeteerPlugin {
+    #private;
+    constructor(library: typeof Puppeteer, options: RemotePuppeteerPluginOptions);
+    createLaunchContext(options?: CreateLaunchContextOptions<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions>): PuppeteerLaunchContext;
+    /** Skips the local proxy and webdriver-stealth preparation; the remote service owns the browser. */
+    launch(launchContext?: PuppeteerLaunchContext): Promise<PuppeteerTypes.Browser>;
+    protected _launch(launchContext: PuppeteerLaunchContext): Promise<PuppeteerTypes.Browser>;
+}

package/puppeteer/remote-puppeteer-plugin.js

@@ -0,0 +1,31 @@
+import { connectRemoteBrowser } from '../remote-browser-plugin.js';
+import { PuppeteerPlugin } from './puppeteer-plugin.js';
+/**
+ * A {@link PuppeteerPlugin} that connects to a remote browser service (Browserbase, Browserless, Steel, …)
+ * over CDP instead of launching locally. `launchOptions` are ignored — the remote service owns the browser.
+ */
+export class RemotePuppeteerPlugin extends PuppeteerPlugin {
+    #remote;
+    constructor(library, options) {
+        super(library, options);
+        this.#remote = options;
+        if (!this.useIncognitoPages) {
+            this.log.info('Remote Puppeteer connection — pages will share cookies and storage on the remote ' +
+                'browser instance (useIncognitoPages defaults to false).');
+        }
+    }
+    createLaunchContext(options = {}) {
+        return super.createLaunchContext({ ...options, isRemote: true });
+    }
+    /** Skips the local proxy and webdriver-stealth preparation; the remote service owns the browser. */
+    async launch(launchContext = this.createLaunchContext()) {
+        return this._launch(launchContext);
+    }
+    async _launch(launchContext) {
+        const browser = await connectRemoteBrowser(this.#remote, launchContext.proxyUrl, this.log, async (url) => {
+            this.log.info('Connecting to remote browser via connect (CDP).');
+            return this.library.connect({ ...this.#remote.connectOptions, browserWSEndpoint: url });
+        });
+        return this.wrapBrowser(browser, launchContext, await this.isOldPuppeteerVersion());
+    }
+}

package/remote-browser-plugin.d.ts

@@ -0,0 +1,49 @@
+import type { CrawleeLogger } from '@crawlee/core';
+import { RemoteBrowserProvider } from './remote-browser-provider.js';
+/**
+ * The result of resolving a remote browser endpoint: the URL to connect to plus an optional opaque
+ * `context` object that is handed back to `release`.
+ */
+export interface ResolvedRemoteEndpoint {
+    /** The WebSocket / CDP URL to connect to. */
+    url: string;
+    /** Opaque per-session data (e.g. a session ID) passed back to `release`. */
+    context?: Record<string, unknown>;
+}
+/**
+ * A remote browser endpoint: either a static URL string, or a function called once per browser launch
+ * that returns the URL (optionally with a `context` for `release`). The function receives the proxy URL
+ * Crawlee resolved for the browser, so it can be forwarded to services that accept an external proxy.
+ */
+export type RemoteBrowserEndpoint = string | ((options?: {
+    proxyUrl?: string;
+}) => string | ResolvedRemoteEndpoint | Promise<string | ResolvedRemoteEndpoint>);
+/** Options shared by all remote browser plugins. */
+export interface RemoteBrowserOptions {
+    /**
+     * The remote browser endpoint: a static URL, a function returning one per launch, or a
+     * {@link RemoteBrowserProvider} instance encapsulating a session create/release lifecycle.
+     */
+    endpoint: RemoteBrowserEndpoint | RemoteBrowserProvider<any>;
+    /**
+     * Cleanup callback invoked when the browser disconnects or the connection fails right after the endpoint
+     * resolved. Receives the `context` returned by a function endpoint. Errors are caught and logged. Ignored
+     * when `endpoint` is a {@link RemoteBrowserProvider} (its own `release()` is used instead).
+     */
+    release?: (info: {
+        endpoint: string;
+        context?: Record<string, unknown>;
+    }) => unknown;
+    /** Extra options forwarded to the library `connect()` call (endpoint excluded). */
+    connectOptions?: Record<string, unknown>;
+}
+/**
+ * Resolves `endpoint` for one launch, runs the library-specific `connect`, and ties the session's `release` to
+ * the browser's `disconnected` event. On connect failure the session is released and the error is wrapped in a
+ * {@link BrowserLaunchError}.
+ *
+ * @internal
+ */
+export declare function connectRemoteBrowser<Browser extends {
+    on(event: 'disconnected', listener: () => void): unknown;
+}>(options: RemoteBrowserOptions, proxyUrl: string | undefined, log: CrawleeLogger, connect: (url: string) => Promise<Browser>): Promise<Browser>;

package/remote-browser-plugin.js

@@ -0,0 +1,63 @@
+import { BrowserLaunchError } from './abstract-classes/browser-plugin.js';
+import { RemoteBrowserProvider } from './remote-browser-provider.js';
+import { sanitizeEndpointForLog } from './utils.js';
+/**
+ * Resolves `endpoint` for one launch, runs the library-specific `connect`, and ties the session's `release` to
+ * the browser's `disconnected` event. On connect failure the session is released and the error is wrapped in a
+ * {@link BrowserLaunchError}.
+ *
+ * @internal
+ */
+export async function connectRemoteBrowser(options, proxyUrl, log, connect) {
+    let resolved;
+    try {
+        resolved = await resolveEndpoint(options.endpoint, proxyUrl);
+    }
+    catch (cause) {
+        throw new BrowserLaunchError('Failed to resolve the remote browser endpoint.', { cause });
+    }
+    let released = false;
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        try {
+            if (options.endpoint instanceof RemoteBrowserProvider) {
+                await options.endpoint.release(resolved.context ?? {});
+            }
+            else {
+                await options.release?.({ endpoint: resolved.url, context: resolved.context });
+            }
+        }
+        catch (err) {
+            log.warning('Remote browser release() failed.', { error: err?.message });
+        }
+    };
+    let browser;
+    try {
+        browser = await connect(resolved.url);
+    }
+    catch (cause) {
+        await release();
+        throw new BrowserLaunchError(`Failed to connect to remote browser at "${sanitizeEndpointForLog(resolved.url)}". ` +
+            'Check that the endpoint is reachable and accepts the configured protocol.', { cause });
+    }
+    browser.on('disconnected', release);
+    return browser;
+}
+async function resolveEndpoint(endpoint, proxyUrl) {
+    const resolved = endpoint instanceof RemoteBrowserProvider
+        ? await endpoint.connect({ proxyUrl })
+        : typeof endpoint === 'function'
+            ? await endpoint({ proxyUrl })
+            : endpoint;
+    if (typeof resolved === 'string') {
+        if (!resolved)
+            throw new Error('Remote browser endpoint resolved to an empty string.');
+        return { url: resolved };
+    }
+    if (!resolved?.url) {
+        throw new Error("Remote browser endpoint() must return a URL string or an object with a non-empty 'url'.");
+    }
+    return resolved;
+}

package/remote-browser-provider.d.ts

@@ -2,20 +2,18 @@
  * Abstract base class for remote browser service providers.
  *
  * Implement this class to encapsulate the lifecycle of a remote browser session
- * (creation, connection URL resolution, and cleanup). {@link RemoteBrowserPool}
- * calls {@link connect} once per browser launch and {@link release} when the browser
- * closes, crashes, the pool is destroyed, or the connection fails during launch.
+ * (creation, connection URL resolution, and cleanup). A remote browser plugin
+ * ({@link RemotePlaywrightPlugin}, {@link RemotePuppeteerPlugin}) calls {@link connect}
+ * once per browser launch and {@link release} when the browser disconnects or the connection
+ * fails during launch.
  *
- * Pass the provider instance as the `endpoint` of a {@link RemoteBrowserPool}, then
- * hand the pool to a crawler via its `browserPool` option:
+ * Pass the provider instance as the `endpoint` of a remote plugin, or as the crawler's
+ * `remoteBrowser.endpoint`:
  *
  * ```typescript
- * const browserPool = new RemoteBrowserPool({
- *     browserPlugins: [new PlaywrightPlugin(playwright.chromium)],
- *     endpoint: new MyProvider(),
+ * const crawler = new PlaywrightCrawler({
+ *     remoteBrowser: { endpoint: new MyProvider() },
  * });
- *
- * const crawler = new PlaywrightCrawler({ browserPool });
  * ```
  *
  * **Example — simple static endpoint (e.g. Browserless):**

package/remote-browser-provider.js

@@ -2,20 +2,18 @@
  * Abstract base class for remote browser service providers.
  *
  * Implement this class to encapsulate the lifecycle of a remote browser session
- * (creation, connection URL resolution, and cleanup). {@link RemoteBrowserPool}
- * calls {@link connect} once per browser launch and {@link release} when the browser
- * closes, crashes, the pool is destroyed, or the connection fails during launch.
+ * (creation, connection URL resolution, and cleanup). A remote browser plugin
+ * ({@link RemotePlaywrightPlugin}, {@link RemotePuppeteerPlugin}) calls {@link connect}
+ * once per browser launch and {@link release} when the browser disconnects or the connection
+ * fails during launch.
  *
- * Pass the provider instance as the `endpoint` of a {@link RemoteBrowserPool}, then
- * hand the pool to a crawler via its `browserPool` option:
+ * Pass the provider instance as the `endpoint` of a remote plugin, or as the crawler's
+ * `remoteBrowser.endpoint`:
  *
  * ```typescript
- * const browserPool = new RemoteBrowserPool({
- *     browserPlugins: [new PlaywrightPlugin(playwright.chromium)],
- *     endpoint: new MyProvider(),
+ * const crawler = new PlaywrightCrawler({
+ *     remoteBrowser: { endpoint: new MyProvider() },
  * });
- *
- * const crawler = new PlaywrightCrawler({ browserPool });
  * ```
  *
  * **Example — simple static endpoint (e.g. Browserless):**

package/remote-browser-pool.d.ts

@@ -1,170 +0,0 @@
-import type { IBrowserPool, NewPageOptions, PageState } from '@crawlee/types';
-import type { BrowserPlugin } from './abstract-classes/browser-plugin.js';
-import { BrowserPool } from './browser-pool.js';
-import type { BrowserPoolHooks, BrowserPoolOptions } from './browser-pool.js';
-import { RemoteBrowserProvider } from './remote-browser-provider.js';
-/**
- * The result of resolving a remote browser endpoint: the URL to connect to plus an optional opaque
- * `context` object that is handed back to `release`.
- */
-export interface ResolvedRemoteEndpoint {
-    /** The browser endpoint URL to connect to. */
-    url: string;
-    /** Opaque metadata passed back to `release()` — e.g. session IDs, API tokens. */
-    context?: Record<string, unknown>;
-}
-/**
- * A remote browser endpoint: either a static URL string, or a function called once per browser launch
- * that returns a URL (optionally with a `context` for `release`).
- *
- * The function receives the `proxyUrl` resolved by Crawlee's proxy configuration for the launch, so it
- * can forward it to the remote service's proxy API.
- */
-export type RemoteBrowserEndpoint = string | ((options?: {
-    proxyUrl?: string;
-}) => string | ResolvedRemoteEndpoint | Promise<string | ResolvedRemoteEndpoint>);
-/**
- * The bridge a {@link RemoteBrowserPool} injects into a {@link BrowserPlugin} so the plugin can
- * connect to a remote browser without owning any remote-session policy.
- *
- * The plugin only knows how to make the library-specific `connect()` call; everything else — resolving
- * the endpoint, calling the user's `release()`, and guaranteeing release fires at most once — lives in
- * the pool. The plugin calls {@link RemoteConnection.resolve|resolve} before connecting, stores the
- * returned `token` on its launch context, and the controller later calls
- * {@link RemoteConnection.release|release} with that token when the browser closes.
- */
-export interface RemoteConnection {
-    /** Resolves the endpoint for a single browser launch. The `token` identifies the session for release. */
-    resolve(options?: {
-        proxyUrl?: string;
-    }): Promise<{
-        url: string;
-        token: number;
-    }>;
-    /** Releases the remote session for `token`. Idempotent — safe to call from both `close()` and `kill()`. */
-    release(token: number): Promise<void>;
-}
-/**
- * Per-plugin remote connection parameters, passed to {@link BrowserPlugin.useRemoteConnection}.
- * The endpoint is supplied per-launch via {@link RemoteConnection}; these are the static connect()
- * parameters (protocol, headers, timeouts, …).
- */
-export interface RemoteConnectionParameters {
-    /**
-     * Playwright only: which protocol to connect with. `'cdp'` uses `connectOverCDP()` (the default),
-// @ts-ignore optional peer dependency or compatibility with es2022
-     * `'playwright'` uses `connect()` (Playwright's own WebSocket protocol). Ignored by Puppeteer.
-     */
-    protocol?: 'cdp' | 'playwright';
-    /** Extra options forwarded to the library `connect()` / `connectOverCDP()` call (endpoint excluded). */
-    connectOptions?: Record<string, unknown>;
-}
-export interface RemoteBrowserPoolOptions {
-    /**
-     * The browser plugin(s) used to connect to the remote service — e.g. `new PlaywrightPlugin(playwright.chromium)`
-     * or `new PuppeteerPlugin(puppeteer)`. The pool configures them for remote connection; do not set a local
-     * `launchOptions` on them.
-     */
-    browserPlugins: BrowserPlugin[];
-    /**
-     * The remote browser endpoint: a static URL, a function returning one per launch, or a
-     * {@link RemoteBrowserProvider} instance encapsulating a session create/release lifecycle.
-     */
-    endpoint: RemoteBrowserEndpoint | RemoteBrowserProvider<any>;
-    /**
-     * Cleanup callback invoked when a browser closes, crashes, or the pool is destroyed. Receives the
-     * `context` returned by a function endpoint. Errors are caught and logged. Ignored when `endpoint`
-     * is a {@link RemoteBrowserProvider} (its own `release()` is used instead).
-     */
-    release?: (info: {
-        endpoint: string;
-        context?: Record<string, unknown>;
-    }) => unknown;
-    /**
-     * Maximum number of remote browsers open at once. When reached, {@link RemoteBrowserPool.newPage|newPage}
-     * waits for a browser to close before connecting a new one. Set it to your service's concurrent-session limit
-     * to avoid `429` errors. Defaults to the {@link RemoteBrowserProvider.maxOpenBrowsers|provider's value}, or
-     * `Infinity`.
-     */
-    maxOpenBrowsers?: number;
-    /** Static connect() parameters (Playwright protocol selection, headers, timeouts, …). */
-    connection?: RemoteConnectionParameters;
-    /** Extra {@link BrowserPool} options (lifecycle hooks, page limits, fingerprinting, …). */
-    browserPoolOptions?: Omit<BrowserPoolOptions, 'browserPlugins'> & BrowserPoolHooks<any, any, any>;
-    /**
-     * Fallback poll interval (ms) while waiting for a free browser slot. The wait is event-driven; this only bounds it.
-     * @default 500
-     * @internal
-     */
-    slotPollIntervalMillis?: number;
-}
-/**
- * The remote-connection configuration a browser crawler accepts on its `remoteBrowser` option: the
- * {@link RemoteBrowserPoolOptions} minus the `browserPlugins` (the crawler builds the correct one for its
- * browser, which is what makes this path mismatch-proof) and minus `browserPoolOptions` — tuning the wrapping
- * pool means building the pool yourself, through the `remote*BrowserPool()` factory for your crawler.
- */
-export type CrawlerRemoteBrowserOptions = Omit<RemoteBrowserPoolOptions, 'browserPlugins' | 'browserPoolOptions'>;
-/**
- * An {@link IBrowserPool} implementation for remote browser services.
- *
- * Unlike configuring a remote browser through a crawler's `launchContext`, this pool is the single owner
- * of all remote-session concerns:
- * - **endpoint resolution** — static URL, per-launch function, or {@link RemoteBrowserProvider};
- * - **release lifecycle** — `release()` fires exactly once per session on close/crash/teardown (no leaks,
- *   no double-release);
- * - **concurrency** — {@link RemoteBrowserPoolOptions.maxOpenBrowsers|maxOpenBrowsers} is enforced inside
- *   {@link RemoteBrowserPool.newPage|newPage}, which waits for a free slot rather than overshooting.
- *
- * The wrapped {@link BrowserPool} and its plugin only perform the library-specific `connect()` call.
- *
- * Pass an instance as the crawler's `browserPool` option:
- *
- * ```typescript
- * import { PlaywrightPlugin, RemoteBrowserPool } from '@crawlee/browser-pool';
- * import { PlaywrightCrawler } from 'crawlee';
-// @ts-ignore optional peer dependency or compatibility with es2022
- * import playwright from 'playwright';
- *
- * const browserPool = new RemoteBrowserPool({
- *     browserPlugins: [new PlaywrightPlugin(playwright.chromium)],
- *     endpoint: 'wss://production-sfo.browserless.io?token=xxx',
- *     maxOpenBrowsers: 2,
- * });
- *
- * const crawler = new PlaywrightCrawler({ browserPool });
- * ```
- *
- * @category Browser management
- */
-export declare class RemoteBrowserPool<Page = unknown> implements IBrowserPool<Page> {
-    #private;
-    /**
-     * The wrapped pool that performs the remote connections and serves pages.
-     *
-     * @internal
-     */
-    readonly browserPool: BrowserPool;
-    constructor(options: RemoteBrowserPoolOptions);
-    /** Maximum number of remote browsers that may be open at the same time. */
-    get maxOpenBrowsers(): number;
-    set maxOpenBrowsers(value: number);
-    /**
-     * Opens a new page, waiting first until {@link RemoteBrowserPoolOptions.maxOpenBrowsers|maxOpenBrowsers}
-     * allows it (either a new browser slot is free, or an active browser still has page capacity).
-     */
-    newPage(options?: NewPageOptions): Promise<Page>;
-    closePage(page: Page, options?: {
-        error?: Error;
-    }): Promise<void>;
-    extractPageState(page: Page): Promise<PageState>;
-    injectPageState(page: Page, state: PageState): Promise<void>;
-    /**
-     * Closes all browsers and releases their remote sessions, leaving the pool usable. Closing a browser is what
-     * releases its session (see the constructor), so this needs no separate release pass.
-     */
-    releaseAllBrowsers(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-    /** Closes all browsers, releases any still-open remote sessions, and tears down the wrapped pool. */
-    destroy(): Promise<void>;
-}