playwright-core 1.54.0-alpha-2025-06-20 → 1.54.0-alpha-1750421372000

package/lib/client/playwright.js

@@ -43,9 +43,9 @@ class Playwright extends import_channelOwner.ChannelOwner {
     this._android._playwright = this;
     this._electron = import_electron.Electron.from(initializer.electron);
     this._electron._playwright = this;
-    this._bidiChromium = import_browserType.BrowserType.from(initializer.bidiChromium);
+    this._bidiChromium = import_browserType.BrowserType.from(initializer._bidiChromium);
     this._bidiChromium._playwright = this;
-    this._bidiFirefox = import_browserType.BrowserType.from(initializer.bidiFirefox);
+    this._bidiFirefox = import_browserType.BrowserType.from(initializer._bidiFirefox);
     this._bidiFirefox._playwright = this;
     this.devices = this._connection.localUtils()?.devices ?? {};
     this.selectors = new import_selectors.Selectors(this._connection._platform);

package/lib/inProcessFactory.js

@@ -43,8 +43,8 @@ function createInProcessPlaywright() {
   playwrightAPI.firefox._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("firefox");
   playwrightAPI.webkit._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("webkit");
   playwrightAPI._android._serverLauncher = new import_androidServerImpl.AndroidServerLauncherImpl();
-  playwrightAPI._bidiChromium._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("bidiChromium");
-  playwrightAPI._bidiFirefox._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("bidiFirefox");
+  playwrightAPI._bidiChromium._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("_bidiChromium");
+  playwrightAPI._bidiFirefox._serverLauncher = new import_browserServerImpl.BrowserServerLauncherImpl("_bidiFirefox");
   dispatcherConnection.onmessage = (message) => setImmediate(() => clientConnection.dispatch(message));
   clientConnection.onmessage = (message) => setImmediate(() => dispatcherConnection.dispatch(message));
   clientConnection.toImpl = (x) => x ? dispatcherConnection._dispatcherByGuid.get(x._guid)._object : dispatcherConnection._dispatcherByGuid.get("");

package/lib/protocol/validator.js

@@ -382,8 +382,8 @@ import_validatorPrimitives.scheme.PlaywrightInitializer = (0, import_validatorPr
   chromium: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
   firefox: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
   webkit: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
-  bidiChromium: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
-  bidiFirefox: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
+  _bidiChromium: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
+  _bidiFirefox: (0, import_validatorPrimitives.tChannel)(["BrowserType"]),
   android: (0, import_validatorPrimitives.tChannel)(["Android"]),
   electron: (0, import_validatorPrimitives.tChannel)(["Electron"]),
   utils: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tChannel)(["LocalUtils"])),

package/lib/remote/playwrightConnection.js

@@ -21,31 +21,22 @@ __export(playwrightConnection_exports, {
   PlaywrightConnection: () => PlaywrightConnection
 });
 module.exports = __toCommonJS(playwrightConnection_exports);
-var import_socksProxy = require("../server/utils/socksProxy");
 var import_server = require("../server");
 var import_android = require("../server/android/android");
 var import_browser = require("../server/browser");
 var import_debugControllerDispatcher = require("../server/dispatchers/debugControllerDispatcher");
-var import_instrumentation = require("../server/instrumentation");
-var import_assert = require("../utils/isomorphic/assert");
-var import_debug = require("../server/utils/debug");
 var import_profiler = require("../server/utils/profiler");
 var import_utils = require("../utils");
 var import_debugLogger = require("../server/utils/debugLogger");
 class PlaywrightConnection {
-  constructor(lock, clientType, ws, options, playwright, preLaunched, id, onClose) {
+  constructor(semaphore, ws, controller, playwright, initialize, id) {
     this._cleanups = [];
     this._disconnected = false;
     this._ws = ws;
-    this._playwright = playwright;
-    this._preLaunched = preLaunched;
-    this._options = options;
-    options.launchOptions = filterLaunchOptions(options.launchOptions, options.allowFSPaths);
-    if (clientType === "pre-launched-browser-or-android")
-      (0, import_assert.assert)(preLaunched.browser || preLaunched.androidDevice);
-    this._onClose = onClose;
+    this._semaphore = semaphore;
     this._id = id;
-    this._profileName = `${(/* @__PURE__ */ new Date()).toISOString()}-${clientType}`;
+    this._profileName = (/* @__PURE__ */ new Date()).toISOString();
+    const lock = this._semaphore.acquire();
     this._dispatcherConnection = new import_server.DispatcherConnection();
     this._dispatcherConnection.onmessage = async (message) => {
       await lock;
@@ -70,125 +61,33 @@ class PlaywrightConnection {
     });
     ws.on("close", () => this._onDisconnect());
     ws.on("error", (error) => this._onDisconnect(error));
-    if (clientType === "controller") {
-      this._root = this._initDebugControllerMode();
+    if (controller) {
+      import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
+      this._root = new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
       return;
     }
-    this._root = new import_server.RootDispatcher(this._dispatcherConnection, async (scope, options2) => {
+    this._root = new import_server.RootDispatcher(this._dispatcherConnection, async (scope, params) => {
       await (0, import_profiler.startProfiling)();
-      if (clientType === "reuse-browser")
-        return await this._initReuseBrowsersMode(scope, options2);
-      if (clientType === "pre-launched-browser-or-android")
-        return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope, options2) : await this._initPreLaunchedAndroidMode(scope);
-      if (clientType === "launch-browser")
-        return await this._initLaunchBrowserMode(scope, options2);
-      throw new Error("Unsupported client type: " + clientType);
-    });
-  }
-  async _initLaunchBrowserMode(scope, options) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
-    const ownedSocksProxy = await this._createOwnedSocksProxy();
-    let browserName = this._options.browserName;
-    if ("bidi" === browserName) {
-      if (this._options.launchOptions?.channel?.toLocaleLowerCase().includes("firefox"))
-        browserName = "bidiFirefox";
-      else
-        browserName = "bidiChromium";
-    }
-    const browser = await this._playwright[browserName].launch((0, import_instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
-    browser.options.sdkLanguage = options.sdkLanguage;
-    this._cleanups.push(() => browser.close({ reason: "Connection terminated" }));
-    browser.on(import_browser.Browser.Events.Disconnected, () => {
-      this.close({ code: 1001, reason: "Browser closed" });
-    });
-    return new import_server.PlaywrightDispatcher(scope, this._playwright, { socksProxy: ownedSocksProxy, preLaunchedBrowser: browser, denyLaunch: true });
-  }
-  async _initPreLaunchedBrowserMode(scope, options) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (browser) mode`);
-    this._preLaunched.socksProxy?.setPattern(this._options.socksProxyPattern);
-    const browser = this._preLaunched.browser;
-    browser.options.sdkLanguage = options.sdkLanguage;
-    browser.on(import_browser.Browser.Events.Disconnected, () => {
-      this.close({ code: 1001, reason: "Browser closed" });
-    });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, {
-      socksProxy: this._preLaunched.socksProxy,
-      preLaunchedBrowser: browser,
-      sharedBrowser: this._options.sharedBrowser,
-      denyLaunch: true
-    });
-    for (const b of this._playwright.allBrowsers()) {
-      if (b !== browser)
-        await b.close({ reason: "Connection terminated" });
-    }
-    this._cleanups.push(() => playwrightDispatcher.cleanup());
-    return playwrightDispatcher;
-  }
-  async _initPreLaunchedAndroidMode(scope) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (Android) mode`);
-    const androidDevice = this._preLaunched.androidDevice;
-    androidDevice.on(import_android.AndroidDevice.Events.Close, () => {
-      this.close({ code: 1001, reason: "Android device disconnected" });
-    });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, { preLaunchedAndroidDevice: androidDevice, denyLaunch: true });
-    this._cleanups.push(() => playwrightDispatcher.cleanup());
-    return playwrightDispatcher;
-  }
-  _initDebugControllerMode() {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
-    return new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, this._playwright.debugController);
-  }
-  async _initReuseBrowsersMode(scope, options) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
-    const requestedOptions = launchOptionsHash(this._options.launchOptions);
-    let browser = this._playwright.allBrowsers().find((b) => {
-      if (b.options.name !== this._options.browserName)
-        return false;
-      const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
-      return existingOptions === requestedOptions;
-    });
-    for (const b of this._playwright.allBrowsers()) {
-      if (b === browser)
-        continue;
-      if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel)
-        await b.close({ reason: "Connection terminated" });
-    }
-    if (!browser) {
-      browser = await this._playwright[this._options.browserName || "chromium"].launch((0, import_instrumentation.serverSideCallMetadata)(), {
-        ...this._options.launchOptions,
-        headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
-      });
-      browser.on(import_browser.Browser.Events.Disconnected, () => {
-        this.close({ code: 1001, reason: "Browser closed" });
-      });
-    }
-    browser.options.sdkLanguage = options.sdkLanguage;
-    this._cleanups.push(async () => {
-      for (const browser2 of this._playwright.allBrowsers()) {
-        for (const context of browser2.contexts()) {
-          if (!context.pages().length)
-            await context.close({ reason: "Connection terminated" });
-          else
-            await context.stopPendingOperations("Connection closed");
-        }
-        if (!browser2.contexts())
-          await browser2.close({ reason: "Connection terminated" });
+      const options = await initialize();
+      if (options.preLaunchedBrowser) {
+        const browser = options.preLaunchedBrowser;
+        browser.options.sdkLanguage = params.sdkLanguage;
+        browser.on(import_browser.Browser.Events.Disconnected, () => {
+          this.close({ code: 1001, reason: "Browser closed" });
+        });
+      }
+      if (options.preLaunchedAndroidDevice) {
+        const androidDevice = options.preLaunchedAndroidDevice;
+        androidDevice.on(import_android.AndroidDevice.Events.Close, () => {
+          this.close({ code: 1001, reason: "Android device disconnected" });
+        });
       }
+      if (options.dispose)
+        this._cleanups.push(options.dispose);
+      const dispatcher = new import_server.PlaywrightDispatcher(scope, playwright, options);
+      this._cleanups.push(() => dispatcher.cleanup());
+      return dispatcher;
     });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, { preLaunchedBrowser: browser, denyLaunch: true });
-    return playwrightDispatcher;
-  }
-  async _createOwnedSocksProxy() {
-    if (!this._options.socksProxyPattern) {
-      this._options.launchOptions.socksProxyPort = void 0;
-      return;
-    }
-    const socksProxy = new import_socksProxy.SocksProxy();
-    socksProxy.setPattern(this._options.socksProxyPattern);
-    this._options.launchOptions.socksProxyPort = await socksProxy.listen(0);
-    import_debugLogger.debugLogger.log("server", `[${this._id}] started socks proxy on port ${this._options.launchOptions.socksProxyPort}`);
-    this._cleanups.push(() => socksProxy.close());
-    return socksProxy;
   }
   async _onDisconnect(error) {
     this._disconnected = true;
@@ -199,7 +98,7 @@ class PlaywrightConnection {
       await cleanup().catch(() => {
       });
     await (0, import_profiler.stopProfiling)(this._profileName);
-    this._onClose();
+    this._semaphore.release();
     import_debugLogger.debugLogger.log("server", `[${this._id}] finished cleanup`);
   }
   logServerMetadata(message, messageString, direction) {
@@ -222,46 +121,6 @@ class PlaywrightConnection {
     }
   }
 }
