@crawlee/browser-pool 4.0.0-beta.12 → 4.0.0-beta.121

package/fingerprinting/utils.js

@@ -1,10 +1,10 @@
 import { PlaywrightPlugin } from '../playwright/playwright-plugin.js';
 import { PuppeteerPlugin } from '../puppeteer/puppeteer-plugin.js';
-import { BrowserName } from './types.js';
+import { BrowserName, DeviceCategory, OperatingSystemsName } from './types.js';
 export const getGeneratorDefaultOptions = (launchContext) => {
     const { browserPlugin, launchOptions } = launchContext;
     const options = {
-        devices: ["desktop" /* DeviceCategory.desktop */],
+        devices: [DeviceCategory.desktop],
         locales: ['en-US'],
         browsers: [getBrowserName(browserPlugin, launchOptions)],
         operatingSystems: [getOperatingSystem()],
@@ -34,12 +34,11 @@ const getOperatingSystem = () => {
     switch (platform) {
         case 'win32':
             // platform is win32 even for 64-bit
-            return "windows" /* OperatingSystemsName.windows */;
+            return OperatingSystemsName.windows;
         case 'darwin':
-            return "macos" /* OperatingSystemsName.macos */;
+            return OperatingSystemsName.macos;
         default:
             // consider everything else a linux
-            return "linux" /* OperatingSystemsName.linux */;
+            return OperatingSystemsName.linux;
     }
 };
-//# sourceMappingURL=utils.js.map

package/index.d.ts

@@ -28,13 +28,20 @@ export * from './browser-pool.js';
 export * from './playwright/playwright-plugin.js';
 export * from './puppeteer/puppeteer-plugin.js';
 export * from './events.js';
-export { BrowserName, DeviceCategory, OperatingSystemsName, } from './fingerprinting/types.js';
-export { BrowserController, BrowserControllerEvents } from './abstract-classes/browser-controller.js';
+export type { BrowserSpecification, FingerprintGenerator, FingerprintGeneratorOptions, GetFingerprintReturn, } 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';
 export { PuppeteerController } from './puppeteer/puppeteer-controller.js';
 export { PlaywrightController } from './playwright/playwright-controller.js';
 export { PlaywrightBrowser } from './playwright/playwright-browser.js';
-export { CommonPage, CommonLibrary, BrowserPlugin, BrowserPluginOptions, CreateLaunchContextOptions, BrowserLaunchError, DEFAULT_USER_AGENT, } from './abstract-classes/browser-plugin.js';
-export { LaunchContext, LaunchContextOptions } from './launch-context.js';
-export { BrowserSpecification, FingerprintGenerator, FingerprintGeneratorOptions, GetFingerprintReturn, } from './fingerprinting/types.js';
-export { InferBrowserPluginArray, UnwrapPromise } from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+export type { CommonPage, CommonLibrary, BrowserPluginOptions, CreateLaunchContextOptions, } from './abstract-classes/browser-plugin.js';
+export { BrowserPlugin, BrowserLaunchError, DEFAULT_USER_AGENT } from './abstract-classes/browser-plugin.js';
+export type { LaunchContextOptions } from './launch-context.js';
+export { LaunchContext } from './launch-context.js';
+export { RemoteBrowserProvider } from './remote-browser-provider.js';
+export { RemoteBrowserPool } from './remote-browser-pool.js';
+export type { RemoteBrowserPoolOptions, CrawlerRemoteBrowserOptions, RemoteBrowserEndpoint, ResolvedRemoteEndpoint, RemoteConnection, RemoteConnectionParameters, } from './remote-browser-pool.js';
+export type { InferBrowserPluginArray, UnwrapPromise } from './utils.js';
+export { anonymizeProxySugar, type AnonymizeProxySugarOptions } from './anonymize-proxy.js';
+export type { IBrowserPool, NewPageOptions } from '@crawlee/types';

package/index.js

@@ -26,11 +26,13 @@ export * from './browser-pool.js';
 export * from './playwright/playwright-plugin.js';
 export * from './puppeteer/puppeteer-plugin.js';
 export * from './events.js';
-export { BrowserName, DeviceCategory, OperatingSystemsName, } from './fingerprinting/types.js';
+export { BrowserName, DeviceCategory, OperatingSystemsName } from './fingerprinting/types.js';
 export { BrowserController } from './abstract-classes/browser-controller.js';
 export { PuppeteerController } from './puppeteer/puppeteer-controller.js';
 export { PlaywrightController } from './playwright/playwright-controller.js';
 export { PlaywrightBrowser } from './playwright/playwright-browser.js';
-export { BrowserPlugin, BrowserLaunchError, DEFAULT_USER_AGENT, } from './abstract-classes/browser-plugin.js';
+export { BrowserPlugin, BrowserLaunchError, DEFAULT_USER_AGENT } from './abstract-classes/browser-plugin.js';
 export { LaunchContext } from './launch-context.js';
-//# sourceMappingURL=index.js.map
+export { RemoteBrowserProvider } from './remote-browser-provider.js';
+export { RemoteBrowserPool } from './remote-browser-pool.js';
+export { anonymizeProxySugar } from './anonymize-proxy.js';

package/launch-context.d.ts

@@ -43,19 +43,35 @@ export interface LaunchContextOptions<Library extends CommonLibrary = CommonLibr
      */
     userDataDir?: string;
     proxyUrl?: string;
-    proxyTier?: number;
+    /**
+     * If set to `true`, TLS certificate errors from the upstream proxy will be ignored.
+     * This is useful when using HTTPS proxies with self-signed certificates.
+     */
+    ignoreProxyCertificate?: boolean;
+    /**
+     * Whether this launch context represents a connection to a remote browser
+     * rather than a locally launched one.
+     * @default false
+     */
+    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;
     useIncognitoPages: boolean;
     browserPerProxy?: boolean;
     userDataDir: string;
-    proxyTier?: number;
-    private _proxyUrl?;
-    private readonly _reservedFieldNames;
+    readonly isRemote: boolean;
+    ignoreProxyCertificate?: boolean;
     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;
     [K: PropertyKey]: unknown;
     constructor(options: LaunchContextOptions<Library, LibraryOptions, LaunchResult, NewPageOptions, NewPageResult>);
     /**
@@ -76,4 +92,3 @@ export declare class LaunchContext<Library extends CommonLibrary = CommonLibrary
      */
     get proxyUrl(): string | undefined;
 }
-//# sourceMappingURL=launch-context.d.ts.map

package/launch-context.js

@@ -5,20 +5,31 @@ export class LaunchContext {
     useIncognitoPages;
     browserPerProxy;
     userDataDir;
-    proxyTier;
-    _proxyUrl;
-    _reservedFieldNames = [...Reflect.ownKeys(this), 'extend'];
+    isRemote;
+    ignoreProxyCertificate;
+    #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;
     constructor(options) {
-        const { id, browserPlugin, launchOptions, proxyUrl, useIncognitoPages, browserPerProxy, userDataDir = '', proxyTier, } = options;
+        const { id, browserPlugin, launchOptions, proxyUrl, useIncognitoPages, browserPerProxy, userDataDir = '', ignoreProxyCertificate, isRemote, } = options;
         this.id = id;
         this.browserPlugin = browserPlugin;
         this.launchOptions = launchOptions;
         this.browserPerProxy = browserPerProxy ?? false;
         this.useIncognitoPages = useIncognitoPages ?? false;
         this.userDataDir = userDataDir;
-        this.proxyTier = proxyTier;
-        this._proxyUrl = proxyUrl;
+        this.ignoreProxyCertificate = ignoreProxyCertificate ?? false;
+        this.isRemote = isRemote ?? false;
+        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.
@@ -29,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 {
@@ -43,6 +54,7 @@ export class LaunchContext {
      */
     set proxyUrl(url) {
         if (!url) {
+            this.#proxyUrl = undefined;
             return;
         }
         const urlInstance = new URL(url);
@@ -50,13 +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;
     }
 }
-//# sourceMappingURL=launch-context.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/browser-pool",
-    "version": "4.0.0-beta.12",
+    "version": "4.0.0-beta.121",
     "description": "Rotate multiple browsers using popular automation libraries such as Playwright or Puppeteer.",
     "engines": {
         "node": ">=22.0.0"
@@ -24,18 +24,17 @@
         "url": "https://github.com/apify/crawlee/issues"
     },
     "scripts": {
-        "build": "yarn clean && yarn compile && yarn copy",
+        "build": "pnpm clean && pnpm compile && pnpm copy",
         "clean": "rimraf ./dist",
         "compile": "tsc -p tsconfig.build.json",
         "copy": "tsx ../../scripts/copy.ts"
     },
     "dependencies": {
-        "@apify/log": "^2.5.18",
-        "@apify/timeout": "^0.3.2",
-        "@crawlee/core": "4.0.0-beta.12",
-        "@crawlee/types": "4.0.0-beta.12",
-        "fingerprint-generator": "^2.1.66",
-        "fingerprint-injector": "^2.1.66",
+        "@apify/timeout": "^0.4.4",
+        "@crawlee/core": "4.0.0-beta.121",
+        "@crawlee/types": "4.0.0-beta.121",
+        "fingerprint-generator": "^2.1.68",
+        "fingerprint-injector": "^2.1.68",
         "lodash.merge": "^4.6.2",
         "nanoid": "^5.1.5",
         "ow": "^2.0.0",
@@ -64,5 +63,5 @@
             }
         }
     },
-    "gitHead": "06431733e5cfa6cc3a4c105427592f87424037ca"
+    "gitHead": "5027317de626f5ba6de5047ae9341a898258cc5a"
 }

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>;
@@ -28,4 +25,3 @@ export declare class PlaywrightBrowser extends EventEmitter {
     startTracing(): Promise<never>;
     stopTracing(): Promise<never>;
 }
-//# sourceMappingURL=playwright-browser.d.ts.map

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');
@@ -55,4 +55,3 @@ export class PlaywrightBrowser extends EventEmitter {
         throw new Error('Function `stopTracing()` is not available in incognito mode');
     }
 }
