patchright-core 1.57.0 → 1.59.0

package/lib/server/browserContext.js

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browserContext_exports = {};
 __export(browserContext_exports, {
   BrowserContext: () => BrowserContext,
+  calculateUserAgentEmulation: () => calculateUserAgentEmulation,
   normalizeProxySettings: () => normalizeProxySettings,
   validateBrowserContextOptions: () => validateBrowserContextOptions,
   verifyClientCertificates: () => verifyClientCertificates,
@@ -36,14 +37,12 @@ __export(browserContext_exports, {
 });
 module.exports = __toCommonJS(browserContext_exports);
 var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
 var import_crypto = require("./utils/crypto");
 var import_debug = require("./utils/debug");
 var import_clock = require("./clock");
 var import_debugger = require("./debugger");
 var import_dialog = require("./dialog");
 var import_fetch = require("./fetch");
-var import_fileUtils = require("./utils/fileUtils");
 var import_stackTrace = require("../utils/isomorphic/stackTrace");
 var import_harRecorder = require("./har/harRecorder");
 var import_helper = require("./helper");
@@ -55,6 +54,25 @@ var import_recorderApp = require("./recorder/recorderApp");
 var import_selectors = require("./selectors");
 var import_tracing = require("./trace/recorder/tracing");
 var rawStorageSource = __toESM(require("../generated/storageScriptSource"));
+const BrowserContextEvent = {
+  Console: "console",
+  Close: "close",
+  Page: "page",
+  // Can't use just 'error' due to node.js special treatment of error events.
+  // @see https://nodejs.org/api/events.html#events_error_events
+  PageError: "pageerror",
+  Request: "request",
+  Response: "response",
+  RequestFailed: "requestfailed",
+  RequestFinished: "requestfinished",
+  RequestAborted: "requestaborted",
+  RequestFulfilled: "requestfulfilled",
+  RequestContinued: "requestcontinued",
+  BeforeClose: "beforeclose",
+  RecorderEvent: "recorderevent",
+  PageClosed: "pageclosed",
+  InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument"
+};
 class BrowserContext extends import_instrumentation.SdkObject {
   constructor(browser, options, browserContextId) {
     super(browser, "browser-context");
@@ -69,6 +87,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     this._creatingStorageStatePage = false;
     this.initScripts = [];
     this._routesInFlight = /* @__PURE__ */ new Set();
+    this._consoleApiExposed = false;
     this.attribution.context = this;
     this._browser = browser;
     this._options = options;
@@ -82,24 +101,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     this.dialogManager = new import_dialog.DialogManager(this.instrumentation);
   }
   static {
-    this.Events = {
-      Console: "console",
-      Close: "close",
-      Page: "page",
-      // Can't use just 'error' due to node.js special treatment of error events.
-      // @see https://nodejs.org/api/events.html#events_error_events
-      PageError: "pageerror",
-      Request: "request",
-      Response: "response",
-      RequestFailed: "requestfailed",
-      RequestFinished: "requestfinished",
-      RequestAborted: "requestaborted",
-      RequestFulfilled: "requestfulfilled",
-      RequestContinued: "requestcontinued",
-      BeforeClose: "beforeclose",
-      VideoStarted: "videostarted",
-      RecorderEvent: "recorderevent"
-    };
+    this.Events = BrowserContextEvent;
   }
   isPersistentContext() {
     return this._isPersistentContext;
@@ -111,31 +113,38 @@ class BrowserContext extends import_instrumentation.SdkObject {
     if (this.attribution.playwright.options.isInternalPlaywright)
       return;
     this._debugger = new import_debugger.Debugger(this);
-    if ((0, import_debug.debugMode)() === "inspector")
+    const shouldEnableDebugger = !this.attribution.playwright.options.isServer && ((0, import_debug.isUnderTest)() || !!this._browser.options.headful);
+    if (shouldEnableDebugger) {
+      this._debugger.setPauseAt();
+      this._debugger.on(import_debugger.Debugger.Events.PausedStateChanged, () => {
+        if (this._debugger.isPaused())
+          import_recorderApp.RecorderApp.showInspectorNoReply(this);
+      });
+    }
+    if ((0, import_debug.debugMode)() === "inspector") {
+      this._debugger.setPauseAt({ next: true });
       await import_recorderApp.RecorderApp.show(this, { pauseOnNextStatement: true });
-    if (this._debugger.isPaused())
-      import_recorderApp.RecorderApp.showInspectorNoReply(this);
-    this._debugger.on(import_debugger.Debugger.Events.PausedStateChanged, () => {
-      if (this._debugger.isPaused())
-        import_recorderApp.RecorderApp.showInspectorNoReply(this);
-    });
-    if ((0, import_debug.debugMode)() === "console") {
-      await this.extendInjectedScript(`
-        function installConsoleApi(injectedScript) { injectedScript.consoleApi.install(); }
-        module.exports = { default: () => installConsoleApi };
-      `);
     }
+    if ((0, import_debug.debugMode)() === "console")
+      await this.exposeConsoleApi();
     if (this._options.serviceWorkers === "block")
-      await this.addInitScript(void 0, `navigator.serviceWorker.register = async () => { };`);
+      await this.addInitScript(`
+if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };
+`);
     if (this._options.permissions)
       await this.grantPermissions(this._options.permissions);
   }
   debugger() {
     return this._debugger;
   }
-  async _ensureVideosPath() {
-    if (this._options.recordVideo)
-      await (0, import_fileUtils.mkdirIfNeeded)(import_path.default.join(this._options.recordVideo.dir, "dummy"));
+  async exposeConsoleApi() {
+    if (this._consoleApiExposed)
+      return;
+    this._consoleApiExposed = true;
+    await this.extendInjectedScript(`
+      function installConsoleApi(injectedScript) { injectedScript.consoleApi.install(); }
+      module.exports = { default: () => installConsoleApi };
+    `);
   }
   canResetForReuse() {
     if (this._closedStatus !== "open")
@@ -230,7 +239,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
   async exposePlaywrightBindingIfNeeded() {
     this._playwrightBindingExposed ??= (async () => {
       await this.doExposePlaywrightBinding();
-      this.bindingsInitScript = import_page2.PageBinding.createInitScript();
+      this.bindingsInitScript = import_page2.PageBinding.createInitScript(this);
       this.initScripts.push(this.bindingsInitScript);
       await this.doAddInitScript(this.bindingsInitScript);
       await this.safeNonStallingEvaluateInAllFrames(this.bindingsInitScript.source, "main");
@@ -247,16 +256,26 @@ class BrowserContext extends import_instrumentation.SdkObject {
       if (page.getBinding(name))
         throw new Error(`Function "${name}" has been already registered in one of the pages`);
     }
-    const binding = new import_page2.PageBinding(name, playwrightBinding, needsHandle);
+    await progress.race(this.exposePlaywrightBindingIfNeeded());
+    const binding = new import_page2.PageBinding(this, name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
-    await this.doExposeBinding(binding);
-  }
-  async removeExposedBindings(bindings) {
-    for (const key of this._pageBindings.keys()) {
-      if (!key.startsWith("__pw")) this._pageBindings.delete(key);
+    try {
+      await progress.race(this.doAddInitScript(binding.initScript));
+      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+      return binding;
+    } catch (error) {
+      this._pageBindings.delete(name);
+      throw error;
     }
-    await this.doRemoveExposedBindings();
+  }
+  async removeExposedBinding(binding) {
+    if (this._pageBindings.get(binding.name) !== binding)
+      return;
+    this._pageBindings.delete(binding.name);
+    await this.doRemoveInitScripts([binding.initScript]);
+    const cleanup = `{ ${binding.cleanupScript} };`;
+    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
   }
   async grantPermissions(permissions, origin) {
     let resolvedOrigin = "*";
@@ -309,7 +328,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     const pageOrError = await progress.race(page.waitForInitializedOrError());
     if (pageOrError instanceof Error)
       throw pageOrError;
-    await page.mainFrame()._waitForLoadState(progress, "load");
+    await page.mainFrame().waitForLoadState(progress, "load");
     return page;
   }
   async _loadDefaultContext(progress) {
@@ -342,25 +361,21 @@ class BrowserContext extends import_instrumentation.SdkObject {
     if (username)
       this._options.httpCredentials = { username, password: password || "" };
   }
-  async addInitScript(progress, source) {
-    const initScript = new import_page.InitScript(source);
+  async addInitScript(source) {
+    const initScript = new import_page.InitScript(this, source);
     this.initScripts.push(initScript);
     try {
-      const promise = this.doAddInitScript(initScript);
-      if (progress)
-        await progress.race(promise);
-      else
-        await promise;
+      await this.doAddInitScript(initScript);
       return initScript;
     } catch (error) {
-      this.removeInitScripts([initScript]).catch(() => {
+      initScript.dispose().catch(() => {
       });
       throw error;
     }
   }
-  async removeInitScripts(initScripts) {
-    this.initScripts.splice(0, this.initScripts.length);
-    await this.doRemoveInitScripts();
+  async removeInitScript(initScript) {
+    this.initScripts = this.initScripts.filter((script) => initScript !== script);
+    await this.doRemoveInitScripts([initScript]);
   }
   async addRequestInterceptor(progress, handler) {
     this.requestInterceptors.push(handler);
@@ -396,16 +411,13 @@ class BrowserContext extends import_instrumentation.SdkObject {
       for (const harRecorder of this._harRecorders.values())
         await harRecorder.flush();
       await this.tracing.flush();
-      const promises = [];
-      for (const { context, artifact } of this._browser._idToVideo.values()) {
-        if (context === this)
-          promises.push(artifact.finishedPromise());
-      }
+      await Promise.all(this.pages().map((page) => page.screencast.handlePageOrContextClose()));
       if (this._customCloseHandler) {
         await this._customCloseHandler();
       } else {
         await this.doClose(options.reason);
       }
+      const promises = [];
       promises.push(this._deleteAllDownloads());
       promises.push(this._deleteAllTempDirs());
       await Promise.all(promises);
@@ -581,22 +593,6 @@ function validateBrowserContextOptions(options, browserOptions) {
     options.acceptDownloads = "internal-browser-default";
   if (!options.viewport && !options.noDefaultViewport)
     options.viewport = { width: 1280, height: 720 };
-  if (options.recordVideo) {
-    if (!options.recordVideo.size) {
-      if (options.noDefaultViewport) {
-        options.recordVideo.size = { width: 800, height: 600 };
-      } else {
-        const size = options.viewport;
-        const scale = Math.min(1, 800 / Math.max(size.width, size.height));
-        options.recordVideo.size = {
-          width: Math.floor(size.width * scale),
-          height: Math.floor(size.height * scale)
-        };
-      }
-    }
-    options.recordVideo.size.width &= ~1;
-    options.recordVideo.size.height &= ~1;
-  }
   if (options.proxy)
     options.proxy = normalizeProxySettings(options.proxy);
   verifyGeolocation(options.geolocation);
@@ -648,6 +644,69 @@ function normalizeProxySettings(proxy) {
     bypass = bypass.split(",").map((t) => t.trim()).join(",");
   return { ...proxy, server, bypass };
 }
+function calculateUserAgentEmulation(options) {
+  const ua = options.userAgent;
+  if (!ua)
+    return { navigatorPlatform: void 0, userAgentMetadata: void 0 };
+  const userAgentMetadata = {
+    mobile: !!options.isMobile,
+    model: "",
+    architecture: "x86",
+    platform: "Windows",
+    platformVersion: ""
+  };
+  const androidMatch = ua.match(/Android (\d+(\.\d+)?(\.\d+)?)/);
+  const iPhoneMatch = ua.match(/iPhone OS (\d+(_\d+)?)/);
+  const iPadMatch = ua.match(/iPad; CPU OS (\d+(_\d+)?)/);
+  const macOSMatch = ua.match(/Mac OS X (\d+(_\d+)?(_\d+)?)/);
+  const windowsMatch = ua.match(/Windows\D+(\d+(\.\d+)?(\.\d+)?)/);
+  if (androidMatch) {
+    userAgentMetadata.platform = "Android";
+    userAgentMetadata.platformVersion = androidMatch[1];
+    userAgentMetadata.architecture = "arm";
+  } else if (iPhoneMatch) {
+    userAgentMetadata.platform = "iOS";
+    userAgentMetadata.platformVersion = iPhoneMatch[1].replace(/_/g, ".");
+    userAgentMetadata.architecture = "arm";
+  } else if (iPadMatch) {
+    userAgentMetadata.platform = "iOS";
+    userAgentMetadata.platformVersion = iPadMatch[1].replace(/_/g, ".");
+    userAgentMetadata.architecture = "arm";
+  } else if (macOSMatch) {
+    userAgentMetadata.platform = "macOS";
+    userAgentMetadata.platformVersion = macOSMatch[1].replace(/_/g, ".");
+    if (!ua.includes("Intel"))
+      userAgentMetadata.architecture = "arm";
+  } else if (windowsMatch) {
+    userAgentMetadata.platform = "Windows";
+    userAgentMetadata.platformVersion = windowsMatch[1];
+  } else if (ua.toLowerCase().includes("linux")) {
+    userAgentMetadata.platform = "Linux";
+  }
+  if (ua.includes("ARM") || ua.includes("aarch64"))
+    userAgentMetadata.architecture = "arm";
+  let navigatorPlatform;
+  if (!process.env.PLAYWRIGHT_NO_UA_PLATFORM) {
+    switch (userAgentMetadata.platform) {
+      case "Android":
+        navigatorPlatform = userAgentMetadata.architecture === "arm" ? "Linux armv8l" : "Linux x86_64";
+        break;
+      case "iOS":
+        navigatorPlatform = ua.includes("iPad") ? "iPad" : "iPhone";
+        break;
+      case "macOS":
+        navigatorPlatform = "MacIntel";
+        break;
+      case "Linux":
+        navigatorPlatform = userAgentMetadata.architecture === "arm" ? "Linux aarch64" : "Linux x86_64";
+        break;
+      case "Windows":
+        navigatorPlatform = "Win32";
+        break;
+    }
+  }
+  return { navigatorPlatform, userAgentMetadata };
+}
 const paramsThatAllowContextReuse = [
   "colorScheme",
   "forcedColors",
@@ -674,6 +733,7 @@ const defaultNewContextParamValues = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserContext,
+  calculateUserAgentEmulation,
   normalizeProxySettings,
   validateBrowserContextOptions,
   verifyClientCertificates,

package/lib/server/browserType.js

@@ -59,7 +59,7 @@ class BrowserType extends import_instrumentation.SdkObject {
     this.logName = "browser";
   }
   executablePath() {
-    return import_registry.registry.findExecutable(this._name).executablePath(this.attribution.playwright.options.sdkLanguage) || "";
+    return import_registry.registry.findExecutable(this._name).executablePath() || "";
   }
   name() {
     return this._name;
@@ -115,7 +115,7 @@ class BrowserType extends import_instrumentation.SdkObject {
         await progress.race(options.__testHookBeforeCreateBrowser());
       const browserOptions = {
         name: this._name,
-        isChromium: this._name === "chromium",
+        browserType: this._name,
         channel: options.channel,
         slowMo: options.slowMo,
         persistent,
@@ -129,7 +129,8 @@ class BrowserType extends import_instrumentation.SdkObject {
         protocolLogger,
         browserLogsCollector,
         wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
-        originalLaunchOptions: options
+        originalLaunchOptions: options,
+        userDataDir: persistent ? userDataDir : void 0
       };
       if (persistent)
         (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
@@ -152,10 +153,14 @@ class BrowserType extends import_instrumentation.SdkObject {
       args = [],
       executablePath = null
     } = options;
-    await this._createArtifactDirs(options);
     const tempDirectories = [];
-    const artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
-    tempDirectories.push(artifactsDir);
+    let artifactsDir;
+    if (options.artifactsDir) {
+      artifactsDir = options.artifactsDir;
+    } else {
+      artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
+      tempDirectories.push(artifactsDir);
+    }
     if (userDataDir) {
       (0, import_assert.assert)(import_path.default.isAbsolute(userDataDir), "userDataDir must be an absolute path");
       if (!await (0, import_fileUtils.existsAsync)(userDataDir))
@@ -250,6 +255,13 @@ class BrowserType extends import_instrumentation.SdkObject {
         this.waitForReadyState(options, browserLogsCollector),
         exitPromise.then(() => ({ wsEndpoint: void 0 }))
       ]);
+      if (exitPromise.isDone()) {
+        const log = import_helper.helper.formatBrowserLogs(browserLogsCollector.recentLogs());
+        const updatedLog = this.doRewriteStartupLog(log);
+        throw new Error(`Failed to launch the browser process.
+Browser logs:
+${updatedLog}`);
+      }
       if (options.cdpPort !== void 0 || !this.supportsPipeTransport()) {
         transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
       } else {
@@ -263,28 +275,24 @@ class BrowserType extends import_instrumentation.SdkObject {
       throw error;
     }
   }
-  async _createArtifactDirs(options) {
-    if (options.downloadsPath)
-      await import_fs.default.promises.mkdir(options.downloadsPath, { recursive: true });
-    if (options.tracesDir)
-      await import_fs.default.promises.mkdir(options.tracesDir, { recursive: true });
-  }
   async connectOverCDP(progress, endpointURL, options) {
     throw new Error("CDP connections are only supported by Chromium");
   }
+  async connectOverCDPTransport(progress, transport) {
+    throw new Error("CDP connections are only supported by Chromium");
+  }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
     throw new Error("Connecting to SELENIUM_REMOTE_URL is only supported by Chromium");
   }
   _validateLaunchOptions(options) {
-    const { devtools = false } = options;
-    let { headless = !devtools, downloadsPath, proxy } = options;
+    let { headless = true, downloadsPath, proxy } = options;
     if ((0, import_debug.debugMode)() === "inspector")
       headless = false;
     if (downloadsPath && !import_path.default.isAbsolute(downloadsPath))
       downloadsPath = import_path.default.join(process.cwd(), downloadsPath);
     if (options.socksProxyPort)
       proxy = { server: `socks5://127.0.0.1:${options.socksProxyPort}` };
-    return { ...options, devtools, headless, downloadsPath, proxy };
+    return { ...options, headless, downloadsPath, proxy };
   }
   _createUserDataDirArgMisuseError(userDataDirArg) {
     switch (this.attribution.playwright.options.sdkLanguage) {
@@ -301,7 +309,9 @@ class BrowserType extends import_instrumentation.SdkObject {
   _rewriteStartupLog(error) {
     if (!(0, import_protocolError.isProtocolError)(error))
       return error;
-    return this.doRewriteStartupLog(error);
+    if (error.logs)
+      error.logs = this.doRewriteStartupLog(error.logs);
+    return error;
   }
   async waitForReadyState(options, browserLogsCollector) {
     return {};

package/lib/server/chromium/chromium.js

@@ -82,6 +82,12 @@ 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 wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
+    const chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
+    const closeAndWait = async () => await chromeTransport.closeAndWait();
+    return this._connectOverCDPImpl(progress, chromeTransport, closeAndWait, options, onClose);
+  }
+  async _connectOverCDPImpl(progress, transport, closeAndWait, options, onClose) {
     const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
     const doCleanup = async () => {
       await (0, import_fileUtils.removeFolders)([artifactsDir]);
@@ -89,20 +95,17 @@ class Chromium extends import_browserType.BrowserType {
       onClose = void 0;
       await cb?.();
     };
-    let chromeTransport;
     const doClose = async () => {
-      await chromeTransport?.closeAndWait();
+      await closeAndWait();
       await doCleanup();
     };
     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,
+        browserType: "chromium",
         persistent,
         browserProcess,
         protocolLogger: import_helper.helper.debugProtocolLogger(),
@@ -113,8 +116,9 @@ class Chromium extends import_browserType.BrowserType {
         originalLaunchOptions: {}
       };
       (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
-      browser._isCollocatedWithServer = false;
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, browserOptions));
+      if (!options.isLocal)
+        browser._isCollocatedWithServer = false;
       browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
       return browser;
     } catch (error) {
@@ -123,18 +127,17 @@ class Chromium extends import_browserType.BrowserType {
       throw error;
     }
   }
+  async connectOverCDPTransport(progress, transport) {
+    const closeAndWait = async () => transport.close();
+    return this._connectOverCDPImpl(progress, transport, closeAndWait, { isLocal: true });
+  }
   _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, browserLogsCollector) {
-    let devtools = this._devtools;
-    if (options.__testHookForDevTools) {
-      devtools = this._createDevTools();
-      await options.__testHookForDevTools(devtools);
-    }
     try {
-      return await import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, devtools);
+      return await import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, this._devtools);
     } catch (e) {
       if (browserLogsCollector.recentLogs().some((log) => log.includes("Failed to create a ProcessSingleton for your profile directory."))) {
         throw new Error(
@@ -144,14 +147,12 @@ class Chromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Missing X server"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    if (!error.logs.includes("crbug.com/357670") && !error.logs.includes("No usable sandbox!") && !error.logs.includes("crbug.com/638180"))
-      return error;
-    error.logs = [
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Missing X server"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    if (!logs.includes("crbug.com/357670") && !logs.includes("No usable sandbox!") && !logs.includes("crbug.com/638180"))
+      return logs;
+    return [
       `Chromium sandboxing failed!`,
       `================================`,
       `To avoid the sandboxing issue, do either of the following:`,
@@ -160,7 +161,6 @@ class Chromium extends import_browserType.BrowserType {
       `================================`,
       ``
     ].join("\n");
-    return error;
   }
   amendEnvironment(env) {
     return env;
@@ -170,7 +170,6 @@ class Chromium extends import_browserType.BrowserType {
     transport.send(message);
   }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
-    await progress.race(this._createArtifactDirs(options));
     if (!hubUrl.endsWith("/"))
       hubUrl = hubUrl + "/";
     const args = this._innerDefaultArgs(options);
@@ -284,11 +283,7 @@ class Chromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
-    if (import_os.default.platform() === "darwin") {
-      chromeArguments.push("--enable-unsafe-swiftshader");
-    }
-    if (options.devtools)
-      chromeArguments.push("--auto-open-devtools-for-tabs");
+    chromeArguments.push("--enable-unsafe-swiftshader");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(
@@ -308,11 +303,9 @@ class Chromium extends import_browserType.BrowserType {
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (options.socksProxyPort)
-        proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));
-      if (!process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK && !proxyBypassRules.includes("<-loopback>"))
+      if (options.socksProxyPort || (0, import_crBrowser.shouldProxyLoopback)(proxy.bypass))
         proxyBypassRules.push("<-loopback>");
       if (proxyBypassRules.length > 0)
         chromeArguments.push(`--proxy-bypass-list=${proxyBypassRules.join(";")}`);
@@ -324,6 +317,10 @@ class Chromium extends import_browserType.BrowserType {
     return waitForReadyState(options, browserLogsCollector);
   }
   getExecutableName(options) {
+    if (options.channel && import_registry.registry.isChromiumAlias(options.channel))
+      return "chromium";
+    if (options.channel === "chromium-tip-of-tree")
+      return options.headless ? "chromium-tip-of-tree-headless-shell" : "chromium-tip-of-tree";
     if (options.channel)
       return options.channel;
     return options.headless ? "chromium-headless-shell" : "chromium";

package/lib/server/chromium/chromiumSwitches.js

@@ -22,10 +22,10 @@ __export(chromiumSwitches_exports, {
 });
 module.exports = __toCommonJS(chromiumSwitches_exports);
 const disabledFeatures = (assistantMode) => [
-  // See https://github.com/microsoft/playwright/pull/10380
-  "AcceptCHFrame",
   // See https://github.com/microsoft/playwright/issues/14047
   "AvoidUnnecessaryBeforeUnloadCheckSync",
+  // See https://github.com/microsoft/playwright/issues/38568
+  "BoundaryEventDispatchTracksNodeRemoval",
   "DestroyProfileOnBrowserClose",
   // See https://github.com/microsoft/playwright/pull/13854
   "DialMediaRouteProvider",
@@ -56,17 +56,27 @@ const chromiumSwitches = (assistantMode, channel, android) => [
   "--disable-background-networking",
   "--disable-background-timer-throttling",
   "--disable-backgrounding-occluded-windows",
+  "--disable-back-forward-cache",
   // Avoids surprises like main request not being intercepted during page.goBack().
   "--disable-breakpad",
+  "--disable-client-side-phishing-detection",
+  "--disable-component-extensions-with-background-pages",
+  "--disable-component-update",
   // Avoids unneeded network activity after startup.
   "--no-default-browser-check",
+  "--disable-default-apps",
   "--disable-dev-shm-usage",
+  "--disable-extensions",
   "--disable-features=" + disabledFeatures(assistantMode).join(","),
   process.env.PLAYWRIGHT_LEGACY_SCREENSHOT ? "" : "--enable-features=CDPScreenshotNewSurface",
+  "--allow-pre-commit-input",
   "--disable-hang-monitor",
+  "--disable-ipc-flooding-protection",
+  "--disable-popup-blocking",
   "--disable-prompt-on-repost",
   "--disable-renderer-backgrounding",
   "--force-color-profile=srgb",
+  "--metrics-recording-only",
   "--no-first-run",
   "--password-store=basic",
   "--use-mock-keychain",
@@ -75,16 +85,18 @@ const chromiumSwitches = (assistantMode, channel, android) => [
   "--export-tagged-pdf",
   // https://chromium-review.googlesource.com/c/chromium/src/+/4853540
   "--disable-search-engine-choice-screen",
+  // https://issues.chromium.org/41491762
+  "--unsafely-disable-devtools-self-xss-warnings",
   // Edge can potentially restart on Windows (msRelaunchNoCompatLayer) which looses its file descriptors (stdout/stderr) and CDP (3/4). Disable until fixed upstream.
   "--edge-skip-compat-layer-relaunch",
+  assistantMode ? "" : "--enable-automation",
   // This disables Chrome for Testing infobar that is visible in the persistent context.
   // The switch is ignored everywhere else, including Chromium/Chrome/Edge.
   "--disable-infobars",
   // Less annoying popups.
   "--disable-search-engine-choice-screen",
   // Prevents the "three dots" menu crash in IdentityManager::HasPrimaryAccount for ephemeral contexts.
-  android ? "" : "--disable-sync",
-  "--disable-blink-features=AutomationControlled"
+  android ? "" : "--disable-sync"
 ].filter(Boolean);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {