brave-real-puppeteer-core 24.25.0 → 24.33.0-patch.1

package/src/bidi/Browser.ts

@@ -14,6 +14,10 @@ import {
   BrowserEvent,
   type BrowserCloseCallback,
   type BrowserContextOptions,
+  type ScreenInfo,
+  type AddScreenParams,
+  type WindowBounds,
+  type WindowId,
   type DebugInfo,
 } from '../api/Browser.js';
 import {BrowserContextEvent} from '../api/BrowserContext.js';
@@ -22,6 +26,7 @@ import type {Target} from '../api/Target.js';
 import type {Connection as CdpConnection} from '../cdp/Connection.js';
 import type {SupportedWebDriverCapabilities} from '../common/ConnectOptions.js';
 import {ProtocolError} from '../common/Errors.js';
+import {UnsupportedOperation} from '../common/Errors.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {debugError} from '../common/util.js';
 import type {Viewport} from '../common/Viewport.js';
@@ -89,6 +94,8 @@ export class BidiBrowser extends Browser {
         // yet because WebDriver BiDi behavior is not specified. See
         // https://github.com/w3c/webdriver-bidi/issues/321.
         'goog:prerenderingDisabled': true,
+        // TODO: remove after Puppeteer rolled Chrome to 142 after Oct 28, 2025.
+        'goog:disableNetworkDurableMessages': true,
       },
     });
 
@@ -109,20 +116,28 @@ export class BidiBrowser extends Browser {
       }) as [string, ...string[]],
     );
 
-    try {
-      await session.send('network.addDataCollector', {
-        dataTypes: [Bidi.Network.DataType.Response],
-        // Buffer size of 20 MB is equivalent to the CDP:
-        maxEncodedDataSize: 20 * 1000 * 1000, // 20 MB
-      });
-    } catch (err) {
-      if (err instanceof ProtocolError) {
-        // Ignore protocol errors, as the data collectors can be not implemented.
-        debugError(err);
-      } else {
-        throw err;
-      }
-    }
+    await Promise.all(
+      [Bidi.Network.DataType.Request, Bidi.Network.DataType.Response].map(
+        // Data collectors might be not implemented for specific data type, so create them
+        // separately and ignore protocol errors.
+        async dataType => {
+          try {
+            await session.send('network.addDataCollector', {
+              dataTypes: [dataType],
+              // Buffer size of 20 MB is equivalent to the CDP:
+              maxEncodedDataSize: 20_000_000,
+            });
+          } catch (err) {
+            if (err instanceof ProtocolError) {
+              debugError(err);
+            } else {
+              throw err;
+            }
+          }
+        },
+      ),
+    );
+
     const browser = new BidiBrowser(session.browser, opts);
     browser.#initialize();
     return browser;
@@ -279,6 +294,29 @@ export class BidiBrowser extends Browser {
     await this.#browserCore.uninstallExtension(id);
   }
 
+  override screens(): Promise<ScreenInfo[]> {
+    throw new UnsupportedOperation();
+  }
+
+  override addScreen(_params: AddScreenParams): Promise<ScreenInfo> {
+    throw new UnsupportedOperation();
+  }
+
+  override removeScreen(_screenId: string): Promise<void> {
+    throw new UnsupportedOperation();
+  }
+
+  override getWindowBounds(_windowId: WindowId): Promise<WindowBounds> {
+    throw new UnsupportedOperation();
+  }
+
+  override setWindowBounds(
+    _windowId: WindowId,
+    _windowBounds: WindowBounds,
+  ): Promise<void> {
+    throw new UnsupportedOperation();
+  }
+
   override targets(): Target[] {
     return [
       this.#target,

package/src/bidi/BrowserConnector.ts

@@ -10,6 +10,7 @@ import type {ConnectionTransport} from '../common/ConnectionTransport.js';
 import type {ConnectOptions} from '../common/ConnectOptions.js';
 import {ProtocolError, UnsupportedOperation} from '../common/Errors.js';
 import {debugError, DEFAULT_VIEWPORT} from '../common/util.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import type {BidiBrowser} from './Browser.js';
 import type {BidiConnection} from './Connection.js';
@@ -66,12 +67,17 @@ async function getBiDiConnection(
   closeCallback: BrowserCloseCallback;
 }> {
   const BiDi = await import(/* webpackIgnore: true */ './bidi.js');
-  const {slowMo = 0, protocolTimeout} = options;
+  const {
+    slowMo = 0,
+    protocolTimeout,
+    idGenerator = createIncrementalIdGenerator(),
+  } = options;
 
   // Try pure BiDi first.
   const pureBidiConnection = new BiDi.BidiConnection(
     url,
     connectionTransport,
+    idGenerator,
     slowMo,
     protocolTimeout,
   );
@@ -102,6 +108,7 @@ async function getBiDiConnection(
     slowMo,
     protocolTimeout,
     /* rawErrors= */ true,
+    idGenerator,
   );
 
   const version = await cdpConnection.send('Browser.getVersion');

package/src/bidi/BrowserContext.ts

@@ -6,7 +6,7 @@
 
 import * as Bidi from 'webdriver-bidi-protocol';
 
-import type {Permission} from '../api/Browser.js';
+import type {CreatePageOptions, Permission} from '../api/Browser.js';
 import {WEB_PERMISSION_TO_PROTOCOL_PERMISSION} from '../api/Browser.js';
 import type {BrowserContextEvents} from '../api/BrowserContext.js';
 import {BrowserContext, BrowserContextEvent} from '../api/BrowserContext.js';
@@ -181,12 +181,15 @@ export class BidiBrowserContext extends BrowserContext {
     });
   }
 
-  override async newPage(): Promise<Page> {
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
     using _guard = await this.waitForScreenshotOperations();
 
-    const context = await this.userContext.createBrowsingContext(
-      Bidi.BrowsingContext.CreateType.Tab,
-    );
+    const type =
+      options?.type === 'window'
+        ? Bidi.BrowsingContext.CreateType.Window
+        : Bidi.BrowsingContext.CreateType.Tab;
+
+    const context = await this.userContext.createBrowsingContext(type);
     const page = this.#pages.get(context)!;
     if (!page) {
       throw new Error('Page is not found');
@@ -221,7 +224,7 @@ export class BidiBrowserContext extends BrowserContext {
     return this.#browser;
   }
 
-  override async pages(): Promise<BidiPage[]> {
+  override async pages(_includeAll = false): Promise<BidiPage[]> {
     return [...this.userContext.browsingContexts].map(context => {
       return this.#pages.get(context)!;
     });

package/src/bidi/Connection.ts

@@ -14,6 +14,7 @@ import {ConnectionClosedError} from '../common/Errors.js';
 import type {EventsWithWildcard} from '../common/EventEmitter.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {debugError} from '../common/util.js';
+import type {GetIdFn} from '../util/incremental-id-generator.js';
 
 import {BidiCdpSession} from './CDPSession.js';
 import type {
@@ -57,12 +58,13 @@ export class BidiConnection
   #delay: number;
   #timeout = 0;
   #closed = false;
-  #callbacks = new CallbackRegistry();
+  #callbacks: CallbackRegistry;
   #emitters: Array<EventEmitter<any>> = [];
 
   constructor(
     url: string,
     transport: ConnectionTransport,
+    idGenerator: GetIdFn,
     delay = 0,
     timeout?: number,
   ) {
@@ -70,6 +72,7 @@ export class BidiConnection
     this.#url = url;
     this.#delay = delay;
     this.#timeout = timeout ?? 180_000;
+    this.#callbacks = new CallbackRegistry(idGenerator);
 
     this.#transport = transport;
     this.#transport.onmessage = this.onMessage.bind(this);
@@ -88,10 +91,26 @@ export class BidiConnection
     this.#emitters.push(emitter);
   }
 
+  #toWebDriverOnlyEvent(event: Record<string, any>) {
+    for (const key in event) {
+      if (key.startsWith('goog:')) {
+        delete event[key];
+      } else {
+        if (typeof event[key] === 'object' && event[key] !== null) {
+          this.#toWebDriverOnlyEvent(event[key]);
+        }
+      }
+    }
+  }
+
   override emit<Key extends keyof EventsWithWildcard<BidiEvents>>(
     type: Key,
     event: EventsWithWildcard<BidiEvents>[Key],
   ): boolean {
+    if (process.env['PUPPETEER_WEBDRIVER_BIDI_ONLY'] === 'true') {
+      // Required for WebDriver-only testing.
+      this.#toWebDriverOnlyEvent(event);
+    }
     for (const emitter of this.#emitters) {
       emitter.emit(type, event);
     }

package/src/bidi/DeviceRequestPrompt.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as Bidi from 'webdriver-bidi-protocol';
+
+import {
+  DeviceRequestPrompt,
+  type DeviceRequestPromptDevice,
+} from '../api/DeviceRequestPrompt.js';
+import {UnsupportedOperation} from '../common/Errors.js';
+import {Deferred} from '../util/Deferred.js';
+
+import type {Session} from './core/Session.js';
+
+/**
+ * @internal
+ */
+export class BidiDeviceRequestPromptManager {
+  readonly #session: Session;
+  readonly #contextId: string;
+  #enabled = false;
+
+  constructor(contextId: string, session: Session) {
+    this.#session = session;
+    this.#contextId = contextId;
+  }
+
+  async #enableIfNeeded(): Promise<void> {
+    if (!this.#enabled) {
+      this.#enabled = true;
+      await this.#session.subscribe(
+        ['bluetooth.requestDevicePromptUpdated'],
+        [this.#contextId],
+      );
+    }
+  }
+
+  async waitForDevicePrompt(
+    timeout: number,
+    signal: AbortSignal | undefined,
+  ): Promise<DeviceRequestPrompt> {
+    const deferred = Deferred.create<DeviceRequestPrompt>({
+      message: `Waiting for \`DeviceRequestPrompt\` failed: ${timeout}ms exceeded`,
+      timeout,
+    });
+
+    const onRequestDevicePromptUpdated = (
+      params: Bidi.Bluetooth.RequestDevicePromptUpdatedParameters,
+    ) => {
+      if (params.context === this.#contextId) {
+        deferred.resolve(
+          new BidiDeviceRequestPrompt(
+            this.#contextId,
+            params.prompt,
+            this.#session,
+            params.devices,
+          ),
+        );
+        this.#session.off(
+          'bluetooth.requestDevicePromptUpdated',
+          onRequestDevicePromptUpdated,
+        );
+      }
+    };
+    this.#session.on(
+      'bluetooth.requestDevicePromptUpdated',
+      onRequestDevicePromptUpdated,
+    );
+
+    if (signal) {
+      signal.addEventListener(
+        'abort',
+        () => {
+          deferred.reject(signal.reason);
+        },
+        {once: true},
+      );
+    }
+
+    await this.#enableIfNeeded();
+
+    return await deferred.valueOrThrow();
+  }
+}
+
+/**
+ * @internal
+ */
+export class BidiDeviceRequestPrompt extends DeviceRequestPrompt {
+  readonly #session: Session;
+  #promptId: string;
+  #contextId: string;
+
+  constructor(
+    contextId: string,
+    promptId: string,
+    session: Session,
+    devices: Bidi.Bluetooth.RequestDeviceInfo[],
+  ) {
+    super();
+    this.#session = session;
+    this.#promptId = promptId;
+    this.#contextId = contextId;
+
+    this.devices.push(
+      ...devices.map(d => {
+        return {
+          id: d.id,
+          name: d.name ?? 'UNKNOWN',
+        };
+      }),
+    );
+  }
+
+  async cancel(): Promise<void> {
+    await this.#session.send('bluetooth.handleRequestDevicePrompt', {
+      context: this.#contextId,
+      prompt: this.#promptId,
+      accept: false,
+    });
+  }
+
+  async select(device: DeviceRequestPromptDevice): Promise<void> {
+    await this.#session.send('bluetooth.handleRequestDevicePrompt', {
+      context: this.#contextId,
+      prompt: this.#promptId,
+      accept: true,
+      device: device.id,
+    });
+  }
+
+  waitForDevice(): never {
+    throw new UnsupportedOperation();
+  }
+}

