@checkly/playwright-core 1.42.18 → 1.47.20-alpha

package/lib/server/frames.js

@@ -19,7 +19,6 @@ var _debugLogger = require("../utils/debugLogger");
 var _instrumentation = require("./instrumentation");
 var _protocolError = require("./protocolError");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
-var _locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 var _frameSelectors = require("./frameSelectors");
 var _errors = require("./errors");
 var _fileUploadUtils = require("./fileUploadUtils");
@@ -109,13 +108,13 @@ class FrameManager {
       return frame;
     }
   }
-  async waitForSignalsCreatedBy(progress, noWaitAfter, action, source) {
-    if (noWaitAfter) return action();
+  async waitForSignalsCreatedBy(progress, waitAfter, action) {
+    if (!waitAfter) return action();
     const barrier = new SignalBarrier(progress);
     this._signalBarriers.add(barrier);
     if (progress) progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
     const result = await action();
-    if (source === 'input') await this._page._delegate.inputActionEpilogue();
+    await this._page._delegate.inputActionEpilogue();
     await barrier.waitFor();
     this._signalBarriers.delete(barrier);
     // Resolve in the next task, after all waitForNavigations.
@@ -238,7 +237,7 @@ class FrameManager {
       request
     });
     if (request._isFavicon) {
-      if (route) route.continue(request, {
+      route === null || route === void 0 || route.continue({
         isFallback: true
       }).catch(() => {});
       return;
@@ -459,13 +458,13 @@ class Frame extends _instrumentation.SdkObject {
       return context.rawEvaluateJSON(expression);
     });
   }
-  nonStallingEvaluateInExistingContext(expression, isFunction, world) {
+  nonStallingEvaluateInExistingContext(expression, world) {
     return this.raceAgainstEvaluationStallingEvents(() => {
       var _this$_contextData$ge;
       const context = (_this$_contextData$ge = this._contextData.get(world)) === null || _this$_contextData$ge === void 0 ? void 0 : _this$_contextData$ge.context;
       if (!context) throw new Error('Frame does not yet have the execution context');
       return context.evaluateExpression(expression, {
-        isFunction
+        isFunction: false
       });
     });
   }
@@ -530,16 +529,19 @@ class Frame extends _instrumentation.SdkObject {
       referer = options.referer;
     }
     url = _helper.helper.completeUserURL(url);
-    const sameDocument = _helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, e => !e.newDocument);
-    const navigateResult = await this._page._delegate.navigateFrame(this, url, referer);
+    const navigationEvents = [];
+    const collectNavigations = arg => navigationEvents.push(arg);
+    this.on(Frame.Events.InternalNavigation, collectNavigations);
+    const navigateResult = await this._page._delegate.navigateFrame(this, url, referer).finally(() => this.off(Frame.Events.InternalNavigation, collectNavigations));
     let event;
     if (navigateResult.newDocumentId) {
-      sameDocument.dispose();
-      event = await _helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, event => {
+      const predicate = event => {
         // We are interested either in this specific document, or any other document that
         // did commit and replaced the expected document.
         return event.newDocument && (event.newDocument.documentId === navigateResult.newDocumentId || !event.error);
-      }).promise;
+      };
+      const events = navigationEvents.filter(predicate);
+      if (events.length) event = events[0];else event = await _helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, predicate).promise;
       if (event.newDocument.documentId !== navigateResult.newDocumentId) {
         // This is just a sanity check. In practice, new navigation should
         // cancel the previous one and report "request cancelled"-like error.
@@ -547,7 +549,10 @@ class Frame extends _instrumentation.SdkObject {
       }
       if (event.error) throw event.error;
     } else {
-      event = await sameDocument.promise;
+      // Wait for same document navigation.
+      const predicate = e => !e.newDocument;
+      const events = navigationEvents.filter(predicate);
+      if (events.length) event = events[0];else event = await _helper.helper.waitForEvent(progress, this, Frame.Events.InternalNavigation, predicate).promise;
     }
     if (!this._firedLifecycleEvents.has(waitUntil)) await _helper.helper.waitForEvent(progress, this, Frame.Events.AddLifecycle, e => e === waitUntil).promise;
     const request = event.newDocument ? event.newDocument.request : undefined;
@@ -618,73 +623,79 @@ 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}`);
-      const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-        const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
-        progress.throwIfAborted();
-        if (!resolved) {
-          if (state === 'hidden' || state === 'detached') return null;
-          return continuePolling;
+      return await this.waitForSelectorInternal(progress, selector, options, scope);
+    }, this._page._timeoutSettings.timeout(options));
+  }
+  async waitForSelectorInternal(progress, selector, options, scope) {
+    const {
+      state = 'visible'
+    } = options;
+    const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
+      const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
+      progress.throwIfAborted();
+      if (!resolved) {
+        if (state === 'hidden' || state === 'detached') return null;
+        return continuePolling;
+      }
+      const result = await resolved.injected.evaluateHandle((injected, {
+        info,
+        root
+      }) => {
+        const elements = injected.querySelectorAll(info.parsed, root || document);
+        const element = elements[0];
+        const visible = element ? injected.utils.isElementVisible(element) : false;
+        let log = '';
+        if (elements.length > 1) {
+          if (info.strict) throw injected.strictModeViolationError(info.parsed, elements);
+          log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
+        } else if (element) {
+          log = `  locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
         }
