patchright-core 1.52.5 → 1.55.1

package/lib/server/browserType.js

@@ -28,7 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var browserType_exports = {};
 __export(browserType_exports, {
-  BrowserReadyState: () => BrowserReadyState,
   BrowserType: () => BrowserType,
   kNoXServerRunningError: () => kNoXServerRunningError
 });
@@ -37,40 +36,27 @@ var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var import_browserContext = require("./browserContext");
-var import_timeoutSettings = require("./timeoutSettings");
 var import_debug = require("./utils/debug");
 var import_assert = require("../utils/isomorphic/assert");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_time = require("../utils/isomorphic/time");
 var import_fileUtils = require("./utils/fileUtils");
 var import_helper = require("./helper");
 var import_instrumentation = require("./instrumentation");
 var import_pipeTransport = require("./pipeTransport");
 var import_processLauncher = require("./utils/processLauncher");
-var import_progress = require("./progress");
 var import_protocolError = require("./protocolError");
 var import_registry = require("./registry");
 var import_socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
 var import_transport = require("./transport");
 var import_debugLogger = require("./utils/debugLogger");
 const kNoXServerRunningError = "Looks like you launched a headed browser without having a XServer running.\nSet either 'headless: true' or use 'xvfb-run <your-playwright-app>' before running Playwright.\n\n<3 Playwright Team";
