@checkly/playwright-core 1.47.20-alpha → 1.48.20

package/lib/server/dispatchers/pageDispatcher.js

@@ -13,6 +13,7 @@ var _jsHandleDispatcher = require("./jsHandleDispatcher");
 var _elementHandlerDispatcher = require("./elementHandlerDispatcher");
 var _artifactDispatcher = require("./artifactDispatcher");
 var _utils = require("../../utils");
+var _webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -54,6 +55,7 @@ class PageDispatcher extends _dispatcher.Dispatcher {
     this._type_Page = true;
     this._page = void 0;
     this._subscriptions = new Set();
+    this._webSocketInterceptionPatterns = [];
     this.adopt(mainFrame);
     this._page = page;
     this.addObjectListener(_page.Page.Events.Close, () => {
@@ -133,6 +135,9 @@ class PageDispatcher extends _dispatcher.Dispatcher {
       response: _networkDispatchers.ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goForward(metadata, params))
     };
   }
+  async requestGC(params, metadata) {
+    await this._page.requestGC();
+  }
   async registerLocatorHandler(params, metadata) {
     const uid = this._page.registerLocatorHandler(params.selector, params.noWaitAfter);
     return {
@@ -174,6 +179,10 @@ class PageDispatcher extends _dispatcher.Dispatcher {
       return true;
     });
   }
+  async setWebSocketInterceptionPatterns(params, metadata) {
+    this._webSocketInterceptionPatterns = params.patterns;
+    if (params.patterns.length) await _webSocketRouteDispatcher.WebSocketRouteDispatcher.installIfNeeded(this.parentScope(), this._page);
+  }
   async expectScreenshot(params, metadata) {
     const mask = (params.mask || []).map(({
       frame,

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -39,9 +39,10 @@ class PlaywrightDispatcher extends _dispatcher.Dispatcher {
     const prelaunchedAndroidDeviceDispatcher = prelaunchedAndroidDevice ? new _androidDispatcher.AndroidDeviceDispatcher(android, prelaunchedAndroidDevice) : undefined;
     super(scope, playwright, 'Playwright', {
       chromium: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium),
-      bidi: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidi),
       firefox: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox),
       webkit: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit),
+      bidiChromium: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiChromium),
+      bidiFirefox: new _browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiFirefox),
       android,
       electron: new _electronDispatcher.ElectronDispatcher(scope, playwright.electron),
       utils: playwright.options.isServer ? undefined : new _localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),

package/lib/server/dispatchers/webSocketRouteDispatcher.js

@@ -0,0 +1,189 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebSocketRouteDispatcher = void 0;
+var _page = require("../page");
+var _dispatcher = require("./dispatcher");
+var _utils = require("../../utils");
+var _pageDispatcher = require("./pageDispatcher");
+var webSocketMockSource = _interopRequireWildcard(require("../../generated/webSocketMockSource"));
+var _eventsHelper = require("../../utils/eventsHelper");
+var _class;
+/**
+ * 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.
+ */
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const kBindingInstalledSymbol = Symbol('webSocketRouteBindingInstalled');
+const kInitScriptInstalledSymbol = Symbol('webSocketRouteInitScriptInstalled');
+class WebSocketRouteDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, id, url, frame) {
+    super(scope, {
+      guid: 'webSocketRoute@' + (0, _utils.createGuid)()
+    }, 'WebSocketRoute', {
+      url
+    });
+    this._type_WebSocketRoute = true;
+    this._id = void 0;
+    this._frame = void 0;
+    this._id = id;
+    this._frame = frame;
+    this._eventListeners.push(
+    // When the frame navigates or detaches, there will be no more communication
+    // from the mock websocket, so pretend like it was closed.
+    _eventsHelper.eventsHelper.addEventListener(frame._page, _page.Page.Events.InternalFrameNavigatedToNewDocument, frame => {
+      if (frame === this._frame) this._executionContextGone();
+    }), _eventsHelper.eventsHelper.addEventListener(frame._page, _page.Page.Events.FrameDetached, frame => {
+      if (frame === this._frame) this._executionContextGone();
+    }), _eventsHelper.eventsHelper.addEventListener(frame._page, _page.Page.Events.Close, () => this._executionContextGone()), _eventsHelper.eventsHelper.addEventListener(frame._page, _page.Page.Events.Crash, () => this._executionContextGone()));
+    WebSocketRouteDispatcher._idToDispatcher.set(this._id, this);
+    scope._dispatchEvent('webSocketRoute', {
+      webSocketRoute: this
+    });
+  }
+  static async installIfNeeded(contextDispatcher, target) {
+    const context = target instanceof _page.Page ? target.context() : target;
+    if (!context[kBindingInstalledSymbol]) {
+      context[kBindingInstalledSymbol] = true;
+      await context.exposeBinding('__pwWebSocketBinding', false, (source, payload) => {
+        if (payload.type === 'onCreate') {
+          const pageDispatcher = _pageDispatcher.PageDispatcher.fromNullable(contextDispatcher, source.page);
+          let scope;
+          if (pageDispatcher && matchesPattern(pageDispatcher, context._options.baseURL, payload.url)) scope = pageDispatcher;else if (matchesPattern(contextDispatcher, context._options.baseURL, payload.url)) scope = contextDispatcher;
+          if (scope) {
+            new WebSocketRouteDispatcher(scope, payload.id, payload.url, source.frame);
+          } else {
+            const request = {
+              id: payload.id,
+              type: 'passthrough'
+            };
+            source.frame.evaluateExpression(`globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {});
+          }
+          return;
+        }
+        const dispatcher = WebSocketRouteDispatcher._idToDispatcher.get(payload.id);
+        if (payload.type === 'onMessageFromPage') dispatcher === null || dispatcher === void 0 || dispatcher._dispatchEvent('messageFromPage', {
+          message: payload.data.data,
+          isBase64: payload.data.isBase64
+        });
+        if (payload.type === 'onMessageFromServer') dispatcher === null || dispatcher === void 0 || dispatcher._dispatchEvent('messageFromServer', {
+          message: payload.data.data,
+          isBase64: payload.data.isBase64
+        });
+        if (payload.type === 'onClosePage') dispatcher === null || dispatcher === void 0 || dispatcher._dispatchEvent('closePage', {
+          code: payload.code,
+          reason: payload.reason,
+          wasClean: payload.wasClean
+        });
+        if (payload.type === 'onCloseServer') dispatcher === null || dispatcher === void 0 || dispatcher._dispatchEvent('closeServer', {
+          code: payload.code,
+          reason: payload.reason,
+          wasClean: payload.wasClean
+        });
+      });
+    }
+    if (!target[kInitScriptInstalledSymbol]) {
+      target[kInitScriptInstalledSymbol] = true;
+      await target.addInitScript(`
+        (() => {
+          const module = {};
+          ${webSocketMockSource.source}
+          (module.exports.inject())(globalThis);
+        })();
+      `);
+    }
+  }
+  async connect(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'connect'
+    });
+  }
+  async ensureOpened(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'ensureOpened'
+    });
+  }
+  async sendToPage(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'sendToPage',
+      data: {
+        data: params.message,
+        isBase64: params.isBase64
+      }
+    });
+  }
+  async sendToServer(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'sendToServer',
+      data: {
+        data: params.message,
+        isBase64: params.isBase64
+      }
+    });
+  }
+  async closePage(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'closePage',
+      code: params.code,
+      reason: params.reason,
+      wasClean: params.wasClean
+    });
+  }
+  async closeServer(params) {
+    await this._evaluateAPIRequest({
+      id: this._id,
+      type: 'closeServer',
+      code: params.code,
+      reason: params.reason,
+      wasClean: params.wasClean
+    });
+  }
+  async _evaluateAPIRequest(request) {
+    await this._frame.evaluateExpression(`globalThis.__pwWebSocketDispatch(${JSON.stringify(request)})`).catch(() => {});
+  }
+  _onDispose() {
+    WebSocketRouteDispatcher._idToDispatcher.delete(this._id);
+  }
+  _executionContextGone() {
+    // We could enter here after being disposed upon page closure:
+    // - first from the recursive dispose inintiated by PageDispatcher;
+    // - then from our own page.on('close') listener.
+    if (!this._disposed) {
+      this._dispatchEvent('closePage', {
+        wasClean: true
+      });
+      this._dispatchEvent('closeServer', {
+        wasClean: true
+      });
+    }
+  }
+}
+exports.WebSocketRouteDispatcher = WebSocketRouteDispatcher;
+_class = WebSocketRouteDispatcher;
+WebSocketRouteDispatcher._idToDispatcher = new Map();
+function matchesPattern(dispatcher, baseURL, url) {
+  for (const pattern of dispatcher._webSocketInterceptionPatterns || []) {
+    const urlMatch = pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob;
+    if ((0, _utils.urlMatches)(baseURL, url, urlMatch)) return true;
+  }
+  return false;
+}

package/lib/server/download.js

@@ -39,15 +39,22 @@ class Download {
     this.url = url;
     this._suggestedFilename = suggestedFilename;
     page._browserContext._downloads.add(this);
-    if (suggestedFilename !== undefined) this._page.emit(_page.Page.Events.Download, this);
+    if (suggestedFilename !== undefined) this._fireDownloadEvent();
+  }
+  page() {
+    return this._page;
   }
   _filenameSuggested(suggestedFilename) {
     (0, _utils.assert)(this._suggestedFilename === undefined);
     this._suggestedFilename = suggestedFilename;
-    this._page.emit(_page.Page.Events.Download, this);
+    this._fireDownloadEvent();
   }
   suggestedFilename() {
     return this._suggestedFilename;
   }
+  _fireDownloadEvent() {
+    this._page.instrumentation.onDownload(this._page, this);
+    this._page.emit(_page.Page.Events.Download, this);
+  }
 }
 exports.Download = Download;

package/lib/server/fetch.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.GlobalAPIRequestContext = exports.BrowserContextAPIRequestContext = exports.APIRequestContext = void 0;
+exports.createProxyAgent = createProxyAgent;
 var _http = _interopRequireDefault(require("http"));
 var _https = _interopRequireDefault(require("https"));
 var _stream = require("stream");
@@ -21,8 +22,8 @@ var _happyEyeballs = require("../utils/happy-eyeballs");
 var _instrumentation = require("./instrumentation");
 var _progress = require("./progress");
 var _tracing = require("./trace/recorder/tracing");
-var _network = require("./network");
 var _socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var _tls = require("tls");
 var _fetch = require("../checkly/fetch");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
@@ -73,7 +74,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
     return uid;
   }
   async fetch(params, metadata) {
-    var _params$method, _defaults$clientCerti;
+    var _params$method;
     const defaults = this._defaultOptions();
     const headers = {
       'user-agent': defaults.userAgent,
@@ -93,7 +94,9 @@ class APIRequestContext extends _instrumentation.SdkObject {
       } of params.headers) setHeader(headers, name, value);
     }
     const requestUrl = new URL(params.url, defaults.baseURL);
-    if (params.params) {
+    if (params.encodedParams) {
+      requestUrl.search = params.encodedParams;
+    } else if (params.params) {
       for (const {
         name,
         value
@@ -104,23 +107,9 @@ class APIRequestContext extends _instrumentation.SdkObject {
     const method = ((_params$method = params.method) === null || _params$method === void 0 ? void 0 : _params$method.toUpperCase()) || 'GET';
     const proxy = defaults.proxy;
     let agent;
-    // When `clientCertificates` is present, we set the `proxy` property to our own socks proxy
-    // for the browser to use. However, we don't need it here, because we already respect
-    // `clientCertificates` when fetching from Node.js.
-    if (proxy && !((_defaults$clientCerti = defaults.clientCertificates) !== null && _defaults$clientCerti !== void 0 && _defaults$clientCerti.length) && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) {
-      var _proxyOpts$protocol;
-      const proxyOpts = _url.default.parse(proxy.server);
-      if ((_proxyOpts$protocol = proxyOpts.protocol) !== null && _proxyOpts$protocol !== void 0 && _proxyOpts$protocol.startsWith('socks')) {
-        agent = new _utilsBundle.SocksProxyAgent({
-          host: proxyOpts.hostname,
-          port: proxyOpts.port || undefined
-        });
-      } else {
-        if (proxy.username) proxyOpts.auth = `${proxy.username}:${proxy.password || ''}`;
-        // TODO: We should use HttpProxyAgent conditional on proxyOpts.protocol instead of always using CONNECT method.
-        agent = new _utilsBundle.HttpsProxyAgent(proxyOpts);
-      }
-    }
+    // We skip 'per-context' in order to not break existing users. 'per-context' was previously used to
+    // workaround an upstream Chromium bug. Can be removed in the future.
+    if (proxy && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) agent = createProxyAgent(proxy);
     const timeout = defaults.timeoutSettings.timeout(params);
     const deadline = timeout && (0, _utils.monotonicTime)() + timeout;
     const options = {
@@ -202,6 +191,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
       try {
         return await this._sendRequest(progress, url, options, postData);
       } catch (e) {
+        e = (0, _socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
         if (maxRetries === 0) throw e;
         if (i === maxRetries || options.deadline && (0, _utils.monotonicTime)() + backoff > options.deadline) throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
         // Retry on connection reset only.
@@ -239,10 +229,33 @@ class APIRequestContext extends _instrumentation.SdkObject {
         ...options,
         agent
       };
-      const timings = (0, _fetch.initializeTimings)();
+      const checklyTimings = (0, _fetch.initializeTimings)();
+      const startAt = (0, _utils.monotonicTime)();
+      let dnsLookupAt;
+      let tcpConnectionAt;
+      let tlsHandshakeAt;
+      let requestFinishAt;
+      let serverIPAddress;
+      let serverPort;
+      let securityDetails;
+      const listeners = [];
       const request = requestConstructor(url, requestOptions, async response => {
-        timings.values.response = _perf_hooks.performance.now() - timings.values.startTimeNow;
+        const responseAt = (0, _utils.monotonicTime)();
+        checklyTimings.values.response = _perf_hooks.performance.now() - checklyTimings.values.startTimeNow;
         const notifyRequestFinished = body => {
+          var _tlsHandshakeAt;
+          const endAt = (0, _utils.monotonicTime)();
+          // spec: http://www.softwareishard.com/blog/har-12-spec/#timings
+          const timings = {
+            send: requestFinishAt - startAt,
+            wait: responseAt - requestFinishAt,
+            receive: endAt - responseAt,
+            dns: dnsLookupAt ? dnsLookupAt - startAt : -1,
+            connect: ((_tlsHandshakeAt = tlsHandshakeAt) !== null && _tlsHandshakeAt !== void 0 ? _tlsHandshakeAt : tcpConnectionAt) - startAt,
+            // "If [ssl] is defined then the time is also included in the connect field "
+            ssl: tlsHandshakeAt ? tlsHandshakeAt - tcpConnectionAt : -1,
+            blocked: -1
+          };
           const requestFinishedEvent = {
             requestEvent,
             httpVersion: response.httpVersion,
@@ -251,7 +264,11 @@ class APIRequestContext extends _instrumentation.SdkObject {
             headers: response.headers,
             rawHeaders: response.rawHeaders,
             cookies,
-            body
+            body,
+            timings,
+            serverIPAddress,
+            serverPort,
+            securityDetails
           };
           this.emit(APIRequestContext.Events.RequestFinished, requestFinishedEvent);
         };
@@ -338,7 +355,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
         response.on('aborted', () => reject(new Error('aborted')));
         const chunks = [];
         const notifyBodyFinished = () => {
-          timings.values.endAt = _perf_hooks.performance.now();
+          checklyTimings.values.endAt = _perf_hooks.performance.now();
           const body = Buffer.concat(chunks);
           notifyRequestFinished(body);
           fulfill({
@@ -350,10 +367,10 @@ class APIRequestContext extends _instrumentation.SdkObject {
             timings: {
               //@ts-ignore
               values: {
-                ...timings.values,
+                ...checklyTimings.values,
                 ..._happyEyeballs.httpHappyEyeballsTimings.values
               },
-              agent: _happyEyeballs.httpHappyEyeballsTimings.agent || timings.agent
+              agent: _happyEyeballs.httpHappyEyeballsTimings.agent || checklyTimings.agent
             }
           });
         };
@@ -386,14 +403,44 @@ class APIRequestContext extends _instrumentation.SdkObject {
         body.on('data', chunk => chunks.push(chunk));
         body.on('end', notifyBodyFinished);
       });
-      request.on('error', error => reject((0, _socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(error)));
-      (0, _fetch.addRequestListeners)(request, timings);
-      const disposeListener = () => {
+      (0, _fetch.addRequestListeners)(request, checklyTimings);
+      request.on('error', reject);
+      listeners.push(_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
         reject(new Error('Request context disposed.'));
         request.destroy();
-      };
-      this.on(APIRequestContext.Events.Dispose, disposeListener);
-      request.on('close', () => this.off(APIRequestContext.Events.Dispose, disposeListener));
+      }));
+      request.on('close', () => _utils.eventsHelper.removeEventListeners(listeners));
+      request.on('socket', socket => {
+        // happy eyeballs don't emit lookup and connect events, so we use our custom ones
+        const happyEyeBallsTimings = (0, _happyEyeballs.timingForSocket)(socket);
+        dnsLookupAt = happyEyeBallsTimings.dnsLookupAt;
+        tcpConnectionAt = happyEyeBallsTimings.tcpConnectionAt;
+
+        // non-happy-eyeballs sockets
+        listeners.push(_utils.eventsHelper.addEventListener(socket, 'lookup', () => {
+          dnsLookupAt = (0, _utils.monotonicTime)();
+        }), _utils.eventsHelper.addEventListener(socket, 'connect', () => {
+          tcpConnectionAt = (0, _utils.monotonicTime)();
+        }), _utils.eventsHelper.addEventListener(socket, 'secureConnect', () => {
+          tlsHandshakeAt = (0, _utils.monotonicTime)();
+          if (socket instanceof _tls.TLSSocket) {
+            var _socket$getProtocol;
+            const peerCertificate = socket.getPeerCertificate();
+            securityDetails = {
+              protocol: (_socket$getProtocol = socket.getProtocol()) !== null && _socket$getProtocol !== void 0 ? _socket$getProtocol : undefined,
+              subjectName: peerCertificate.subject.CN,
+              validFrom: new Date(peerCertificate.valid_from).getTime() / 1000,
+              validTo: new Date(peerCertificate.valid_to).getTime() / 1000,
+              issuer: peerCertificate.issuer.CN
+            };
+          }
+        }));
+        serverIPAddress = socket.remoteAddress;
+        serverPort = socket.remotePort;
+      });
+      request.on('finish', () => {
+        requestFinishAt = (0, _utils.monotonicTime)();
+      });
       progress.log(`→ ${options.method} ${url.toString()}`);
       if (options.headers) {
         for (const [name, value] of Object.entries(options.headers)) progress.log(`  ${name}: ${value}`);
@@ -539,6 +586,19 @@ class GlobalAPIRequestContext extends APIRequestContext {
   }
 }
 exports.GlobalAPIRequestContext = GlobalAPIRequestContext;
+function createProxyAgent(proxy) {
+  var _proxyOpts$protocol;
+  const proxyOpts = _url.default.parse(proxy.server);
+  if ((_proxyOpts$protocol = proxyOpts.protocol) !== null && _proxyOpts$protocol !== void 0 && _proxyOpts$protocol.startsWith('socks')) {
+    return new _utilsBundle.SocksProxyAgent({
+      host: proxyOpts.hostname,
+      port: proxyOpts.port || undefined
+    });
+  }
+  if (proxy.username) proxyOpts.auth = `${proxy.username}:${proxy.password || ''}`;
+  // TODO: We should use HttpProxyAgent conditional on proxyOpts.protocol instead of always using CONNECT method.
+  return new _utilsBundle.HttpsProxyAgent(proxyOpts);
+}
 function toHeadersArray(rawHeaders) {
   const result = [];
   for (let i = 0; i < rawHeaders.length; i += 2) result.push({
@@ -549,26 +609,9 @@ function toHeadersArray(rawHeaders) {
 }
 const redirectStatus = [301, 302, 303, 307, 308];
 function parseCookie(header) {
-  const pairs = header.split(';').filter(s => s.trim().length > 0).map(p => {
-    let key = '';
-    let value = '';
-    const separatorPos = p.indexOf('=');
-    if (separatorPos === -1) {
-      // If only a key is specified, the value is left undefined.
-      key = p.trim();
-    } else {
-      // Otherwise we assume that the key is the element before the first `=`
-      key = p.slice(0, separatorPos).trim();
-      // And the value is the rest of the string.
-      value = p.slice(separatorPos + 1).trim();
-    }
-    return [key, value];
-  });
-  if (!pairs.length) return null;
-  const [name, value] = pairs[0];
+  const raw = (0, _cookieStore.parseRawCookie)(header);
+  if (!raw) return null;
   const cookie = {
-    name,
-    value,
     domain: '',
     path: '',
     expires: -1,
@@ -576,55 +619,9 @@ function parseCookie(header) {
     secure: false,
     // From https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
     // The cookie-sending behavior if SameSite is not specified is SameSite=Lax.
-    sameSite: 'Lax'
+    sameSite: 'Lax',
+    ...raw
   };
-  for (let i = 1; i < pairs.length; i++) {
-    const [name, value] = pairs[i];
-    switch (name.toLowerCase()) {
-      case 'expires':
-        const expiresMs = +new Date(value);
-        // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.1
-        if (isFinite(expiresMs)) {
-          if (expiresMs <= 0) cookie.expires = 0;else cookie.expires = Math.min(expiresMs / 1000, _network.kMaxCookieExpiresDateInSeconds);
-        }
-        break;
-      case 'max-age':
-        const maxAgeSec = parseInt(value, 10);
-        if (isFinite(maxAgeSec)) {
-          // From https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.2
-          // If delta-seconds is less than or equal to zero (0), let expiry-time
-          // be the earliest representable date and time.
-          if (maxAgeSec <= 0) cookie.expires = 0;else cookie.expires = Math.min(Date.now() / 1000 + maxAgeSec, _network.kMaxCookieExpiresDateInSeconds);
-        }
-        break;
-      case 'domain':
-        cookie.domain = value.toLocaleLowerCase() || '';
-        if (cookie.domain && !cookie.domain.startsWith('.') && cookie.domain.includes('.')) cookie.domain = '.' + cookie.domain;
-        break;
-      case 'path':
-        cookie.path = value || '';
-        break;
-      case 'secure':
-        cookie.secure = true;
-        break;
-      case 'httponly':
-        cookie.httpOnly = true;
-        break;
-      case 'samesite':
-        switch (value.toLowerCase()) {
-          case 'none':
-            cookie.sameSite = 'None';
-            break;
-          case 'lax':
-            cookie.sameSite = 'Lax';
-            break;
-          case 'strict':
-            cookie.sameSite = 'Strict';
-            break;
-        }
-        break;
-    }
-  }
   return cookie;
 }
 function serializePostData(params, headers) {

package/lib/server/firefox/ffBrowser.js

@@ -53,7 +53,8 @@ class FFBrowser extends _browser.Browser {
       browser._defaultContext = new FFBrowserContext(browser, undefined, options.persistent);
       promises.push(browser._defaultContext._initialize());
     }
-    if (options.proxy) promises.push(browser.session.send('Browser.setBrowserProxy', toJugglerProxyOptions(options.proxy)));
+    const proxy = options.originalLaunchOptions.proxyOverride || options.proxy;
+    if (proxy) promises.push(browser.session.send('Browser.setBrowserProxy', toJugglerProxyOptions(proxy)));
     await Promise.all(promises);
     return browser;
   }
@@ -205,7 +206,7 @@ class FFBrowserContext extends _browserContext.BrowserContext {
       browserContextId,
       bypassCSP: true
     }));
-    if (this._options.ignoreHTTPSErrors) promises.push(this._browser.session.send('Browser.setIgnoreHTTPSErrors', {
+    if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors) promises.push(this._browser.session.send('Browser.setIgnoreHTTPSErrors', {
       browserContextId,
       ignoreHTTPSErrors: true
     }));
@@ -255,10 +256,11 @@ class FFBrowserContext extends _browserContext.BrowserContext {
         });
       }));
     }
-    if (this._options.proxy) {
+    const proxy = this._options.proxyOverride || this._options.proxy;
+    if (proxy) {
       promises.push(this._browser.session.send('Browser.setContextProxy', {
         browserContextId: this._browserContextId,
-        ...toJugglerProxyOptions(this._options.proxy)
+        ...toJugglerProxyOptions(proxy)
       }));
     }
     await Promise.all(promises);

package/lib/server/firefox/ffExecutionContext.js

@@ -101,9 +101,6 @@ class FFExecutionContext {
       objectId
     });
   }
-  objectCount(objectId) {
-    throw new Error('Method not implemented in Firefox.');
-  }
 }
 exports.FFExecutionContext = FFExecutionContext;
 function checkException(exceptionDetails) {

package/lib/server/firefox/ffPage.js

@@ -360,6 +360,9 @@ class FFPage {
     });
     return success;
   }
+  async requestGC() {
+    await this._session.send('Heap.collectGarbage');
+  }
   async addInitScript(initScript, worldName) {
     this._initScripts.push({
       initScript,

package/lib/server/firefox/firefox.js

@@ -92,19 +92,8 @@ class Firefox extends _browserType.BrowserType {
   }
 }
 exports.Firefox = Firefox;
-class JugglerReadyState {
-  constructor() {
-    this._jugglerPromise = new _utils.ManualPromise();
-  }
+class JugglerReadyState extends _browserType.BrowserReadyState {
   onBrowserOutput(message) {
-    if (message.includes('Juggler listening to the pipe')) this._jugglerPromise.resolve();
-  }
-  onBrowserExit() {
-    // Unblock launch when browser prematurely exits.
-    this._jugglerPromise.resolve();
-  }
-  async waitUntilReady() {
-    await this._jugglerPromise;
-    return {};
+    if (message.includes('Juggler listening to the pipe')) this._wsEndpoint.resolve(undefined);
   }
 }

package/lib/server/frameSelectors.js

@@ -165,7 +165,7 @@ class FrameSelectors {
 exports.FrameSelectors = FrameSelectors;
 async function adoptIfNeeded(handle, context) {
   if (handle._context === context) return handle;
-  const adopted = handle._page._delegate.adoptElementHandle(handle, context);
+  const adopted = await handle._page._delegate.adoptElementHandle(handle, context);
   handle.dispose();
   return adopted;
 }

package/lib/server/frames.js

@@ -623,14 +623,15 @@ class Frame extends _instrumentation.SdkObject {
     if (!['attached', 'detached', 'visible', 'hidden'].includes(state)) throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
     return controller.run(async progress => {
       progress.log(`waiting for ${this._asLocator(selector)}${state === 'attached' ? '' : ' to be ' + state}`);
-      return await this.waitForSelectorInternal(progress, selector, options, scope);
+      return await this.waitForSelectorInternal(progress, selector, true, options, scope);
     }, this._page._timeoutSettings.timeout(options));
   }
-  async waitForSelectorInternal(progress, selector, options, scope) {
+  async waitForSelectorInternal(progress, selector, performLocatorHandlersCheckpoint, options, scope) {
     const {
       state = 'visible'
     } = options;
     const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
+      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       progress.throwIfAborted();
       if (!resolved) {