-function launchOptionsHash(options) {
-  const copy = { ...options };
-  for (const k of Object.keys(copy)) {
-    const key = k;
-    if (copy[key] === defaultLaunchOptions[key])
-      delete copy[key];
-  }
-  for (const key of optionsThatAllowBrowserReuse)
-    delete copy[key];
-  return JSON.stringify(copy);
-}
-function filterLaunchOptions(options, allowFSPaths) {
-  return {
-    channel: options.channel,
-    args: options.args,
-    ignoreAllDefaultArgs: options.ignoreAllDefaultArgs,
-    ignoreDefaultArgs: options.ignoreDefaultArgs,
-    timeout: options.timeout,
-    headless: options.headless,
-    proxy: options.proxy,
-    chromiumSandbox: options.chromiumSandbox,
-    firefoxUserPrefs: options.firefoxUserPrefs,
-    slowMo: options.slowMo,
-    executablePath: (0, import_debug.isUnderTest)() || allowFSPaths ? options.executablePath : void 0,
-    downloadsPath: allowFSPaths ? options.downloadsPath : void 0
-  };
-}
-const defaultLaunchOptions = {
-  ignoreAllDefaultArgs: false,
-  handleSIGINT: false,
-  handleSIGTERM: false,
-  handleSIGHUP: false,
-  headless: true,
-  devtools: false
-};
-const optionsThatAllowBrowserReuse = [
-  "headless",
-  "timeout",
-  "tracesDir"
-];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PlaywrightConnection

package/lib/remote/playwrightServer.js

@@ -28,6 +28,9 @@ var import_time = require("../utils/isomorphic/time");
 var import_wsServer = require("../server/utils/wsServer");
 var import_ascii = require("../server/utils/ascii");
 var import_userAgent = require("../server/utils/userAgent");
+var import_utils = require("../utils");
+var import_server = require("../server");
+var import_socksProxy = require("../server/utils/socksProxy");
 class PlaywrightServer {
   constructor(options) {
     this._options = options;
@@ -75,41 +78,144 @@ ${uaError}` };
         } catch (e) {
         }
         const isExtension = this._options.mode === "extension";
-        let clientType = "launch-browser";
-        let semaphore = browserSemaphore;
-        if (isExtension && url.searchParams.has("debug-controller")) {
-          clientType = "controller";
-          semaphore = controllerSemaphore;
-        } else if (isExtension) {
-          clientType = "reuse-browser";
-          semaphore = reuseBrowserSemaphore;
-        } else if (this._options.mode === "launchServer" || this._options.mode === "launchServerShared") {
-          clientType = "pre-launched-browser-or-android";
-          semaphore = browserSemaphore;
+        const allowFSPaths = isExtension;
+        launchOptions = filterLaunchOptions(launchOptions, allowFSPaths);
+        if (isExtension) {
+          if (url.searchParams.has("debug-controller")) {
+            return new import_playwrightConnection.PlaywrightConnection(
+              controllerSemaphore,
+              ws,
+              true,
+              this._playwright,
+              async () => {
+                throw new Error("shouldnt be used");
+              },
+              id
+            );
+          }
+          return new import_playwrightConnection.PlaywrightConnection(
+            reuseBrowserSemaphore,
+            ws,
+            false,
+            this._playwright,
+            () => this._initReuseBrowsersMode(browserName, launchOptions, id),
+            id
+          );
+        }
+        if (this._options.mode === "launchServer" || this._options.mode === "launchServerShared") {
+          if (this._options.preLaunchedBrowser) {
+            return new import_playwrightConnection.PlaywrightConnection(
+              browserSemaphore,
+              ws,
+              false,
+              this._playwright,
+              () => this._initPreLaunchedBrowserMode(id),
+              id
+            );
+          }
+          return new import_playwrightConnection.PlaywrightConnection(
+            browserSemaphore,
+            ws,
+            false,
+            this._playwright,
+            () => this._initPreLaunchedAndroidMode(id),
+            id
+          );
         }
         return new import_playwrightConnection.PlaywrightConnection(
-          semaphore.acquire(),
-          clientType,
+          browserSemaphore,
           ws,
-          {
-            socksProxyPattern: proxyValue,
-            browserName,
-            launchOptions,
-            allowFSPaths: this._options.mode === "extension",
-            sharedBrowser: this._options.mode === "launchServerShared"
-          },
+          false,
           this._playwright,
-          {
-            browser: this._options.preLaunchedBrowser,
-            androidDevice: this._options.preLaunchedAndroidDevice,
-            socksProxy: this._options.preLaunchedSocksProxy
-          },
-          id,
-          () => semaphore.release()
+          () => this._initLaunchBrowserMode(browserName, proxyValue, launchOptions, id),
+          id
         );
       }
     });
   }
+  async _initReuseBrowsersMode(browserName, launchOptions, id) {
+    import_utils.debugLogger.log("server", `[${id}] engaged reuse browsers mode for ${browserName}`);
+    const requestedOptions = launchOptionsHash(launchOptions);
+    let browser = this._playwright.allBrowsers().find((b) => {
+      if (b.options.name !== browserName)
+        return false;
+      const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
+      return existingOptions === requestedOptions;
+    });
+    for (const b of this._playwright.allBrowsers()) {
+      if (b === browser)
+        continue;
+      if (b.options.name === browserName && b.options.channel === launchOptions.channel)
+        await b.close({ reason: "Connection terminated" });
+    }
+    if (!browser) {
+      browser = await this._playwright[browserName || "chromium"].launch((0, import_server.serverSideCallMetadata)(), {
+        ...launchOptions,
+        headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
+      });
+    }
+    return {
+      preLaunchedBrowser: browser,
+      denyLaunch: true,
+      dispose: async () => {
+        for (const browser2 of this._playwright.allBrowsers()) {
+          for (const context of browser2.contexts()) {
+            if (!context.pages().length)
+              await context.close({ reason: "Connection terminated" });
+            else
+              await context.stopPendingOperations("Connection closed");
+          }
+          if (!browser2.contexts())
+            await browser2.close({ reason: "Connection terminated" });
+        }
+      }
+    };
+  }
+  async _initPreLaunchedBrowserMode(id) {
+    import_utils.debugLogger.log("server", `[${id}] engaged pre-launched (browser) mode`);
+    const browser = this._options.preLaunchedBrowser;
+    for (const b of this._playwright.allBrowsers()) {
+      if (b !== browser)
+        await b.close({ reason: "Connection terminated" });
+    }
+    return {
+      preLaunchedBrowser: browser,
+      socksProxy: this._options.preLaunchedSocksProxy,
+      sharedBrowser: this._options.mode === "launchServerShared",
+      denyLaunch: true
+    };
+  }
+  async _initPreLaunchedAndroidMode(id) {
+    import_utils.debugLogger.log("server", `[${id}] engaged pre-launched (Android) mode`);
+    const androidDevice = this._options.preLaunchedAndroidDevice;
+    return {
+      preLaunchedAndroidDevice: androidDevice,
+      denyLaunch: true
+    };
+  }
+  async _initLaunchBrowserMode(browserName, proxyValue, launchOptions, id) {
+    import_utils.debugLogger.log("server", `[${id}] engaged launch mode for "${browserName}"`);
+    let socksProxy;
+    if (proxyValue) {
+      socksProxy = new import_socksProxy.SocksProxy();
+      socksProxy.setPattern(proxyValue);
+      launchOptions.socksProxyPort = await socksProxy.listen(0);
+      import_utils.debugLogger.log("server", `[${id}] started socks proxy on port ${launchOptions.socksProxyPort}`);
+    } else {
+      launchOptions.socksProxyPort = void 0;
+    }
+    const browser = await this._playwright[browserName].launch((0, import_server.serverSideCallMetadata)(), launchOptions);
+    return {
+      preLaunchedBrowser: browser,
+      socksProxy,
+      sharedBrowser: true,
+      denyLaunch: true,
+      dispose: async () => {
+        await browser.close({ reason: "Connection terminated" });
+        socksProxy?.close();
+      }
+    };
+  }
   async listen(port = 0, hostname) {
     return this._wsServer.listen(port, hostname, this._options.path);
   }
@@ -140,6 +246,46 @@ function userAgentVersionMatchesErrorMessage(userAgent) {
     ].join("\n"), 1);
   }
 }
+function launchOptionsHash(options) {
+  const copy = { ...options };
+  for (const k of Object.keys(copy)) {
+    const key = k;
+    if (copy[key] === defaultLaunchOptions[key])
+      delete copy[key];
+  }
+  for (const key of optionsThatAllowBrowserReuse)
+    delete copy[key];
+  return JSON.stringify(copy);
+}
+function filterLaunchOptions(options, allowFSPaths) {
+  return {
+    channel: options.channel,
+    args: options.args,
+    ignoreAllDefaultArgs: options.ignoreAllDefaultArgs,
+    ignoreDefaultArgs: options.ignoreDefaultArgs,
+    timeout: options.timeout,
+    headless: options.headless,
+    proxy: options.proxy,
+    chromiumSandbox: options.chromiumSandbox,
+    firefoxUserPrefs: options.firefoxUserPrefs,
+    slowMo: options.slowMo,
+    executablePath: (0, import_utils.isUnderTest)() || allowFSPaths ? options.executablePath : void 0,
+    downloadsPath: allowFSPaths ? options.downloadsPath : void 0
+  };
+}
+const defaultLaunchOptions = {
+  ignoreAllDefaultArgs: false,
+  handleSIGINT: false,
+  handleSIGTERM: false,
+  handleSIGHUP: false,
+  headless: true,
+  devtools: false
+};
+const optionsThatAllowBrowserReuse = [
+  "headless",
+  "timeout",
+  "tracesDir"
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PlaywrightServer

package/lib/server/android/android.js

@@ -93,6 +93,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     this.model = model;
     this.serial = backend.serial;
     this._options = options;
+    this.logName = "browser";
   }
   static {
     this.Events = {
@@ -220,17 +221,20 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     this._android._deviceClosed(this);
     this.emit(AndroidDevice.Events.Close);
   }
-  async launchBrowser(pkg = "com.android.chrome", options) {
-    (0, import_utilsBundle.debug)("pw:android")("Force-stopping", pkg);
-    await this._backend.runCommand(`shell:am force-stop ${pkg}`);
-    const socketName = (0, import_debug.isUnderTest)() ? "webview_devtools_remote_playwright_test" : "playwright_" + (0, import_crypto.createGuid)() + "_devtools_remote";
-    const commandLine = this._defaultArgs(options, socketName).join(" ");
-    (0, import_utilsBundle.debug)("pw:android")("Starting", pkg, commandLine);
-    await this._backend.runCommand(`shell:echo "${Buffer.from(commandLine).toString("base64")}" | base64 -d > /data/local/tmp/chrome-command-line`);
-    await this._backend.runCommand(`shell:am start -a android.intent.action.VIEW -d about:blank ${pkg}`);
-    const browserContext = await this._connectToBrowser(socketName, options);
-    await this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`);
-    return browserContext;
+  async launchBrowser(metadata, pkg = "com.android.chrome", options) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run(async (progress) => {
+      (0, import_utilsBundle.debug)("pw:android")("Force-stopping", pkg);
+      await this._backend.runCommand(`shell:am force-stop ${pkg}`);
+      const socketName = (0, import_debug.isUnderTest)() ? "webview_devtools_remote_playwright_test" : "playwright_" + (0, import_crypto.createGuid)() + "_devtools_remote";
+      const commandLine = this._defaultArgs(options, socketName).join(" ");
+      (0, import_utilsBundle.debug)("pw:android")("Starting", pkg, commandLine);
+      await progress.race(this._backend.runCommand(`shell:echo "${Buffer.from(commandLine).toString("base64")}" | base64 -d > /data/local/tmp/chrome-command-line`));
+      await progress.race(this._backend.runCommand(`shell:am start -a android.intent.action.VIEW -d about:blank ${pkg}`));
+      const browserContext = await this._connectToBrowser(progress, socketName, options);
+      await progress.race(this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`));
+      return browserContext;
+    });
   }
   _defaultArgs(options, socketName) {
     const chromeArguments = [
@@ -259,23 +263,28 @@ class AndroidDevice extends import_instrumentation.SdkObject {
     chromeArguments.push(...args);
     return chromeArguments;
   }
-  async connectToWebView(socketName) {
-    const webView = this._webViews.get(socketName);
-    if (!webView)
-      throw new Error("WebView has been closed");
-    return await this._connectToBrowser(socketName);
+  async connectToWebView(metadata, socketName) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run(async (progress) => {
+      const webView = this._webViews.get(socketName);
+      if (!webView)
+        throw new Error("WebView has been closed");
+      return await this._connectToBrowser(progress, socketName);
+    });
   }
-  async _connectToBrowser(socketName, options = {}) {
-    const socket = await this._waitForLocalAbstract(socketName);
+  async _connectToBrowser(progress, socketName, options = {}) {
+    const socket = await progress.race(this._waitForLocalAbstract(socketName));
     const androidBrowser = new AndroidBrowser(this, socket);
-    await androidBrowser._init();
+    progress.cleanupWhenAborted(() => androidBrowser.close());
+    await progress.race(androidBrowser._init());
     this._browserConnections.add(androidBrowser);
-    const artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
+    const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
     const cleanupArtifactsDir = async () => {
       const errors = (await (0, import_fileUtils.removeFolders)([artifactsDir])).filter(Boolean);
       for (let i = 0; i < (errors || []).length; ++i)
         (0, import_utilsBundle.debug)("pw:android")(`exception while removing ${artifactsDir}: ${errors[i]}`);
     };
+    progress.cleanupWhenAborted(cleanupArtifactsDir);
     import_processLauncher.gracefullyCloseSet.add(cleanupArtifactsDir);
     socket.on("close", async () => {
       import_processLauncher.gracefullyCloseSet.delete(cleanupArtifactsDir);
@@ -296,12 +305,9 @@ class AndroidDevice extends import_instrumentation.SdkObject {
       originalLaunchOptions: { timeout: 0 }
     };
     (0, import_browserContext.validateBrowserContextOptions)(options, browserOptions);
-    const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions);
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
+    const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions));
     const defaultContext = browser._defaultContext;
-    await controller.run(async (progress) => {
-      await defaultContext._loadDefaultContextAsIs(progress);
-    });
+    await defaultContext._loadDefaultContextAsIs(progress);
     return defaultContext;
   }
   webViews() {

package/lib/server/bidi/bidiChromium.js

@@ -40,7 +40,7 @@ var import_chromiumSwitches = require("../chromium/chromiumSwitches");
 var import_chromium = require("../chromium/chromium");
 class BidiChromium extends import_browserType.BrowserType {
   constructor(parent) {
-    super(parent, "bidi");
+    super(parent, "_bidiChromium");
   }
   async connectToTransport(transport, options, browserLogsCollector) {
     const bidiTransport = await require("./bidiOverCdp").connectBidiOverCdp(transport);

package/lib/server/bidi/bidiFirefox.js

@@ -41,7 +41,10 @@ var import_firefoxPrefs = require("./third_party/firefoxPrefs");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 class BidiFirefox extends import_browserType.BrowserType {
   constructor(parent) {
-    super(parent, "bidi");
+    super(parent, "_bidiFirefox");
+  }
+  executablePath() {
+    return "";
   }
   async connectToTransport(transport, options) {
     return import_bidiBrowser.BidiBrowser.connect(this.attribution.playwright, transport, options);