@checkly/playwright-core 1.51.17-beta.2 → 1.54.2-beta.0

package/lib/server/browserType.js

@@ -1,127 +1,99 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.kNoXServerRunningError = exports.BrowserType = exports.BrowserReadyState = void 0;
-var _fs = _interopRequireDefault(require("fs"));
-var _os = _interopRequireDefault(require("os"));
-var _path = _interopRequireDefault(require("path"));
-var _browserContext = require("./browserContext");
-var _timeoutSettings = require("./timeoutSettings");
-var _debug = require("./utils/debug");
-var _assert = require("../utils/isomorphic/assert");
-var _manualPromise = require("../utils/isomorphic/manualPromise");
-var _fileUtils = require("./utils/fileUtils");
-var _helper = require("./helper");
-var _instrumentation = require("./instrumentation");
-var _pipeTransport = require("./pipeTransport");
-var _processLauncher = require("./utils/processLauncher");
-var _progress = require("./progress");
-var _protocolError = require("./protocolError");
-var _registry = require("./registry");
-var _socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
-var _transport = require("./transport");
-var _debugLogger = require("./utils/debugLogger");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const kNoXServerRunningError = exports.kNoXServerRunningError = 'Looks like you launched a headed browser without having a XServer running.\n' + 'Set either \'headless: true\' or use \'xvfb-run <your-playwright-app>\' before running Playwright.\n\n<3 Playwright Team';
-class BrowserReadyState {
-  constructor() {
-    this._wsEndpoint = new _manualPromise.ManualPromise();
-  }
-  onBrowserExit() {
-    // Unblock launch when browser prematurely exits.
-    this._wsEndpoint.resolve(undefined);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  async waitUntilReady() {
-    const wsEndpoint = await this._wsEndpoint;
-    return {
-      wsEndpoint
-    };
-  }
-}
-exports.BrowserReadyState = BrowserReadyState;
-class BrowserType extends _instrumentation.SdkObject {
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserType_exports = {};
+__export(browserType_exports, {
+  BrowserType: () => BrowserType,
+  kNoXServerRunningError: () => kNoXServerRunningError
+});
+module.exports = __toCommonJS(browserType_exports);
+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_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_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 BrowserType extends import_instrumentation.SdkObject {
   constructor(parent, browserName) {
-    super(parent, 'browser-type');
-    this._name = void 0;
-    this._useBidi = false;
+    super(parent, "browser-type");
     this.attribution.browserType = this;
     this._name = browserName;
+    this.logName = "browser";
   }
   executablePath() {
-    return _registry.registry.findExecutable(this._name).executablePath(this.attribution.playwright.options.sdkLanguage) || '';
+    return import_registry.registry.findExecutable(this._name).executablePath(this.attribution.playwright.options.sdkLanguage) || "";
   }
   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 _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, undefined, _helper.helper.debugProtocolLogger(protocolLogger)).catch(e => {
-        throw this._rewriteStartupLog(e);
-      });
-    }, _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 _progress.ProgressController(metadata, this);
-    controller.setLogName('browser');
-    const browser = await controller.run(async progress => {
-      var _options$clientCertif;
-      // Note: Any initial TLS requests will fail since we rely on the Page/Frames initialize which sets ignoreHTTPSErrors.
-      let clientCertificatesProxy;
-      if ((_options$clientCertif = options.clientCertificates) !== null && _options$clientCertif !== void 0 && _options$clientCertif.length) {
-        var _clientCertificatesPr;
-        clientCertificatesProxy = new _socksClientCertificatesInterceptor.ClientCertificatesProxy(options);
-        launchOptions.proxyOverride = await ((_clientCertificatesPr = clientCertificatesProxy) === null || _clientCertificatesPr === void 0 ? void 0 : _clientCertificatesPr.listen());
-        options = {
-          ...options
-        };
-        options.internalIgnoreHTTPSErrors = true;
-      }
-      progress.cleanupWhenAborted(() => {
-        var _clientCertificatesPr2;
-        return (_clientCertificatesPr2 = clientCertificatesProxy) === null || _clientCertificatesPr2 === void 0 ? void 0 : _clientCertificatesPr2.close();
-      });
-      const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, _helper.helper.debugProtocolLogger(), userDataDir).catch(e => {
-        throw this._rewriteStartupLog(e);
-      });
-      browser._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
-      return browser;
-    }, _timeoutSettings.TimeoutSettings.launchTimeout(launchOptions));
+    let clientCertificatesProxy;
+    if (options.clientCertificates?.length) {
+      clientCertificatesProxy = await progress.raceWithCleanup(import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(options), (proxy) => proxy.close());
+      launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
+      options = { ...options };
+      options.internalIgnoreHTTPSErrors = true;
+    }
+    const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
+      throw this._rewriteStartupLog(e);
+    });
+    browser._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
     return browser._defaultContext;
   }
   async _innerLaunchWithRetries(progress, options, persistent, protocolLogger, userDataDir) {
     try {
       return await this._innerLaunch(progress, options, persistent, protocolLogger, userDataDir);
     } catch (error) {
-      // @see https://github.com/microsoft/playwright/issues/5214
-      const errorMessage = typeof error === 'object' && typeof error.message === 'string' ? error.message : '';
-      if (errorMessage.includes('Inconsistency detected by ld.so')) {
+      const errorMessage = typeof error === "object" && typeof error.message === "string" ? error.message : "";
+      if (errorMessage.includes("Inconsistency detected by ld.so")) {
         progress.log(`<restarting browser due to hitting race condition in glibc>`);
         return this._innerLaunch(progress, options, persistent, protocolLogger, userDataDir);
       }
@@ -129,18 +101,14 @@ class BrowserType extends _instrumentation.SdkObject {
     }
   }
   async _innerLaunch(progress, options, persistent, protocolLogger, maybeUserDataDir) {
-    options.proxy = options.proxy ? (0, _browserContext.normalizeProxySettings)(options.proxy) : undefined;
-    const browserLogsCollector = new _debugLogger.RecentLogsCollector();
-    const {
-      browserProcess,
-      userDataDir,
-      artifactsDir,
-      transport
-    } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
-    if (options.__testHookBeforeCreateBrowser) await options.__testHookBeforeCreateBrowser();
+    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 progress.race(options.__testHookBeforeCreateBrowser());
     const browserOptions = {
       name: this._name,
-      isChromium: this._name === 'chromium',
+      isChromium: this._name === "chromium",
       channel: options.channel,
       slowMo: options.slowMo,
       persistent,
@@ -153,187 +121,189 @@ class BrowserType extends _instrumentation.SdkObject {
       proxy: options.proxy,
       protocolLogger,
       browserLogsCollector,
-      wsEndpoint: options.useWebSocket ? transport.wsEndpoint : undefined,
+      wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
       originalLaunchOptions: options
     };
-    if (persistent) (0, _browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+    if (persistent)
+      (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
     copyTestHooks(options, browserOptions);
-    const browser = await this.connectToTransport(transport, browserOptions);
+    const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
     browser._userDataDirForTest = userDataDir;
-    // We assume no control when using custom arguments, and do not prepare the default context in that case.
-    if (persistent && !options.ignoreAllDefaultArgs) await browser._defaultContext._loadDefaultContext(progress);
+    if (persistent && !options.ignoreAllDefaultArgs)
+      await browser._defaultContext._loadDefaultContext(progress);
     return browser;
   }
-  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
-    var _await$readyState$wai;
+  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, _processLauncher.envArrayToObject)(options.env) : process.env;
     await this._createArtifactDirs(options);
     const tempDirectories = [];
-    const artifactsDir = await _fs.default.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), 'playwright-artifacts-'));
+    const artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
     tempDirectories.push(artifactsDir);
     if (userDataDir) {
-      (0, _assert.assert)(_path.default.isAbsolute(userDataDir), 'userDataDir must be an absolute path');
-      // Firefox bails if the profile directory does not exist, Chrome creates it. We ensure consistent behavior here.
-      if (!(await (0, _fileUtils.existsAsync)(userDataDir))) await _fs.default.promises.mkdir(userDataDir, {
-        recursive: true,
-        mode: 0o700
-      });
+      (0, import_assert.assert)(import_path.default.isAbsolute(userDataDir), "userDataDir must be an absolute path");
+      if (!await (0, import_fileUtils.existsAsync)(userDataDir))
+        await import_fs.default.promises.mkdir(userDataDir, { recursive: true, mode: 448 });
     } else {
-      userDataDir = await _fs.default.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), `playwright_${this._name}dev_profile-`));
+      userDataDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), `playwright_${this._name}dev_profile-`));
       tempDirectories.push(userDataDir);
     }
     await this.prepareUserDataDir(options, userDataDir);
     const browserArguments = [];