-class BrowserReadyState {
-  constructor() {
-    this._wsEndpoint = new import_manualPromise.ManualPromise();
-  }
-  onBrowserExit() {
-    this._wsEndpoint.resolve(void 0);
-  }
-  async waitUntilReady() {
-    const wsEndpoint = await this._wsEndpoint;
-    return { wsEndpoint };
-  }
-}
 class BrowserType extends import_instrumentation.SdkObject {
   constructor(parent, browserName) {
     super(parent, "browser-type");
-    this._useBidi = false;
     this.attribution.browserType = this;
     this._name = browserName;
+    this.logName = "browser";
   }
   executablePath() {
     return import_registry.registry.findExecutable(this._name).executablePath(this.attribution.playwright.options.sdkLanguage) || "";
@@ -78,44 +64,35 @@ class BrowserType extends import_instrumentation.SdkObject {
   name() {
     return this._name;
   }
-  async launch(metadata, options, protocolLogger) {
+  async launch(progress, options, protocolLogger) {
     options = this._validateLaunchOptions(options);
-    if (this._useBidi)
-      options.useWebSocket = true;
-    const controller = new import_progress.ProgressController(metadata, this);
-    controller.setLogName("browser");
-    const browser = await controller.run((progress) => {
-      const seleniumHubUrl = options.__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
-      if (seleniumHubUrl)
-        return this._launchWithSeleniumHub(progress, seleniumHubUrl, options);
-      return this._innerLaunchWithRetries(progress, options, void 0, import_helper.helper.debugProtocolLogger(protocolLogger)).catch((e) => {
-        throw this._rewriteStartupLog(e);
-      });
-    }, import_timeoutSettings.TimeoutSettings.launchTimeout(options));
-    return browser;
+    const seleniumHubUrl = options.__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
+    if (seleniumHubUrl)
+      return this._launchWithSeleniumHub(progress, seleniumHubUrl, options);
+    return this._innerLaunchWithRetries(progress, options, void 0, import_helper.helper.debugProtocolLogger(protocolLogger)).catch((e) => {
+      throw this._rewriteStartupLog(e);
+    });
   }
-  async launchPersistentContext(metadata, userDataDir, options) {
+  async launchPersistentContext(progress, userDataDir, options) {
     const launchOptions = this._validateLaunchOptions(options);
-    if (this._useBidi)
-      launchOptions.useWebSocket = true;
-    const controller = new import_progress.ProgressController(metadata, this);
-    controller.setLogName("browser");
-    const browser = await controller.run(async (progress) => {
-      let clientCertificatesProxy;
-      if (options.clientCertificates?.length) {
-        clientCertificatesProxy = new import_socksClientCertificatesInterceptor.ClientCertificatesProxy(options);
-        launchOptions.proxyOverride = await clientCertificatesProxy?.listen();
-        options = { ...options };
-        options.internalIgnoreHTTPSErrors = true;
-      }
-      progress.cleanupWhenAborted(() => clientCertificatesProxy?.close());
-      const browser2 = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
+    let clientCertificatesProxy;
+    if (options.clientCertificates?.length) {
+      clientCertificatesProxy = await import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(progress, options);
+      launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
+      options = { ...options };
+      options.internalIgnoreHTTPSErrors = true;
+    }
+    try {
+      const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
         throw this._rewriteStartupLog(e);
       });
-      browser2._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
-      return browser2;
-    }, import_timeoutSettings.TimeoutSettings.launchTimeout(launchOptions));
-    return browser._defaultContext;
+      browser._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
+      return browser._defaultContext;
+    } catch (error) {
+      await clientCertificatesProxy?.close().catch(() => {
+      });
+      throw error;
+    }
   }
   async _innerLaunchWithRetries(progress, options, persistent, protocolLogger, userDataDir) {
     try {
@@ -133,46 +110,48 @@ class BrowserType extends import_instrumentation.SdkObject {
     options.proxy = options.proxy ? (0, import_browserContext.normalizeProxySettings)(options.proxy) : void 0;
     const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
     const { browserProcess, userDataDir, artifactsDir, transport } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
-    if (options.__testHookBeforeCreateBrowser)
-      await options.__testHookBeforeCreateBrowser();
-    const browserOptions = {
-      name: this._name,
-      isChromium: this._name === "chromium",
-      channel: options.channel,
-      slowMo: options.slowMo,
-      persistent,
-      headful: !options.headless,
-      artifactsDir,
-      downloadsPath: options.downloadsPath || artifactsDir,
-      tracesDir: options.tracesDir || artifactsDir,
-      browserProcess,
-      customExecutablePath: options.executablePath,
-      proxy: options.proxy,
-      protocolLogger,
-      browserLogsCollector,
-      wsEndpoint: options.useWebSocket ? transport.wsEndpoint : void 0,
-      originalLaunchOptions: options
-    };
-    if (persistent)
-      (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-    copyTestHooks(options, browserOptions);
-    const browser = await this.connectToTransport(transport, browserOptions);
-    browser._userDataDirForTest = userDataDir;
-    if (persistent && !options.ignoreAllDefaultArgs)
-      await browser._defaultContext._loadDefaultContext(progress);
-    return browser;
+    try {
+      if (options.__testHookBeforeCreateBrowser)
+        await progress.race(options.__testHookBeforeCreateBrowser());
+      const browserOptions = {
+        name: this._name,
+        isChromium: this._name === "chromium",
+        channel: options.channel,
+        slowMo: options.slowMo,
+        persistent,
+        headful: !options.headless,
+        artifactsDir,
+        downloadsPath: options.downloadsPath || artifactsDir,
+        tracesDir: options.tracesDir || artifactsDir,
+        browserProcess,
+        customExecutablePath: options.executablePath,
+        proxy: options.proxy,
+        protocolLogger,
+        browserLogsCollector,
+        wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
+        originalLaunchOptions: options
+      };
+      if (persistent)
+        (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+      copyTestHooks(options, browserOptions);
+      const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
+      browser._userDataDirForTest = userDataDir;
+      if (persistent && !options.ignoreAllDefaultArgs)
+        await browser._defaultContext._loadDefaultContext(progress);
+      return browser;
+    } catch (error) {
+      await browserProcess.close().catch(() => {
+      });
+      throw error;
+    }
   }
-  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
+  async _prepareToLaunch(options, isPersistent, userDataDir) {
     const {
       ignoreDefaultArgs,
       ignoreAllDefaultArgs,
       args = [],
-      executablePath = null,
-      handleSIGINT = true,
-      handleSIGTERM = true,
-      handleSIGHUP = true
+      executablePath = null
     } = options;
-    const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
     await this._createArtifactDirs(options);
     const tempDirectories = [];
     const artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
@@ -205,30 +184,43 @@ class BrowserType extends import_instrumentation.SdkObject {
       executable = registryExecutable.executablePathOrDie(this.attribution.playwright.options.sdkLanguage);
       await import_registry.registry.validateHostRequirementsForExecutablesIfNeeded([registryExecutable], this.attribution.playwright.options.sdkLanguage);
     }
-    const readyState = this.readyState(options);
+    return { executable, browserArguments, userDataDir, artifactsDir, tempDirectories };
+  }
+  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
+    const {
+      handleSIGINT = true,
+      handleSIGTERM = true,
+      handleSIGHUP = true
+    } = options;
+    const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
+    const prepared = await progress.race(this._prepareToLaunch(options, isPersistent, userDataDir));
     let transport = void 0;
     let browserProcess = void 0;
+    const exitPromise = new import_manualPromise.ManualPromise();
     const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
-      command: executable,
-      args: browserArguments,
-      env: this.amendEnvironment(env, userDataDir, executable, browserArguments),
+      command: prepared.executable,
+      args: prepared.browserArguments,
+      env: this.amendEnvironment(env, prepared.userDataDir, isPersistent),
       handleSIGINT,
       handleSIGTERM,
       handleSIGHUP,
       log: (message) => {
-        readyState?.onBrowserOutput(message);
         progress.log(message);
         browserLogsCollector.log(message);
       },
       stdio: "pipe",
-      tempDirectories,
+      tempDirectories: prepared.tempDirectories,
       attemptToGracefullyClose: async () => {
         if (options.__testHookGracefullyClose)
           await options.__testHookGracefullyClose();
-        this.attemptToGracefullyCloseBrowser(transport);
+        if (transport) {
+          this.attemptToGracefullyCloseBrowser(transport);
+        } else {
+          throw new Error("Force-killing the browser because no transport is available to gracefully close it.");
+        }
       },
       onExit: (exitCode, signal) => {
-        readyState?.onBrowserExit();
+        exitPromise.resolve();
         if (browserProcess && browserProcess.onclose)
           browserProcess.onclose(exitCode, signal);
       }
@@ -250,18 +242,26 @@ class BrowserType extends import_instrumentation.SdkObject {
     browserProcess = {
       onclose: void 0,
       process: launchedProcess,
-      close: () => closeOrKill(options.__testHookBrowserCloseTimeout || import_timeoutSettings.DEFAULT_TIMEOUT),
+      close: () => closeOrKill(options.__testHookBrowserCloseTimeout || import_time.DEFAULT_PLAYWRIGHT_TIMEOUT),
       kill
     };
-    progress.cleanupWhenAborted(() => closeOrKill(progress.timeUntilDeadline()));
-    const wsEndpoint = (await readyState?.waitUntilReady())?.wsEndpoint;
-    if (options.useWebSocket) {
-      transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
-    } else {
-      const stdio = launchedProcess.stdio;
-      transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
+    try {
+      const { wsEndpoint } = await progress.race([
+        this.waitForReadyState(options, browserLogsCollector),
+        exitPromise.then(() => ({ wsEndpoint: void 0 }))
+      ]);
+      if (options.cdpPort !== void 0 || !this.supportsPipeTransport()) {
+        transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
+      } else {
+        const stdio = launchedProcess.stdio;
+        transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
+      }
+      return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
+    } catch (error) {
+      await closeOrKill(import_time.DEFAULT_PLAYWRIGHT_TIMEOUT).catch(() => {
+      });
+      throw error;
     }
-    return { browserProcess, artifactsDir, userDataDir, transport };
   }
   async _createArtifactDirs(options) {
     if (options.downloadsPath)
@@ -269,7 +269,7 @@ class BrowserType extends import_instrumentation.SdkObject {
     if (options.tracesDir)
       await import_fs.default.promises.mkdir(options.tracesDir, { recursive: true });
   }
-  async connectOverCDP(metadata, endpointURL, options) {
+  async connectOverCDP(progress, endpointURL, options) {
     throw new Error("CDP connections are only supported by Chromium");
   }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
@@ -278,12 +278,12 @@ class BrowserType extends import_instrumentation.SdkObject {
   _validateLaunchOptions(options) {
     const { devtools = false } = options;
     let { headless = !devtools, downloadsPath, proxy } = options;
-    if ((0, import_debug.debugMode)())
+    if ((0, import_debug.debugMode)() === "inspector")
       headless = false;
     if (downloadsPath && !import_path.default.isAbsolute(downloadsPath))
       downloadsPath = import_path.default.join(process.cwd(), downloadsPath);
-    if (this.attribution.playwright.options.socksProxyPort)
-      proxy = { server: `socks5://127.0.0.1:${this.attribution.playwright.options.socksProxyPort}` };
+    if (options.socksProxyPort)
+      proxy = { server: `socks5://127.0.0.1:${options.socksProxyPort}` };
     return { ...options, devtools, headless, downloadsPath, proxy };
   }
   _createUserDataDirArgMisuseError(userDataDirArg) {
@@ -303,11 +303,14 @@ class BrowserType extends import_instrumentation.SdkObject {
       return error;
     return this.doRewriteStartupLog(error);
   }
-  readyState(options) {
-    return void 0;
+  async waitForReadyState(options, browserLogsCollector) {
+    return {};
   }
   async prepareUserDataDir(options, userDataDir) {
   }
+  supportsPipeTransport() {
+    return true;
+  }
   getExecutableName(options) {
     return options.channel || this._name;
   }
@@ -320,7 +323,6 @@ function copyTestHooks(from, to) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BrowserReadyState,
   BrowserType,
   kNoXServerRunningError
 });

package/lib/server/chromium/chromium.js

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var chromium_exports = {};
 __export(chromium_exports, {
-  Chromium: () => Chromium
+  Chromium: () => Chromium,
+  waitForReadyState: () => waitForReadyState
 });
 module.exports = __toCommonJS(chromium_exports);
 var import_fs = __toESM(require("fs"));
@@ -37,7 +38,6 @@ var import_path = __toESM(require("path"));
 var import_chromiumSwitches = require("./chromiumSwitches");
 var import_crBrowser = require("./crBrowser");
 var import_crConnection = require("./crConnection");
-var import_timeoutSettings = require("../timeoutSettings");
 var import_utils = require("../../utils");
 var import_ascii = require("../utils/ascii");
 var import_debugLogger = require("../utils/debugLogger");
@@ -46,7 +46,6 @@ var import_network = require("../utils/network");
 var import_userAgent = require("../utils/userAgent");
 var import_browserContext = require("../browserContext");
 var import_browserType = require("../browserType");
-var import_browserType2 = require("../browserType");
 var import_helper = require("../helper");
 var import_registry = require("../registry");
 var import_transport = require("../transport");
@@ -54,20 +53,15 @@ var import_crDevTools = require("./crDevTools");
 var import_browser = require("../browser");
 var import_fileUtils = require("../utils/fileUtils");
 var import_processLauncher = require("../utils/processLauncher");
-var import_progress = require("../progress");
 const ARTIFACTS_FOLDER = import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-");
 class Chromium extends import_browserType.BrowserType {
   constructor(parent) {
     super(parent, "chromium");
-    if ((0, import_utils.debugMode)())
+    if ((0, import_utils.debugMode)() === "inspector")
       this._devtools = this._createDevTools();
   }
-  async connectOverCDP(metadata, endpointURL, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    controller.setLogName("browser");
-    return controller.run(async (progress) => {
-      return await this._connectOverCDPInternal(progress, endpointURL, options);
-    }, import_timeoutSettings.TimeoutSettings.timeout(options));
+  async connectOverCDP(progress, endpointURL, options) {
+    return await this._connectOverCDPInternal(progress, endpointURL, options);
   }
   async _connectOverCDPInternal(progress, endpointURL, options, onClose) {
     let headersMap;
@@ -77,53 +71,67 @@ class Chromium extends import_browserType.BrowserType {
       headersMap = { "User-Agent": (0, import_userAgent.getUserAgent)() };
     else if (headersMap && !Object.keys(headersMap).some((key) => key.toLowerCase() === "user-agent"))
       headersMap["User-Agent"] = (0, import_userAgent.getUserAgent)();
-    const artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
-    const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
-    progress.throwIfAborted();
-    const chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
-    const cleanedUp = new import_manualPromise.ManualPromise();
+    const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
     const doCleanup = async () => {
       await (0, import_fileUtils.removeFolders)([artifactsDir]);
-      await onClose?.();
-      cleanedUp.resolve();
+      const cb = onClose;
+      onClose = void 0;
+      await cb?.();
     };
+    let chromeTransport;
     const doClose = async () => {
-      await chromeTransport.closeAndWait();
-      await cleanedUp;
+      await chromeTransport?.closeAndWait();
+      await doCleanup();
     };
-    const browserProcess = { close: doClose, kill: doClose };
-    const persistent = { noDefaultViewport: true };
-    const browserOptions = {
-      slowMo: options.slowMo,
-      name: "chromium",
-      isChromium: true,
-      persistent,
-      browserProcess,
-      protocolLogger: import_helper.helper.debugProtocolLogger(),
-      browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
-      artifactsDir,
-      downloadsPath: options.downloadsPath || artifactsDir,
-      tracesDir: options.tracesDir || artifactsDir,
-      originalLaunchOptions: {}
-    };
-    (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-    progress.throwIfAborted();
-    const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
-    browser._isCollocatedWithServer = false;
-    browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
-    return browser;
+    try {
+      const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
+      chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
+      const browserProcess = { close: doClose, kill: doClose };
+      const persistent = { noDefaultViewport: true };
+      const browserOptions = {
+        slowMo: options.slowMo,
+        name: "chromium",
+        isChromium: true,
+        persistent,
+        browserProcess,
+        protocolLogger: import_helper.helper.debugProtocolLogger(),
+        browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
+        artifactsDir,
+        downloadsPath: options.downloadsPath || artifactsDir,
+        tracesDir: options.tracesDir || artifactsDir,
+        originalLaunchOptions: {}
+      };
+      (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
+      browser._isCollocatedWithServer = false;
+      browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
+      return browser;
+    } catch (error) {
+      await doClose().catch(() => {
+      });
+      throw error;
+    }
   }
   _createDevTools() {
     const directory = import_registry.registry.findExecutable("chromium").directory;
     return directory ? new import_crDevTools.CRDevTools(import_path.default.join(directory, "devtools-preferences.json")) : void 0;
   }
-  async connectToTransport(transport, options) {
+  async connectToTransport(transport, options, browserLogsCollector) {
     let devtools = this._devtools;
     if (options.__testHookForDevTools) {
       devtools = this._createDevTools();
       await options.__testHookForDevTools(devtools);
     }
-    return import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, devtools);
+    try {
+      return await import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, devtools);
+    } catch (e) {
+      if (browserLogsCollector.recentLogs().some((log) => log.includes("Failed to create a ProcessSingleton for your profile directory."))) {
+        throw new Error(
+          "Failed to create a ProcessSingleton for your profile directory. This usually means that the profile is already in use by another instance of Chromium."
+        );
+      }
+      throw e;
+    }
   }
   doRewriteStartupLog(error) {
     if (!error.logs)
@@ -143,7 +151,7 @@ class Chromium extends import_browserType.BrowserType {
     ].join("\n");
     return error;
   }
-  amendEnvironment(env, userDataDir, executable, browserArguments) {
+  amendEnvironment(env) {
     return env;
   }
   attemptToGracefullyCloseBrowser(transport) {
@@ -151,7 +159,7 @@ class Chromium extends import_browserType.BrowserType {
     transport.send(message);
   }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
-    await this._createArtifactDirs(options);
+    await progress.race(this._createArtifactDirs(options));
     if (!hubUrl.endsWith("/"))
       hubUrl = hubUrl + "/";
     const args = this._innerDefaultArgs(options);
@@ -173,7 +181,7 @@ class Chromium extends import_browserType.BrowserType {
         headers = remoteHeaders;
     }
     progress.log(`<selenium> connecting to ${hubUrl}`);
-    const response = await (0, import_network.fetchData)({
+    const response = await (0, import_network.fetchData)(progress, {
       url: hubUrl + "session",
       method: "POST",
       headers: {
@@ -182,15 +190,14 @@ class Chromium extends import_browserType.BrowserType {
       },
       data: JSON.stringify({
         capabilities: { alwaysMatch: desiredCapabilities }
-      }),
-      timeout: progress.timeUntilDeadline()
+      })
     }, seleniumErrorHandler);
     const value = JSON.parse(response).value;
     const sessionId = value.sessionId;
     progress.log(`<selenium> connected to sessionId=${sessionId}`);
     const disconnectFromSelenium = async () => {
       progress.log(`<selenium> disconnecting from sessionId=${sessionId}`);
-      await (0, import_network.fetchData)({
+      await (0, import_network.fetchData)(void 0, {
         url: hubUrl + "session/" + sessionId,
         method: "DELETE",
         headers
@@ -221,10 +228,9 @@ class Chromium extends import_browserType.BrowserType {
         if (endpointURL.hostname === "localhost" || endpointURL.hostname === "127.0.0.1") {
           const sessionInfoUrl = new URL(hubUrl).origin + "/grid/api/testsession?session=" + sessionId;
           try {
-            const sessionResponse = await (0, import_network.fetchData)({
+            const sessionResponse = await (0, import_network.fetchData)(progress, {
               url: sessionInfoUrl,
               method: "GET",
-              timeout: progress.timeUntilDeadline(),
               headers
             }, seleniumErrorHandler);
             const proxyId = JSON.parse(sessionResponse).proxyId;
@@ -247,8 +253,8 @@ class Chromium extends import_browserType.BrowserType {
   defaultArgs(options, isPersistent, userDataDir) {
     const chromeArguments = this._innerDefaultArgs(options);
     chromeArguments.push(`--user-data-dir=${userDataDir}`);
-    if (options.useWebSocket)
-      chromeArguments.push("--remote-debugging-port=0");
+    if (options.cdpPort !== void 0)
+      chromeArguments.push(`--remote-debugging-port=${options.cdpPort}`);
     else
       chromeArguments.push("--remote-debugging-pipe");
     if (isPersistent)
@@ -266,11 +272,9 @@ class Chromium extends import_browserType.BrowserType {
       throw new Error("Playwright manages remote debugging connection itself.");
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
-    const chromeArguments = [...import_chromiumSwitches.chromiumSwitches];
+    const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
     if (import_os.default.platform() === "darwin") {
-      chromeArguments.push("--enable-use-zoom-for-dsf=false");
-      if (options.headless && (!options.channel || options.channel === "chromium-headless-shell"))
-        chromeArguments.push("--use-angle");
+      chromeArguments.push("--enable-unsafe-swiftshader");
     }
     if (options.devtools)
       chromeArguments.push("--auto-open-devtools-for-tabs");
@@ -288,12 +292,12 @@ class Chromium extends import_browserType.BrowserType {
     if (proxy) {
       const proxyURL = new URL(proxy.server);
       const isSocks = proxyURL.protocol === "socks5:";
-      if (isSocks && !this.attribution.playwright.options.socksProxyPort) {
+      if (isSocks && !options.socksProxyPort) {
         chromeArguments.push(`--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE ${proxyURL.hostname}"`);
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (this.attribution.playwright.options.socksProxyPort)
+      if (options.socksProxyPort)
         proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));
@@ -305,10 +309,8 @@ class Chromium extends import_browserType.BrowserType {
     chromeArguments.push(...args);
     return chromeArguments;
   }
-  readyState(options) {
-    if (options.useWebSocket || options.args?.some((a) => a.startsWith("--remote-debugging-port")))
-      return new ChromiumReadyState();
-    return void 0;
+  async waitForReadyState(options, browserLogsCollector) {
+    return waitForReadyState(options, browserLogsCollector);
   }
   getExecutableName(options) {
     if (options.channel)
@@ -316,19 +318,31 @@ class Chromium extends import_browserType.BrowserType {
     return options.headless ? "chromium-headless-shell" : "chromium";
   }
 }
-class ChromiumReadyState extends import_browserType2.BrowserReadyState {
-  onBrowserOutput(message) {
+async function waitForReadyState(options, browserLogsCollector) {
+  if (options.cdpPort === void 0 && !options.args?.some((a) => a.startsWith("--remote-debugging-port")))
+    return {};
+  const result = new import_manualPromise.ManualPromise();
+  browserLogsCollector.onMessage((message) => {
+    if (message.includes("Failed to create a ProcessSingleton for your profile directory.")) {
+      result.reject(new Error("Failed to create a ProcessSingleton for your profile directory. This usually means that the profile is already in use by another instance of Chromium."));
+    }
     const match = message.match(/DevTools listening on (.*)/);
     if (match)
-      this._wsEndpoint.resolve(match[1]);
-  }
+      result.resolve({ wsEndpoint: match[1] });
+  });
+  return result;
 }
 async function urlToWSEndpoint(progress, endpointURL, headers) {
   if (endpointURL.startsWith("ws"))
     return endpointURL;
   progress.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
-  const httpURL = endpointURL.endsWith("/") ? `${endpointURL}json/version/` : `${endpointURL}/json/version/`;
+  const url = new URL(endpointURL);
+  if (!url.pathname.endsWith("/"))
+    url.pathname += "/";
+  url.pathname += "json/version/";
+  const httpURL = url.toString();
   const json = await (0, import_network.fetchData)(
+    progress,
     {
       url: httpURL,
       headers
@@ -372,5 +386,6 @@ function parseSeleniumRemoteParams(env, progress) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Chromium
+  Chromium,
+  waitForReadyState
 });