chrome-devtools-frontend 1.0.1550444 → 1.0.1555174

package/front_end/third_party/puppeteer/package/src/api/Page.ts

@@ -81,6 +81,7 @@ import {
 } from '../util/disposable.js';
 import {stringToTypedArray} from '../util/encoding.js';
 
+import type {BluetoothEmulation} from './BluetoothEmulation.js';
 import type {Browser} from './Browser.js';
 import type {BrowserContext} from './BrowserContext.js';
 import type {CDPSession} from './CDPSession.js';
@@ -3174,6 +3175,11 @@ export abstract class Page extends EventEmitter<PageEvents> {
    * method is only available in Chrome.
    */
   abstract openDevTools(): Promise<Page>;
+
+  /**
+   * {@inheritDoc BluetoothEmulation}
+   */
+  abstract get bluetooth(): BluetoothEmulation;
 }
 
 /**

package/front_end/third_party/puppeteer/package/src/api/api.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+export type * from './BluetoothEmulation.js';
 export * from './Browser.js';
 export * from './BrowserContext.js';
 export * from './CDPSession.js';

package/front_end/third_party/puppeteer/package/src/bidi/BluetoothEmulation.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  AdapterState,
+  BluetoothEmulation,
+  PreconnectedPeripheral,
+} from '../api/BluetoothEmulation.js';
+
+import type {Session} from './core/Session.js';
+
+/**
+ * @internal
+ */
+export class BidiBluetoothEmulation implements BluetoothEmulation {
+  readonly #session: Session;
+  readonly #contextId: string;
+
+  constructor(contextId: string, session: Session) {
+    this.#contextId = contextId;
+    this.#session = session;
+  }
+
+  async emulateAdapter(state: AdapterState, leSupported = true): Promise<void> {
+    await this.#session.send('bluetooth.simulateAdapter', {
+      context: this.#contextId,
+      state,
+      leSupported,
+    });
+  }
+
+  async disableEmulation(): Promise<void> {
+    await this.#session.send('bluetooth.disableSimulation', {
+      context: this.#contextId,
+    });
+  }
+
+  async simulatePreconnectedPeripheral(
+    preconnectedPeripheral: PreconnectedPeripheral,
+  ): Promise<void> {
+    await this.#session.send('bluetooth.simulatePreconnectedPeripheral', {
+      context: this.#contextId,
+      address: preconnectedPeripheral.address,
+      name: preconnectedPeripheral.name,
+      manufacturerData: preconnectedPeripheral.manufacturerData,
+      knownServiceUuids: preconnectedPeripheral.knownServiceUuids,
+    });
+  }
+}

package/front_end/third_party/puppeteer/package/src/bidi/Browser.ts

@@ -14,6 +14,8 @@ import {
   BrowserEvent,
   type BrowserCloseCallback,
   type BrowserContextOptions,
+  type ScreenInfo,
+  type AddScreenParams,
   type DebugInfo,
 } from '../api/Browser.js';
 import {BrowserContextEvent} from '../api/BrowserContext.js';
@@ -22,6 +24,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';
@@ -289,6 +292,18 @@ 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 targets(): Target[] {
     return [
       this.#target,

package/front_end/third_party/puppeteer/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/front_end/third_party/puppeteer/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/front_end/third_party/puppeteer/package/src/bidi/Page.ts

@@ -8,7 +8,9 @@ import type Protocol from 'devtools-protocol';
 import * as Bidi from 'webdriver-bidi-protocol';
 
 import {firstValueFrom, from, raceWith} from '../../third_party/rxjs/rxjs.js';
+import type {BluetoothEmulation} from '../api/BluetoothEmulation.js';
 import type {CDPSession} from '../api/CDPSession.js';
+import type {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
 import type {BoundingBox} from '../api/ElementHandle.js';
 import type {WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
@@ -1010,8 +1012,14 @@ export class BidiPage extends Page {
     }
   }
 
-  override waitForDevicePrompt(): never {
-    throw new UnsupportedOperation();
+  override async waitForDevicePrompt(
+    options: WaitTimeoutOptions = {},
+  ): Promise<DeviceRequestPrompt> {
+    return await this.mainFrame().waitForDevicePrompt(options);
+  }
+
+  override get bluetooth(): BluetoothEmulation {
+    return this.mainFrame().browsingContext.bluetooth;
   }
 }
 

package/front_end/third_party/puppeteer/package/src/bidi/core/BrowsingContext.ts

@@ -6,9 +6,13 @@
 
 import type * as Bidi from 'webdriver-bidi-protocol';
 
+import type {BluetoothEmulation} from '../../api/BluetoothEmulation.js';
+import type {DeviceRequestPrompt} from '../../api/DeviceRequestPrompt.js';
 import {EventEmitter} from '../../common/EventEmitter.js';
 import {inertIfDisposed, throwIfDisposed} from '../../util/decorators.js';
 import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
+import {BidiBluetoothEmulation} from '../BluetoothEmulation.js';
+import {BidiDeviceRequestPromptManager} from '../DeviceRequestPrompt.js';
 
 import type {AddPreloadScriptOptions} from './Browser.js';
 import {Navigation} from './Navigation.js';
@@ -161,9 +165,11 @@ export class BrowsingContext extends EventEmitter<{
   readonly #emulationState: {
     javaScriptEnabled: boolean;
   } = {javaScriptEnabled: true};
+  readonly #bluetoothEmulation: BluetoothEmulation;
+  readonly #deviceRequestPromptManager: BidiDeviceRequestPromptManager;
 
   private constructor(
-    context: UserContext,
+    userContext: UserContext,
     parent: BrowsingContext | undefined,
     id: string,
     url: string,
@@ -174,10 +180,18 @@ export class BrowsingContext extends EventEmitter<{
     this.#url = url;
     this.id = id;
     this.parent = parent;
-    this.userContext = context;
+    this.userContext = userContext;
     this.originalOpener = originalOpener;
 
     this.defaultRealm = this.#createWindowRealm();
+    this.#bluetoothEmulation = new BidiBluetoothEmulation(
+      this.id,
+      this.#session,
+    );
+    this.#deviceRequestPromptManager = new BidiDeviceRequestPromptManager(
+      this.id,
+      this.#session,
+    );
   }
 
   #initialize() {
@@ -757,4 +771,18 @@ export class BrowsingContext extends EventEmitter<{
       contexts: [this.id],
     });
   }
+
+  get bluetooth(): BluetoothEmulation {
+    return this.#bluetoothEmulation;
+  }
+
+  async waitForDevicePrompt(
+    timeout: number,
+    signal?: AbortSignal,
+  ): Promise<DeviceRequestPrompt> {
+    return await this.#deviceRequestPromptManager.waitForDevicePrompt(
+      timeout,
+      signal,
+    );
+  }
 }

package/front_end/third_party/puppeteer/package/src/bidi/util.ts