-    if (ignoreAllDefaultArgs) browserArguments.push(...args);else if (ignoreDefaultArgs) browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1));else browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir));
+    if (ignoreAllDefaultArgs)
+      browserArguments.push(...args);
+    else if (ignoreDefaultArgs)
+      browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir).filter((arg) => ignoreDefaultArgs.indexOf(arg) === -1));
+    else
+      browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir));
     let executable;
     if (executablePath) {
-      if (!(await (0, _fileUtils.existsAsync)(executablePath))) throw new Error(`Failed to launch ${this._name} because executable doesn't exist at ${executablePath}`);
+      if (!await (0, import_fileUtils.existsAsync)(executablePath))
+        throw new Error(`Failed to launch ${this._name} because executable doesn't exist at ${executablePath}`);
       executable = executablePath;
     } else {
-      const registryExecutable = _registry.registry.findExecutable(this.getExecutableName(options));
-      if (!registryExecutable || registryExecutable.browserName !== this._name) throw new Error(`Unsupported ${this._name} channel "${options.channel}"`);
+      const registryExecutable = import_registry.registry.findExecutable(this.getExecutableName(options));
+      if (!registryExecutable || registryExecutable.browserName !== this._name)
+        throw new Error(`Unsupported ${this._name} channel "${options.channel}"`);
       executable = registryExecutable.executablePathOrDie(this.attribution.playwright.options.sdkLanguage);
-      await _registry.registry.validateHostRequirementsForExecutablesIfNeeded([registryExecutable], this.attribution.playwright.options.sdkLanguage);
+      await import_registry.registry.validateHostRequirementsForExecutablesIfNeeded([registryExecutable], this.attribution.playwright.options.sdkLanguage);
     }
-    const readyState = this.readyState(options);
-    // Note: it is important to define these variables before launchProcess, so that we don't get
-    // "Cannot access 'browserServer' before initialization" if something went wrong.
-    let transport = undefined;
-    let browserProcess = undefined;
+    return { executable, browserArguments, userDataDir, artifactsDir, tempDirectories };
+  }
+  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
     const {
-      launchedProcess,
-      gracefullyClose,
-      kill
-    } = await (0, _processLauncher.launchProcess)({
-      command: executable,
-      args: browserArguments,
-      env: this.amendEnvironment(env, userDataDir, executable, browserArguments),
+      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));
+    progress.cleanupWhenAborted(() => (0, import_fileUtils.removeFolders)(prepared.tempDirectories));
+    let transport = void 0;
+    let browserProcess = void 0;
+    const exitPromise = new import_manualPromise.ManualPromise();
+    const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
+      command: prepared.executable,
+      args: prepared.browserArguments,
+      env: this.amendEnvironment(env, prepared.userDataDir, isPersistent),
       handleSIGINT,
       handleSIGTERM,
       handleSIGHUP,
-      log: message => {
-        readyState === null || readyState === void 0 || readyState.onBrowserOutput(message);
+      log: (message) => {
         progress.log(message);
         browserLogsCollector.log(message);
       },
-      stdio: 'pipe',
-      tempDirectories,
+      stdio: "pipe",
+      tempDirectories: prepared.tempDirectories,
       attemptToGracefullyClose: async () => {
-        if (options.__testHookGracefullyClose) await options.__testHookGracefullyClose();
-        // We try to gracefully close to prevent crash reporting and core dumps.
-        // Note that it's fine to reuse the pipe transport, since
-        // our connection ignores kBrowserCloseMessageId.
+        if (options.__testHookGracefullyClose)
+          await options.__testHookGracefullyClose();
         this.attemptToGracefullyCloseBrowser(transport);
       },
       onExit: (exitCode, signal) => {
-        // Unblock launch when browser prematurely exits.
-        readyState === null || readyState === void 0 || readyState.onBrowserExit();
-        if (browserProcess && browserProcess.onclose) browserProcess.onclose(exitCode, signal);
+        exitPromise.resolve();
+        if (browserProcess && browserProcess.onclose)
+          browserProcess.onclose(exitCode, signal);
       }
     });
     async function closeOrKill(timeout) {
       let timer;
       try {
-        await Promise.race([gracefullyClose(), new Promise((resolve, reject) => timer = setTimeout(reject, timeout))]);
+        await Promise.race([
+          gracefullyClose(),
+          new Promise((resolve, reject) => timer = setTimeout(reject, timeout))
+        ]);
       } catch (ignored) {
-        await kill().catch(ignored => {}); // Make sure to await actual process exit.
+        await kill().catch((ignored2) => {
+        });
       } finally {
         clearTimeout(timer);
       }
     }
     browserProcess = {
-      onclose: undefined,
+      onclose: void 0,
       process: launchedProcess,
-      close: () => closeOrKill(options.__testHookBrowserCloseTimeout || _timeoutSettings.DEFAULT_TIMEOUT),
+      close: () => closeOrKill(options.__testHookBrowserCloseTimeout || import_time.DEFAULT_PLAYWRIGHT_TIMEOUT),
       kill
     };