-//# sourceMappingURL=playwright-browser.js.map

package/playwright/playwright-controller.d.ts

@@ -11,4 +11,3 @@ export declare class PlaywrightController extends BrowserController<BrowserType,
     protected _getCookies(page: Page): Promise<Cookie[]>;
     protected _setCookies(page: Page, cookies: Cookie[]): Promise<void>;
 }
-//# sourceMappingURL=playwright-controller.d.ts.map

package/playwright/playwright-controller.js

@@ -11,7 +11,7 @@ export class PlaywrightController extends BrowserController {
         const password = decodeURIComponent(url.password);
         return {
             proxy: {
-                server: url.origin,
+                server: `${url.protocol}//${url.host}`,
                 username,
                 password,
                 bypass: pageOptions?.proxy?.bypass,
@@ -23,15 +23,26 @@ export class PlaywrightController extends BrowserController {
             throw new Error('A new page can be created with provided context only when using incognito pages.');
         }
         let close = async () => { };
-        if (this.launchContext.useIncognitoPages && contextOptions?.proxy) {
-            const [anonymizedProxyUrl, closeProxy] = await anonymizeProxySugar(contextOptions.proxy.server, contextOptions.proxy.username, contextOptions.proxy.password);
-            if (anonymizedProxyUrl) {
-                contextOptions.proxy = {
-                    server: anonymizedProxyUrl,
-                    bypass: contextOptions.proxy.bypass,
-                };
+        if (this.launchContext.useIncognitoPages) {
+            // Each page requires to have all the context options applied
+            contextOptions = {
+                ...this.launchContext.launchOptions,
+                ...contextOptions,
+            };
+            // Remote browsers handle their own proxy — don't inject local proxy settings into context
+            if (this.launchContext.isRemote) {
+                delete contextOptions?.proxy;
+            }
+            if (contextOptions?.proxy) {
+                const [anonymizedProxyUrl, closeProxy] = await anonymizeProxySugar(contextOptions.proxy.server, contextOptions.proxy.username, contextOptions.proxy.password, { ignoreProxyCertificate: this.launchContext.ignoreProxyCertificate });
+                if (anonymizedProxyUrl) {
+                    contextOptions.proxy = {
+                        server: anonymizedProxyUrl,
+                        bypass: contextOptions.proxy.bypass,
+                    };
+                }
+                close = closeProxy;
             }
-            close = closeProxy;
         }
         try {
             const page = await this.browser.newPage(contextOptions);
@@ -63,4 +74,3 @@ export class PlaywrightController extends BrowserController {
         return context.addCookies(cookies);
     }
 }
-//# sourceMappingURL=playwright-controller.js.map

package/playwright/playwright-plugin.d.ts

@@ -1,17 +1,20 @@
 // @ts-ignore optional peer dependency or compatibility with es2022
 import type { Browser as PlaywrightBrowser, BrowserType } from 'playwright';
 import { BrowserPlugin } from '../abstract-classes/browser-plugin.js';
-import type { createProxyServerForContainers } from '../container-proxy-server.js';
 import type { LaunchContext } from '../launch-context.js';
+import type { RemoteConnection, RemoteConnectionParameters } from '../remote-browser-pool.js';
 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?;
-    _containerProxyServer?: Awaited<ReturnType<typeof createProxyServerForContainers>>;
+    #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;
 }
-//# sourceMappingURL=playwright-plugin.d.ts.map

package/playwright/playwright-plugin.js

@@ -1,14 +1,35 @@
 import fs from 'node:fs';
 import { BrowserPlugin } from '../abstract-classes/browser-plugin.js';
 import { anonymizeProxySugar } from '../anonymize-proxy.js';
-import { log } from '../logger.js';
 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;
-    _containerProxyServer;
+    #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.
+     */
+    useRemoteConnection(connection, parameters = {}) {
+        super.useRemoteConnection(connection, parameters);
+        if (!this.useIncognitoPages) {
+            this.log.info('Remote Playwright connection — useIncognitoPages forced to true. ' +
+                'Pages will not share cookies/storage between each other; use the SessionPool for shared state.');
+        }
+        this.useIncognitoPages = true;
+    }
     async _launch(launchContext) {
+        if (this.remoteConnection) {
+            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).');
+                    return this.library.connect(url, connectOptions);
+                }
+                this.log.info('Connecting to remote browser via connectOverCDP.');
+                return this.library.connectOverCDP(url, connectOptions);
+            });
+        }
         const { launchOptions, useIncognitoPages, userDataDir, proxyUrl } = launchContext;
         let browser;
         // Required for the `proxy` context option to work.
@@ -20,7 +41,9 @@ export class PlaywrightPlugin extends BrowserPlugin {
         if (this.library.name() === 'webkit') {
             launchOptions.args = launchOptions.args?.filter((arg) => arg !== '--no-sandbox');
         }
-        const [anonymizedProxyUrl, close] = await anonymizeProxySugar(proxyUrl);
+        const [anonymizedProxyUrl, close] = await anonymizeProxySugar(proxyUrl, undefined, undefined, {
+            ignoreProxyCertificate: launchContext.ignoreProxyCertificate,
+        });
         if (anonymizedProxyUrl) {
             launchOptions.proxy = {
                 server: anonymizedProxyUrl,
@@ -30,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 () => {
@@ -42,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-')) {
@@ -57,18 +80,20 @@ 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) => {
-                        log.exception(error, 'Failed to close browser.');
+                        this.log.exception(error, 'Failed to close browser.');
                     });
                 }
-                browser = new PlaywrightBrowserWithPersistentContext({
+                const persistentBrowser = new PlaywrightBrowserWithPersistentContext({
                     browserContext,
-                    version: this._browserVersion,
+                    version: this.#browserVersion,
                 });
+                persistentBrowser.setBrowserType(this.library);
+                browser = persistentBrowser;
             }
         }
         catch (error) {
@@ -77,13 +102,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) {
@@ -95,9 +120,8 @@ export class PlaywrightPlugin extends BrowserPlugin {
             };
         }
     }
-    _isChromiumBasedBrowser() {
+    isChromiumBasedBrowser() {
         const name = this.library.name();
         return name === 'chromium';
     }
 }
-//# sourceMappingURL=playwright-plugin.js.map

package/proxy-server.d.ts

@@ -1,2 +1 @@
 export declare function getLocalProxyAddress(): Promise<string>;
-//# sourceMappingURL=proxy-server.d.ts.map

package/proxy-server.js

@@ -10,4 +10,3 @@ export async function getLocalProxyAddress() {
     await listenPromise;
     return `http://127.0.0.1:${server.port}`;
 }
-//# sourceMappingURL=proxy-server.js.map

package/puppeteer/puppeteer-controller.d.ts

@@ -16,4 +16,3 @@ export declare class PuppeteerController extends BrowserController<typeof Puppet
     protected _getCookies(page: PuppeteerTypes.Page): Promise<Cookie[]>;
     protected _setCookies(page: PuppeteerTypes.Page, cookies: Cookie[]): Promise<void>;
 }
-//# sourceMappingURL=puppeteer-controller.d.ts.map

package/puppeteer/puppeteer-controller.js

@@ -1,7 +1,6 @@
 import { tryCancel } from '@apify/timeout';
 import { BrowserController } from '../abstract-classes/browser-controller.js';
 import { anonymizeProxySugar } from '../anonymize-proxy.js';
-import { log } from '../logger.js';
 const PROCESS_KILL_TIMEOUT_MILLIS = 5000;
 export class PuppeteerController extends BrowserController {
     normalizeProxyOptions(proxyUrl, pageOptions) {
@@ -12,7 +11,7 @@ export class PuppeteerController extends BrowserController {
         const username = decodeURIComponent(url.username);
         const password = decodeURIComponent(url.password);
         return {
-            proxyServer: url.origin,
+            proxyServer: `${url.protocol}//${url.host}`,
             proxyUsername: username,
             proxyPassword: password,
             proxyBypassList: pageOptions?.proxyBypassList,
@@ -25,7 +24,7 @@ export class PuppeteerController extends BrowserController {
             }
             let close = async () => { };
             if (contextOptions.proxyServer) {
-                const [anonymizedProxyUrl, closeProxy] = await anonymizeProxySugar(contextOptions.proxyServer, contextOptions.proxyUsername, contextOptions.proxyPassword);
+                const [anonymizedProxyUrl, closeProxy] = await anonymizeProxySugar(contextOptions.proxyServer, contextOptions.proxyUsername, contextOptions.proxyPassword, { ignoreProxyCertificate: this.launchContext.ignoreProxyCertificate });
                 if (anonymizedProxyUrl) {
                     contextOptions.proxyServer = anonymizedProxyUrl;
                     delete contextOptions.proxyUsername;
@@ -58,7 +57,7 @@ export class PuppeteerController extends BrowserController {
                         await context.close();
                     }
                     catch (error) {
-                        log.exception(error, 'Failed to close context.');
+                        this.log.exception(error, 'Failed to close context.');
                     }
                     finally {
                         await close();
@@ -84,7 +83,7 @@ export class PuppeteerController extends BrowserController {
     async _kill() {
         const browserProcess = this.browser.process();
         if (!browserProcess) {
-            log.debug('Browser was connected using the `puppeteer.connect` method no browser to kill.');
+            this.log.debug('Browser was connected using the `puppeteer.connect` method no browser to kill.');
             return;
         }
         const timeout = setTimeout(() => {
@@ -98,14 +97,22 @@ export class PuppeteerController extends BrowserController {
             clearTimeout(timeout);
         }
         catch (error) {
-            log.debug('Browser was already killed.', { error });
+            this.log.debug('Browser was already killed.', { error });
         }
     }
     async _getCookies(page) {
-        return page.cookies();
+        const cookies = await page.browserContext().cookies();
+        // Puppeteer 25+ can report `sameSite: 'Default'`, which means the attribute is unspecified.
+        return cookies.map(({ sameSite, ...rest }) => ({
+            ...rest,
+            sameSite: sameSite === 'Default' ? undefined : sameSite,
+        }));
     }
     async _setCookies(page, cookies) {
-        return page.setCookie(...cookies);
+        // BrowserContext.setCookie requires `url` or `domain`; the page-level API used to back-fill
+        // the page's current URL for us. Replicate that so callers who pass neither don't get rejected.
+        const pageUrl = page.url();
+        const normalized = cookies.map((cookie) => cookie.url || cookie.domain ? cookie : { ...cookie, url: pageUrl });
+        return page.browserContext().setCookie(...normalized);
     }
 }
-//# sourceMappingURL=puppeteer-controller.js.map

package/puppeteer/puppeteer-plugin.d.ts

@@ -4,12 +4,14 @@ import type Puppeteer from 'puppeteer';
 import type * as PuppeteerTypes from 'puppeteer';
 import { BrowserPlugin } from '../abstract-classes/browser-plugin.js';
 import type { LaunchContext } from '../launch-context.js';
+import type { RemoteConnection, RemoteConnectionParameters } from '../remote-browser-pool.js';
 import type { PuppeteerNewPageOptions } from './puppeteer-controller.js';
 import { PuppeteerController } from './puppeteer-controller.js';
 export declare class PuppeteerPlugin extends BrowserPlugin<typeof Puppeteer, PuppeteerTypes.LaunchOptions, PuppeteerTypes.Browser, PuppeteerNewPageOptions> {
+    /** Pages share cookies/storage on the remote browser (Puppeteer defaults to non-incognito). */
+    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;
 }
-//# sourceMappingURL=puppeteer-plugin.d.ts.map