@@ -17,6 +17,14 @@ import {BidiDeserializer} from './Deserializer.js';
 export function createEvaluationError(
   details: Bidi.Script.ExceptionDetails,
 ): unknown {
+  if (details.exception.type === 'object' && !('value' in details.exception)) {
+    // Heuristic detecting a platform object was thrown. WebDriver BiDi serializes
+    // platform objects without value. If so, throw a generic error with the actual
+    // exception's message, as there is no way to restore the original exception's
+    // constructor.
+    return new Error(details.text);
+  }
+
   if (details.exception.type !== 'error') {
     return BidiDeserializer.deserialize(details.exception);
   }

package/front_end/third_party/puppeteer/package/src/cdp/Accessibility.ts

@@ -618,7 +618,7 @@ class AXNode {
         continue;
       }
       const value = getBooleanPropertyValue(booleanProperty);
-      if (!value) {
+      if (value === undefined) {
         continue;
       }
       node[booleanProperty] = getBooleanPropertyValue(booleanProperty);

package/front_end/third_party/puppeteer/package/src/cdp/BluetoothEmulation.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type {
+  AdapterState,
+  BluetoothEmulation,
+  PreconnectedPeripheral,
+} from '../api/BluetoothEmulation.js';
+
+import type {Connection} from './Connection.js';
+
+/**
+ * @internal
+ */
+export class CdpBluetoothEmulation implements BluetoothEmulation {
+  #connection: Connection;
+
+  constructor(connection: Connection) {
+    this.#connection = connection;
+  }
+
+  async emulateAdapter(state: AdapterState, leSupported = true): Promise<void> {
+    // Bluetooth spec requires overriding the existing adapter (step 6). From the CDP
+    // perspective, it means disabling the emulation first.
+    // https://webbluetoothcg.github.io/web-bluetooth/#bluetooth-simulateAdapter-command
+    await this.#connection.send('BluetoothEmulation.disable');
+    await this.#connection.send('BluetoothEmulation.enable', {
+      state,
+      leSupported,
+    });
+  }
+
+  async disableEmulation(): Promise<void> {
+    await this.#connection.send('BluetoothEmulation.disable');
+  }
+
+  async simulatePreconnectedPeripheral(
+    preconnectedPeripheral: PreconnectedPeripheral,
+  ): Promise<void> {
+    await this.#connection.send(
+      'BluetoothEmulation.simulatePreconnectedPeripheral',
+      preconnectedPeripheral,
+    );
+  }
+}

package/front_end/third_party/puppeteer/package/src/cdp/Browser.ts

@@ -16,6 +16,8 @@ import {
   type BrowserContextOptions,
   type IsPageTargetCallback,
   type TargetFilterCallback,
+  type ScreenInfo,
+  type AddScreenParams,
 } from '../api/Browser.js';
 import {BrowserContextEvent} from '../api/BrowserContext.js';
 import {CDPSessionEvent} from '../api/CDPSession.js';
@@ -196,7 +198,9 @@ export class CdpBrowser extends BrowserBase {
           target.type() === 'webview' ||
           (this.#handleDevToolsAsPage &&
             target.type() === 'other' &&
-            target.url().startsWith('devtools://'))
+            target
+              .url()
+              .startsWith('devtools://devtools/bundled/devtools_app.html'))
         );
       });
   }
@@ -343,8 +347,8 @@ export class CdpBrowser extends BrowserBase {
     return this.#connection.url();
   }
 
-  override async newPage(): Promise<Page> {
-    return await this.#defaultContext.newPage();
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
+    return await this.#defaultContext.newPage(options);
   }
 
   async _createPageInContext(
@@ -355,9 +359,16 @@ export class CdpBrowser extends BrowserBase {
       this.targets().filter(t => {
         return t.browserContext().id === contextId;
       }).length > 0;
+    const windowBounds =
+      options?.type === 'window' ? options.windowBounds : undefined;
     const {targetId} = await this.#connection.send('Target.createTarget', {
       url: 'about:blank',
       browserContextId: contextId || undefined,
+      left: windowBounds?.left,
+      top: windowBounds?.top,
+      width: windowBounds?.width,
+      height: windowBounds?.height,
+      windowState: windowBounds?.windowState,
       // Works around crbug.com/454825274.
       newWindow: hasTargets && options?.type === 'window' ? true : undefined,
     });
@@ -423,6 +434,25 @@ export class CdpBrowser extends BrowserBase {
     return this.#connection.send('Extensions.uninstall', {id});
   }
 