-    progress.cleanupWhenAborted(() => closeOrKill(progress.timeUntilDeadline()));
-    const wsEndpoint = (_await$readyState$wai = await (readyState === null || readyState === void 0 ? void 0 : readyState.waitUntilReady())) === null || _await$readyState$wai === void 0 ? void 0 : _await$readyState$wai.wsEndpoint;
-    if (options.useWebSocket) {
-      transport = await _transport.WebSocketTransport.connect(progress, wsEndpoint);
+    progress.cleanupWhenAborted(() => closeOrKill(import_time.DEFAULT_PLAYWRIGHT_TIMEOUT));
+    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 _pipeTransport.PipeTransport(stdio[3], stdio[4]);
+      transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
     }
-    return {
-      browserProcess,
-      artifactsDir,
-      userDataDir,
-      transport
-    };
+    progress.cleanupWhenAborted(() => transport.close());
+    return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
   }
   async _createArtifactDirs(options) {
-    if (options.downloadsPath) await _fs.default.promises.mkdir(options.downloadsPath, {
-      recursive: true
-    });
-    if (options.tracesDir) await _fs.default.promises.mkdir(options.tracesDir, {
-      recursive: true
-    });
+    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(metadata, endpointURL, options, timeout) {
-    throw new Error('CDP connections are only supported by Chromium');
+  async connectOverCDP(progress, endpointURL, options) {
+    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');
+    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;
-    if ((0, _debug.debugMode)()) headless = false;
-    if (downloadsPath && !_path.default.isAbsolute(downloadsPath)) downloadsPath = _path.default.join(process.cwd(), downloadsPath);
-    if (this.attribution.playwright.options.socksProxyPort) proxy = {
-      server: `socks5://127.0.0.1:${this.attribution.playwright.options.socksProxyPort}`
-    };
-    return {
-      ...options,
-      devtools,
-      headless,
-      downloadsPath,
-      proxy
-    };
+    const { devtools = false } = options;
+    let { headless = !devtools, downloadsPath, proxy } = options;
+    if ((0, import_debug.debugMode)())
+      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 };
   }
   _createUserDataDirArgMisuseError(userDataDirArg) {
     switch (this.attribution.playwright.options.sdkLanguage) {
-      case 'java':
+      case "java":
         return new Error(`Pass userDataDir parameter to 'BrowserType.launchPersistentContext(userDataDir, options)' instead of specifying '${userDataDirArg}' argument`);
-      case 'python':
+      case "python":
         return new Error(`Pass user_data_dir parameter to 'browser_type.launch_persistent_context(user_data_dir, **kwargs)' instead of specifying '${userDataDirArg}' argument`);
-      case 'csharp':
+      case "csharp":
         return new Error(`Pass userDataDir parameter to 'BrowserType.LaunchPersistentContextAsync(userDataDir, options)' instead of specifying '${userDataDirArg}' argument`);
       default:
         return new Error(`Pass userDataDir parameter to 'browserType.launchPersistentContext(userDataDir, options)' instead of specifying '${userDataDirArg}' argument`);
     }
   }
   _rewriteStartupLog(error) {
-    if (!(0, _protocolError.isProtocolError)(error)) return error;
+    if (!(0, import_protocolError.isProtocolError)(error))
+      return error;
     return this.doRewriteStartupLog(error);
   }
-  readyState(options) {
-    return undefined;
+  async waitForReadyState(options, browserLogsCollector) {
+    return {};
+  }
+  async prepareUserDataDir(options, userDataDir) {
+  }
+  supportsPipeTransport() {
+    return true;
   }
-  async prepareUserDataDir(options, userDataDir) {}
   getExecutableName(options) {
     return options.channel || this._name;
   }
 }
-exports.BrowserType = BrowserType;
 function copyTestHooks(from, to) {
   for (const [key, value] of Object.entries(from)) {
-    if (key.startsWith('__testHook')) to[key] = value;
+    if (key.startsWith("__testHook"))
+      to[key] = value;
   }
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserType,
+  kNoXServerRunningError
+});