package/src/bidi/Frame.ts

@@ -21,13 +21,14 @@ import {
   switchMap,
 } from '../../third_party/rxjs/rxjs.js';
 import type {CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import {
   Frame,
   throwIfDetached,
   type GoToOptions,
   type WaitForOptions,
 } from '../api/Frame.js';
-import {PageEvent} from '../api/Page.js';
+import {PageEvent, type WaitTimeoutOptions} from '../api/Page.js';
 import {Accessibility} from '../cdp/Accessibility.js';
 import type {ConsoleMessageType} from '../common/ConsoleMessage.js';
 import {
@@ -474,8 +475,11 @@ export class BidiFrame extends Frame {
     );
   }
 
-  override waitForDevicePrompt(): never {
-    throw new UnsupportedOperation();
+  override waitForDevicePrompt(
+    options: WaitTimeoutOptions = {},
+  ): Promise<DeviceRequestPrompt> {
+    const {timeout = this.timeoutSettings.timeout(), signal} = options;
+    return this.browsingContext.waitForDevicePrompt(timeout, signal);
   }
 
   override get detached(): boolean {

package/src/bidi/HTTPRequest.ts

@@ -109,17 +109,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     this.#request.on('authenticate', this.#handleAuthentication);
 
     this.#frame.page().trustedEmitter.emit(PageEvent.Request, this);
-
-    if (this.#hasInternalHeaderOverwrite) {
-      this.interception.handlers.push(async () => {
-        await this.continue(
-          {
-            headers: this.headers(),
-          },
-          0,
-        );
-      });
-    }
   }
 
   protected canBeIntercepted(): boolean {
@@ -158,40 +147,21 @@ export class BidiHTTPRequest extends HTTPRequest {
   }
 
   override hasPostData(): boolean {
-    if (!this.#frame.page().browser().cdpSupported) {
-      throw new UnsupportedOperation();
-    }
     return this.#request.hasPostData;
   }
 
   override async fetchPostData(): Promise<string | undefined> {
-    throw new UnsupportedOperation();
-  }
-
-  get #hasInternalHeaderOverwrite(): boolean {
-    return Boolean(
-      Object.keys(this.#extraHTTPHeaders).length ||
-        Object.keys(this.#userAgentHeaders).length,
-    );
-  }
-
-  get #extraHTTPHeaders(): Record<string, string> {
-    return this.#frame?.page()._extraHTTPHeaders ?? {};
-  }
-
-  get #userAgentHeaders(): Record<string, string> {
-    return this.#frame?.page()._userAgentHeaders ?? {};
+    return await this.#request.fetchPostData();
   }
 
   override headers(): Record<string, string> {
+    // Callers should not be allowed to mutate internal structure.
     const headers: Record<string, string> = {};
     for (const header of this.#request.headers) {
       headers[header.name.toLowerCase()] = header.value.value;
     }
     return {
       ...headers,
-      ...this.#extraHTTPHeaders,
-      ...this.#userAgentHeaders,
     };
   }
 
@@ -225,19 +195,6 @@ export class BidiHTTPRequest extends HTTPRequest {
     return this.#frame;
   }
 
-  override async continue(
-    overrides?: ContinueRequestOverrides,
-    priority?: number | undefined,
-  ): Promise<void> {
-    return await super.continue(
-      {
-        headers: this.#hasInternalHeaderOverwrite ? this.headers() : undefined,
-        ...overrides,
-      },
-      priority,
-    );
-  }
-
   override async _continue(
     overrides: ContinueRequestOverrides = {},
   ): Promise<void> {