-        const result = await resolved.injected.evaluateHandle((injected, {
-          info,
-          root
-        }) => {
-          const elements = injected.querySelectorAll(info.parsed, root || document);
-          const element = elements[0];
-          const visible = element ? injected.isVisible(element) : false;
-          let log = '';
-          if (elements.length > 1) {
-            if (info.strict) throw injected.strictModeViolationError(info.parsed, elements);
-            log = `  locator resolved to ${elements.length} elements. Proceeding with the first one: ${injected.previewNode(elements[0])}`;
-          } else if (element) {
-            log = `  locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
-          }
-          return {
-            log,
-            element,
-            visible,
-            attached: !!element
-          };
-        }, {
-          info: resolved.info,
-          root: resolved.frame === this ? scope : undefined
-        });
-        const {
+        return {
           log,
+          element,
           visible,
-          attached
-        } = await result.evaluate(r => ({
-          log: r.log,
-          visible: r.visible,
-          attached: r.attached
-        }));
-        if (log) progress.log(log);
-        const success = {
-          attached,
-          detached: !attached,
-          visible,
-          hidden: !visible
-        }[state];
-        if (!success) {
-          result.dispose();
-          return continuePolling;
-        }
-        if (options.omitReturnValue) {
-          result.dispose();
-          return null;
-        }
-        const element = state === 'attached' || state === 'visible' ? await result.evaluateHandle(r => r.element) : null;
-        result.dispose();
-        if (!element) return null;
-        if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
-        try {
-          return await element._adoptTo(await resolved.frame._mainContext());
-        } catch (e) {
-          return continuePolling;
-        }
+          attached: !!element
+        };
+      }, {
+        info: resolved.info,
+        root: resolved.frame === this ? scope : undefined
       });
-      return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
-    }, this._page._timeoutSettings.timeout(options));
+      const {
+        log,
+        visible,
+        attached
+      } = await result.evaluate(r => ({
+        log: r.log,
+        visible: r.visible,
+        attached: r.attached
+      }));
+      if (log) progress.log(log);
+      const success = {
+        attached,
+        detached: !attached,
+        visible,
+        hidden: !visible
+      }[state];
+      if (!success) {
+        result.dispose();
+        return continuePolling;
+      }
+      if (options.omitReturnValue) {
+        result.dispose();
+        return null;
+      }
+      const element = state === 'attached' || state === 'visible' ? await result.evaluateHandle(r => r.element) : null;
+      result.dispose();
+      if (!element) return null;
+      if (options.__testHookBeforeAdoptNode) await options.__testHookBeforeAdoptNode();
+      try {
+        return await element._adoptTo(await resolved.frame._mainContext());
+      } catch (e) {
+        return continuePolling;
+      }
+    });
+    return scope ? scope._context._raceAgainstContextDestroyed(promise) : promise;
   }
   async dispatchEvent(metadata, selector, type, eventInit = {}, options = {}, scope) {
     await this._callOnElementOnceMatches(metadata, selector, (injectedScript, element, data) => {
@@ -753,10 +764,11 @@ class Frame extends _instrumentation.SdkObject {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
       await this.raceNavigationAction(progress, options, async () => {
+        var _this$_page$_delegate, _this$_page$_delegate2;
         const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
         progress.log(`setting frame content, waiting until "${waitUntil}"`);
         const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-        const context = await this._utilityContext();
+        const context = (_this$_page$_delegate = (_this$_page$_delegate2 = this._page._delegate).useMainWorldForSetContent) !== null && _this$_page$_delegate !== void 0 && _this$_page$_delegate.call(_this$_page$_delegate2) ? await this._mainContext() : await this._utilityContext();
         const lifecyclePromise = new Promise((resolve, reject) => {
           this._page._frameManager._consoleMessageTags.set(tag, () => {
             // Clear lifecycle right after document.open() - see 'tag' below.
@@ -787,6 +799,11 @@ class Frame extends _instrumentation.SdkObject {
   url() {
     return this._url;
   }
+  origin() {
+    var _network$parsedURL;
+    if (!this._url.startsWith('http')) return;
+    return (_network$parsedURL = network.parsedURL(this._url)) === null || _network$parsedURL === void 0 ? void 0 : _network$parsedURL.origin;
+  }
   parentFrame() {
     return this._parentFrame;
   }
@@ -812,7 +829,7 @@ class Frame extends _instrumentation.SdkObject {
       })).asElement();
       // Another round trip to the browser to ensure that we receive CSP error messages
       // (if any) logged asynchronously in a separate task on the content main thread.
-      if (this._page._delegate.cspErrorsAsynchronousForInlineScipts) await context.evaluate(() => true);
+      if (this._page._delegate.cspErrorsAsynchronousForInlineScripts) await context.evaluate(() => true);
       return result;
     });
     async function addScriptUrl(params) {
@@ -994,7 +1011,10 @@ class Frame extends _instrumentation.SdkObject {
   async click(metadata, selector, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, {
+        ...options,
+        waitAfter: !options.noWaitAfter
+      })));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dblclick(metadata, selector, options = {}) {
@@ -1012,6 +1032,7 @@ class Frame extends _instrumentation.SdkObject {
           await this._page.mouse.down();
         }, {
           ...options,
+          waitAfter: 'disabled',
           position: options.sourcePosition,
           timeout: progress.timeUntilDeadline()
         });
@@ -1023,6 +1044,7 @@ class Frame extends _instrumentation.SdkObject {
           await this._page.mouse.up();
         }, {
           ...options,
+          waitAfter: 'disabled',
           position: options.targetPosition,
           timeout: progress.timeUntilDeadline()
         });
@@ -1164,7 +1186,7 @@ class Frame extends _instrumentation.SdkObject {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems, params)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems)));
     }, this._page._timeoutSettings.timeout(params));
   }
   async type(metadata, selector, text, options = {}) {
@@ -1209,93 +1231,64 @@ class Frame extends _instrumentation.SdkObject {
     return result;
   }
   async _expectImpl(metadata, selector, options) {
-    let timeout = this._page._timeoutSettings.timeout(options);
-    const start = timeout > 0 ? (0, _utils.monotonicTime)() : 0;
     const lastIntermediateResult = {
       isSet: false
     };
-    const resultOneShot = await this._expectInternal(metadata, selector, options, true, timeout, lastIntermediateResult);
-    if (resultOneShot.matches !== options.isNot) return resultOneShot;
-    if (timeout > 0) {
-      const elapsed = (0, _utils.monotonicTime)() - start;
-      timeout -= elapsed;
-    }
-    if (timeout < 0) return {
-      matches: options.isNot,
-      log: metadata.log,
-      timedOut: true,
-      received: lastIntermediateResult.received
-    };
-    return await this._expectInternal(metadata, selector, options, false, timeout, lastIntermediateResult);
-  }
-  async _expectInternal(metadata, selector, options, oneShot, timeout, lastIntermediateResult) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(async progress => {
-      if (oneShot) {
+    try {
+      let timeout = this._page._timeoutSettings.timeout(options);
+      const start = timeout > 0 ? (0, _utils.monotonicTime)() : 0;
+
+      // Step 1: perform locator handlers checkpoint with a specified timeout.
+      await new _progress.ProgressController(metadata, this).run(async progress => {
         progress.log(`${metadata.apiName}${timeout ? ` with timeout ${timeout}ms` : ''}`);
         progress.log(`waiting for ${this._asLocator(selector)}`);
-      }
-      return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
-        var _info$world;
         await this._page.performLocatorHandlersCheckpoint(progress);
-        const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, {
-          strict: true
+      }, timeout);
+
+      // Step 2: perform one-shot expect check without a timeout.
+      // Supports the case of `expect(locator).toBeVisible({ timeout: 1 })`
+      // that should succeed when the locator is already visible.
+      try {
+        const resultOneShot = await new _progress.ProgressController(metadata, this).run(async progress => {
+          return await this._expectInternal(progress, selector, options, lastIntermediateResult);
         });
-        progress.throwIfAborted();
-        const {
-          frame,
-          info
-        } = selectorInFrame || {
-          frame: this,
-          info: undefined
-        };
-        const world = options.expression === 'to.have.property' ? 'main' : (_info$world = info === null || info === void 0 ? void 0 : info.world) !== null && _info$world !== void 0 ? _info$world : 'utility';
-        const context = await frame._context(world);
-        const injected = await context.injectedScript();
-        progress.throwIfAborted();
-        const {
-          log,
-          matches,
-          received,
-          missingRecevied
-        } = await injected.evaluate(async (injected, {
-          info,
-          options,
-          callId
-        }) => {
-          const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
-          const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
-          let log = '';
-          if (isArray) log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;else if (elements.length > 1) throw injected.strictModeViolationError(info.parsed, elements);else if (elements.length) log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-          if (callId) injected.markTargetElements(new Set(elements), callId);
+        if (resultOneShot.matches !== options.isNot) return resultOneShot;
+      } catch (e) {
+        if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
+        // Ignore any other errors from one-shot, we'll handle them during retries.
+      }
+      if (timeout > 0) {
+        const elapsed = (0, _utils.monotonicTime)() - start;
+        timeout -= elapsed;
+      }
+      if (timeout < 0) return {
+        matches: options.isNot,
+        log: metadata.log,
+        timedOut: true,
+        received: lastIntermediateResult.received
+      };
+
+      // Step 3: auto-retry expect with increasing timeouts. Bounded by the total remaining time.
+      return await new _progress.ProgressController(metadata, this).run(async progress => {
+        return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
+          await this._page.performLocatorHandlersCheckpoint(progress);
+          const {
+            matches,
+            received
+          } = await this._expectInternal(progress, selector, options, lastIntermediateResult);
+          if (matches === options.isNot) {
+            // Keep waiting in these cases:
+            // expect(locator).conditionThatDoesNotMatch
+            // expect(locator).not.conditionThatDoesMatch
+            return continuePolling;
+          }
           return {
-            log,
-            ...(await injected.expect(elements[0], options, elements))
+            matches,
+            received
           };
-        }, {
-          info,
-          options,
-          callId: metadata.id
         });
-        if (log) progress.log(log);
-        // Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
-        if (matches === options.isNot && !missingRecevied) {
-          lastIntermediateResult.received = received;
-          lastIntermediateResult.isSet = true;
-          if (!Array.isArray(received)) progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
-        }
-        if (!oneShot && matches === options.isNot) {
-          // Keep waiting in these cases:
-          // expect(locator).conditionThatDoesNotMatch
-          // expect(locator).not.conditionThatDoesMatch
-          return continuePolling;
-        }
-        return {
-          matches,
-          received
-        };
-      });
-    }, oneShot ? 0 : timeout).catch(e => {
+      }, timeout);
+    } catch (e) {
       // Q: Why not throw upon isSessionClosedError(e) as in other places?
       // A: We want user to receive a friendly message containing the last intermediate result.
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
@@ -1306,7 +1299,60 @@ class Frame extends _instrumentation.SdkObject {
       if (lastIntermediateResult.isSet) result.received = lastIntermediateResult.received;
       if (e instanceof _errors.TimeoutError) result.timedOut = true;
       return result;
+    }
+  }
+  async _expectInternal(progress, selector, options, lastIntermediateResult) {
+    var _info$world;
+    const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, {
+      strict: true
     });
+    progress.throwIfAborted();
+    const {
+      frame,
+      info
+    } = selectorInFrame || {
+      frame: this,
+      info: undefined
+    };
+    const world = options.expression === 'to.have.property' ? 'main' : (_info$world = info === null || info === void 0 ? void 0 : info.world) !== null && _info$world !== void 0 ? _info$world : 'utility';
+    const context = await frame._context(world);
+    const injected = await context.injectedScript();
+    progress.throwIfAborted();
+    const {
+      log,
+      matches,
+      received,
+      missingReceived
+    } = await injected.evaluate(async (injected, {
+      info,
+      options,
+      callId
+    }) => {
+      const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
+      const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
+      let log = '';
+      if (isArray) log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;else if (elements.length > 1) throw injected.strictModeViolationError(info.parsed, elements);else if (elements.length) log = `  locator resolved to ${injected.previewNode(elements[0])}`;
+      if (callId) injected.markTargetElements(new Set(elements), callId);
+      return {
+        log,
+        ...(await injected.expect(elements[0], options, elements))
+      };
+    }, {
+      info,
+      options,
+      callId: progress.metadata.id
+    });
+    if (log) progress.log(log);
+    // Note: missingReceived avoids `unexpected value "undefined"` when element was not found.
+    if (matches === options.isNot) {
+      lastIntermediateResult.received = missingReceived ? '<element(s) not found>' : received;
+      lastIntermediateResult.isSet = true;
+      if (!missingReceived && !Array.isArray(received)) progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);
+    }
+    return {
+      matches,
+      received
+    };
   }
   async _waitForFunctionExpression(metadata, expression, isFunction, arg, options, world = 'main') {
     const controller = new _progress.ProgressController(metadata, this);
@@ -1352,7 +1398,7 @@ class Frame extends _instrumentation.SdkObject {
                 fulfill(success);
                 return;
               }
-              if (typeof polling !== 'number') requestAnimationFrame(next);else setTimeout(next, polling);
+              if (typeof polling !== 'number') injected.builtinRequestAnimationFrame(next);else injected.builtinSetTimeout(next, polling);
             } catch (e) {
               reject(e);
             }
@@ -1546,7 +1592,7 @@ class Frame extends _instrumentation.SdkObject {
     }).catch(() => {});
   }
   _asLocator(selector) {
-    return (0, _locatorGenerators.asLocator)(this._page.attribution.playwright.options.sdkLanguage, selector);
+    return (0, _utils.asLocator)(this._page.attribution.playwright.options.sdkLanguage, selector);
   }
 }
 exports.Frame = Frame;

package/lib/server/har/harTracer.js

@@ -12,10 +12,7 @@ var _utils = require("../../utils");
 var _eventsHelper = require("../../utils/eventsHelper");
 var _utilsBundle = require("../../utilsBundle");
 var _manualPromise = require("../../utils/manualPromise");
-var _userAgent = require("../../utils/userAgent");
-var _network2 = require("../../utils/network");
 var _frames = require("../frames");
-var _mimeType = require("../../utils/mimeType");
 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; }
 /**
@@ -76,7 +73,7 @@ class HarTracer {
     }
   }
   _shouldIncludeEntryWithUrl(urlString) {
-    return !this._options.urlFilter || (0, _network2.urlMatches)(this._baseURL, urlString, this._options.urlFilter);
+    return !this._options.urlFilter || (0, _utils.urlMatches)(this._baseURL, urlString, this._options.urlFilter);
   }
   _entryForRequest(request) {
     return request[this._entrySymbol];
@@ -276,7 +273,7 @@ class HarTracer {
     });
     this._addBarrier(page || request.serviceWorker(), promise);
 
-    // Respose end timing is only available after the response event was received.
+    // Response end timing is only available after the response event was received.
     const timing = response.timing();
     harEntry.timings.receive = response.request()._responseEndTiming !== -1 ? _helper.helper.millisToRoundishMillis(response.request()._responseEndTiming - timing.responseStart) : -1;
     this._computeHarEntryTotalTime(harEntry);
@@ -318,7 +315,7 @@ class HarTracer {
     if (this._options.content === 'embed') {
       // Sometimes, we can receive a font/media file with textual mime type. Browser
       // still interprets them correctly, but the 'content-type' header is obviously wrong.
-      if ((0, _mimeType.isTextualMimeType)(content.mimeType) && resourceType !== 'font') {
+      if ((0, _utils.isTextualMimeType)(content.mimeType) && resourceType !== 'font') {
         content.text = buffer.toString();
       } else {
         content.text = buffer.toString('base64');
@@ -337,11 +334,6 @@ class HarTracer {
     const page = (_response$frame = response.frame()) === null || _response$frame === void 0 ? void 0 : _response$frame._page;
     const pageEntry = this._createPageEntryIfNeeded(page);
     const request = response.request();
-
-    // Prefer "response received" time over "request sent" time
-    // for the purpose of matching requests that were used in a particular snapshot.
-    // Note that both snapshot time and request time are taken here in the Node process.
-    if (this._options.includeTraceInfo) harEntry._monotonicTime = (0, _utils.monotonicTime)();
     harEntry.response = {
       status: response.status(),
       statusText: response.statusText(),
@@ -411,7 +403,7 @@ class HarTracer {
       version: '1.2',
       creator: {
         name: 'Playwright',
-        version: (0, _userAgent.getPlaywrightVersion)()
+        version: (0, _utils.getPlaywrightVersion)()
       },
       browser: {
         name: (context === null || context === void 0 ? void 0 : context._browser.options.name) || '',

package/lib/server/helper.js

@@ -95,9 +95,9 @@ class Helper {
       }
     };
   }
-  static formatBrowserLogs(logs) {
-    if (!logs.length) return '';
-    return '\n' + logs.join('\n');
+  static formatBrowserLogs(logs, disconnectReason) {
+    if (!disconnectReason && !logs.length) return '';
+    return '\n' + (disconnectReason ? disconnectReason + '\n' : '') + logs.join('\n');
   }
 }
 const helper = exports.helper = Helper;

package/lib/server/index.js

@@ -51,6 +51,12 @@ Object.defineProperty(exports, "installDefaultBrowsersForNpmInstall", {
     return _registry.installDefaultBrowsersForNpmInstall;
   }
 });
+Object.defineProperty(exports, "installRootRedirect", {
+  enumerable: true,
+  get: function () {
+    return _traceViewer.installRootRedirect;
+  }
+});
 Object.defineProperty(exports, "openTraceInBrowser", {
   enumerable: true,
   get: function () {
@@ -75,12 +81,24 @@ Object.defineProperty(exports, "registryDirectory", {
     return _registry.registryDirectory;
   }
 });
+Object.defineProperty(exports, "runTraceViewerApp", {
+  enumerable: true,
+  get: function () {
+    return _traceViewer.runTraceViewerApp;
+  }
+});
 Object.defineProperty(exports, "serverSideCallMetadata", {
   enumerable: true,
   get: function () {
     return _instrumentation.serverSideCallMetadata;
   }
 });
+Object.defineProperty(exports, "startTraceViewerServer", {
+  enumerable: true,
+  get: function () {
+    return _traceViewer.startTraceViewerServer;
+  }
+});
 Object.defineProperty(exports, "writeDockerVersion", {
   enumerable: true,
   get: function () {