package/lib/server/callLog.js

@@ -1,35 +1,41 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var callLog_exports = {};
+__export(callLog_exports, {
+  compressCallLog: () => compressCallLog,
+  findRepeatedSubsequencesForTest: () => findRepeatedSubsequencesForTest
 });
-exports.compressCallLog = compressCallLog;
-exports.findRepeatedSubsequencesForTest = void 0;
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+module.exports = __toCommonJS(callLog_exports);
 function compressCallLog(log) {
   const lines = [];
   for (const block of findRepeatedSubsequences(log)) {
     for (let i = 0; i < block.sequence.length; i++) {
       const line = block.sequence[i];
       const leadingWhitespace = line.match(/^\s*/);
-      const whitespacePrefix = '  ' + (leadingWhitespace === null || leadingWhitespace === void 0 ? void 0 : leadingWhitespace[0]) || '';
-      const countPrefix = `${block.count} × `;
-      if (block.count > 1 && i === 0) lines.push(whitespacePrefix + countPrefix + line.trim());else if (block.count > 1) lines.push(whitespacePrefix + ' '.repeat(countPrefix.length - 2) + '- ' + line.trim());else lines.push(whitespacePrefix + '- ' + line.trim());
+      const whitespacePrefix = "  " + leadingWhitespace?.[0] || "";
+      const countPrefix = `${block.count} \xD7 `;
+      if (block.count > 1 && i === 0)
+        lines.push(whitespacePrefix + countPrefix + line.trim());
+      else if (block.count > 1)
+        lines.push(whitespacePrefix + " ".repeat(countPrefix.length - 2) + "- " + line.trim());
+      else
+        lines.push(whitespacePrefix + "- " + line.trim());
     }
   }
   return lines;
@@ -39,41 +45,38 @@ function findRepeatedSubsequences(s) {
   const result = [];
   let i = 0;
   const arraysEqual = (a1, a2) => {
-    if (a1.length !== a2.length) return false;
+    if (a1.length !== a2.length)
+      return false;
     for (let j = 0; j < a1.length; j++) {
-      if (a1[j] !== a2[j]) return false;
+      if (a1[j] !== a2[j])
+        return false;
     }
     return true;
   };
   while (i < n) {
     let maxRepeatCount = 1;
-    let maxRepeatSubstr = [s[i]]; // Initialize with the element at index i
+    let maxRepeatSubstr = [s[i]];
     let maxRepeatLength = 1;
-
-    // Try substrings of length from 1 to the remaining length of the array
     for (let p = 1; p <= n - i; p++) {
-      const substr = s.slice(i, i + p); // Extract substring as array
+      const substr = s.slice(i, i + p);
       let k = 1;
-
-      // Count how many times the substring repeats consecutively
-      while (i + p * k <= n && arraysEqual(s.slice(i + p * (k - 1), i + p * k), substr)) k += 1;
-      k -= 1; // Adjust k since it increments one extra time in the loop
-
-      // Update the maximal repeating substring if necessary
+      while (i + p * k <= n && arraysEqual(s.slice(i + p * (k - 1), i + p * k), substr))
+        k += 1;
+      k -= 1;
       if (k > 1 && k * p > maxRepeatCount * maxRepeatLength) {
         maxRepeatCount = k;
         maxRepeatSubstr = substr;
         maxRepeatLength = p;
       }
     }
-
-    // Record the substring and its count
-    result.push({
-      sequence: maxRepeatSubstr,
-      count: maxRepeatCount
-    });
-    i += maxRepeatLength * maxRepeatCount; // Move index forward
+    result.push({ sequence: maxRepeatSubstr, count: maxRepeatCount });
+    i += maxRepeatLength * maxRepeatCount;
   }
   return result;
 }
-const findRepeatedSubsequencesForTest = exports.findRepeatedSubsequencesForTest = findRepeatedSubsequences;
+const findRepeatedSubsequencesForTest = findRepeatedSubsequences;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compressCallLog,
+  findRepeatedSubsequencesForTest
+});