+  override async screens(): Promise<ScreenInfo[]> {
+    const {screenInfos} = await this.#connection.send(
+      'Emulation.getScreenInfos',
+    );
+    return screenInfos;
+  }
+
+  override async addScreen(params: AddScreenParams): Promise<ScreenInfo> {
+    const {screenInfo} = await this.#connection.send(
+      'Emulation.addScreen',
+      params,
+    );
+    return screenInfo;
+  }
+
+  override async removeScreen(screenId: string): Promise<void> {
+    return await this.#connection.send('Emulation.removeScreen', {screenId});
+  }
+
   override targets(): CdpTarget[] {
     return Array.from(
       this.#targetManager.getAvailableTargets().values(),

package/front_end/third_party/puppeteer/package/src/cdp/CdpSession.ts

@@ -71,7 +71,7 @@ export class CdpCDPSession extends CDPSession {
     return this.#target;
   }
 
-  override connection(): Connection | undefined {
+  override connection(): Connection {
     return this.#connection;
   }
 

package/front_end/third_party/puppeteer/package/src/cdp/DeviceRequestPrompt.ts

@@ -8,7 +8,7 @@ import type Protocol from 'devtools-protocol';
 
 import type {CDPSession} from '../api/CDPSession.js';
 import {DeviceRequestPrompt} from '../api/DeviceRequestPrompt.js';
-import {DeviceRequestPromptDevice} from '../api/DeviceRequestPrompt.js';
+import type {DeviceRequestPromptDevice} from '../api/DeviceRequestPrompt.js';
 import type {WaitTimeoutOptions} from '../api/Page.js';
 import type {TimeoutSettings} from '../common/TimeoutSettings.js';
 import {assert} from '../util/assert.js';
@@ -28,8 +28,6 @@ export class CdpDeviceRequestPrompt extends DeviceRequestPrompt {
     promise: Deferred<DeviceRequestPromptDevice>;
   }>();
 
-  devices: DeviceRequestPromptDevice[] = [];
-
   constructor(
     client: CDPSession,
     timeoutSettings: TimeoutSettings,
@@ -65,10 +63,7 @@ export class CdpDeviceRequestPrompt extends DeviceRequestPrompt {
         continue;
       }
 
-      const newDevice = new DeviceRequestPromptDevice(
-        rawDevice.id,
-        rawDevice.name,
-      );
+      const newDevice = {id: rawDevice.id, name: rawDevice.name};
       this.devices.push(newDevice);
 
       for (const waitForDevicePromise of this.#waitForDevicePromises) {
@@ -156,7 +151,7 @@ export class CdpDeviceRequestPrompt extends DeviceRequestPrompt {
 /**
  * @internal
  */
-export class DeviceRequestPromptManager {
+export class CdpDeviceRequestPromptManager {
   #client: CDPSession | null;
   #timeoutSettings: TimeoutSettings;
   #deviceRequestPromptDeferreds = new Set<Deferred<DeviceRequestPrompt>>();

package/front_end/third_party/puppeteer/package/src/cdp/Frame.ts

@@ -22,7 +22,7 @@ import {isErrorLike} from '../util/ErrorLike.js';
 import {Accessibility} from './Accessibility.js';
 import type {Binding} from './Binding.js';
 import type {CdpPreloadScript} from './CdpPreloadScript.js';
-import type {DeviceRequestPromptManager} from './DeviceRequestPrompt.js';
+import type {CdpDeviceRequestPromptManager} from './DeviceRequestPrompt.js';
 import type {FrameManager} from './FrameManager.js';
 import {FrameManagerEvent} from './FrameManagerEvents.js';
 import type {IsolatedWorldChart} from './IsolatedWorld.js';
@@ -315,7 +315,7 @@ export class CdpFrame extends Frame {
     return this._frameManager._frameTree.childFrames(this._id);
   }
 
-  #deviceRequestPromptManager(): DeviceRequestPromptManager {
+  #deviceRequestPromptManager(): CdpDeviceRequestPromptManager {
     return this._frameManager._deviceRequestPromptManager(this.#client);
   }
 

package/front_end/third_party/puppeteer/package/src/cdp/FrameManager.ts

@@ -21,7 +21,7 @@ import type {Binding} from './Binding.js';
 import {CdpPreloadScript} from './CdpPreloadScript.js';
 import type {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
-import {DeviceRequestPromptManager} from './DeviceRequestPrompt.js';
+import {CdpDeviceRequestPromptManager} from './DeviceRequestPrompt.js';
 import {ExecutionContext} from './ExecutionContext.js';
 import {CdpFrame} from './Frame.js';
 import type {FrameManagerEvents} from './FrameManagerEvents.js';
@@ -60,7 +60,7 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
 
   #deviceRequestPromptManagerMap = new WeakMap<
     CDPSession,
-    DeviceRequestPromptManager
+    CdpDeviceRequestPromptManager
   >();
 
   #frameTreeHandled?: Deferred<void>;
@@ -344,10 +344,15 @@ export class FrameManager extends EventEmitter<FrameManagerEvents> {
     void this.initialize(target._session()!, frame);
   }
 
-  _deviceRequestPromptManager(client: CDPSession): DeviceRequestPromptManager {
+  _deviceRequestPromptManager(
+    client: CDPSession,
+  ): CdpDeviceRequestPromptManager {
     let manager = this.#deviceRequestPromptManagerMap.get(client);
     if (manager === undefined) {
-      manager = new DeviceRequestPromptManager(client, this.#timeoutSettings);
+      manager = new CdpDeviceRequestPromptManager(
+        client,
+        this.#timeoutSettings,
+      );
       this.#deviceRequestPromptManagerMap.set(client, manager);
     }
     return manager;

package/front_end/third_party/puppeteer/package/src/cdp/Page.ts

@@ -7,6 +7,7 @@
 import type {Protocol} from 'devtools-protocol';
 
 import {firstValueFrom, from, raceWith} from '../../third_party/rxjs/rxjs.js';
+import type {BluetoothEmulation} from '../api/BluetoothEmulation.js';
 import type {Browser} from '../api/Browser.js';
 import type {BrowserContext} from '../api/BrowserContext.js';
 import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
@@ -59,6 +60,7 @@ import {AsyncDisposableStack} from '../util/disposable.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
 import {Binding} from './Binding.js';
+import {CdpBluetoothEmulation} from './BluetoothEmulation.js';
 import type {CdpBrowser} from './Browser.js';
 import {CdpCDPSession} from './CdpSession.js';
 import {isTargetClosedError} from './Connection.js';
@@ -120,6 +122,7 @@ export class CdpPage extends Page {
 
   #closed = false;
   readonly #targetManager: TargetManager;
+  readonly #cdpBluetoothEmulation: CdpBluetoothEmulation;
 
   #primaryTargetClient: CdpCDPSession;
   #primaryTarget: CdpTarget;
@@ -159,6 +162,12 @@ export class CdpPage extends Page {
     this.#coverage = new Coverage(client);
     this.#viewport = null;
 
+    // Use browser context's connection, as current Bluetooth emulation in Chromium is
+    // implemented on the browser context level, and not tight to the specific tab.
+    this.#cdpBluetoothEmulation = new CdpBluetoothEmulation(
+      this.#primaryTargetClient.connection(),
+    );
+
     const frameManagerEmitter = new EventEmitter(this.#frameManager);
     frameManagerEmitter.on(FrameManagerEvent.FrameAttached, frame => {
       this.emit(PageEvent.FrameAttached, frame);
@@ -1232,6 +1241,10 @@ export class CdpPage extends Page {
   ): Promise<DeviceRequestPrompt> {
     return await this.mainFrame().waitForDevicePrompt(options);
   }
+
+  override get bluetooth(): BluetoothEmulation {
+    return this.#cdpBluetoothEmulation;
+  }
 }
 
 const supportedMetrics = new Set<string>([