lighthouse 10.4.0-dev.20230717 → 10.4.0-dev.20230719

package/cli/sentry-prompt.js

@@ -10,10 +10,12 @@ import log from 'lighthouse-logger';
 
 const MAXIMUM_WAIT_TIME = 20 * 1000;
 
-// eslint-disable-next-line max-len
+/* eslint-disable max-len */
 const MESSAGE = `${log.reset}We're constantly trying to improve Lighthouse and its reliability.\n  ` +
   `${log.reset}Learn more: https://github.com/GoogleChrome/lighthouse/blob/main/docs/error-reporting.md \n ` +
-  ` ${log.bold}May we anonymously report runtime exceptions to improve the tool over time?${log.reset} `; // eslint-disable-line max-len
+  ` ${log.bold}May we anonymously report runtime exceptions to improve the tool over time?${log.reset}\n  ` +
+  `We'll remember your choice, but you can also use the flag --[no-]enable-error-reporting`;
+/* eslint-enable max-len */
 
 /**
  * @return {Promise<boolean>}

package/core/audits/uses-rel-preconnect.js

@@ -14,6 +14,7 @@ import {LoadSimulator} from '../computed/load-simulator.js';
 import {ProcessedNavigation} from '../computed/processed-navigation.js';
 import {PageDependencyGraph} from '../computed/page-dependency-graph.js';
 import {LanternLargestContentfulPaint} from '../computed/metrics/lantern-largest-contentful-paint.js';
+import {LanternFirstContentfulPaint} from '../computed/metrics/lantern-first-contentful-paint.js';
 
 // Preconnect establishes a "clean" socket. Chrome's socket manager will keep an unused socket
 // around for 10s. Meaning, the time delta between processing preconnect a request should be <10s,
@@ -125,7 +126,8 @@ class UsesRelPreconnectAudit extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreconnectAudit.DEFAULT_PASS];
     const settings = context.settings;
 
-    let maxWasted = 0;
+    let maxWastedLcp = 0;
+    let maxWastedFcp = 0;
     /** @type {Array<LH.IcuMessage>} */
     const warnings = [];
 
@@ -144,7 +146,14 @@ class UsesRelPreconnectAudit extends Audit {
     /** @type {Set<string>} */
     const lcpGraphURLs = new Set();
     lcpGraph.traverse(node => {
-      if (node.type === 'network' ) lcpGraphURLs.add(node.record.url);
+      if (node.type === 'network') lcpGraphURLs.add(node.record.url);
+    });
+
+    const fcpGraph =
+      await LanternFirstContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
+    const fcpGraphURLs = new Set();
+    fcpGraph.traverse(node => {
+      if (node.type === 'network') fcpGraphURLs.add(node.record.url);
     });
 
     /** @type {Map<string, LH.Artifacts.NetworkRequest[]>}  */
@@ -216,7 +225,11 @@ class UsesRelPreconnectAudit extends Audit {
         return;
       }
 
-      maxWasted = Math.max(wastedMs, maxWasted);
+      maxWastedLcp = Math.max(wastedMs, maxWastedLcp);
+
+      if (fcpGraphURLs.has(firstRecordOfOrigin.url)) {
+        maxWastedFcp = Math.max(wastedMs, maxWastedLcp);
+      }
       results.push({
         url: securityOrigin,
         wastedMs: wastedMs,
@@ -240,6 +253,7 @@ class UsesRelPreconnectAudit extends Audit {
         score: 1,
         warnings: preconnectLinks.length >= 3 ?
           [...warnings, str_(UIStrings.tooManyPreconnectLinksWarning)] : warnings,
+        metricSavings: {LCP: maxWastedLcp, FCP: maxWastedFcp},
       };
     }
 
@@ -250,17 +264,18 @@ class UsesRelPreconnectAudit extends Audit {
     ];
 
     const details = Audit.makeOpportunityDetails(headings, results,
-      {overallSavingsMs: maxWasted, sortedBy: ['wastedMs']});
+      {overallSavingsMs: maxWastedLcp, sortedBy: ['wastedMs']});
 
     return {
-      score: ByteEfficiencyAudit.scoreForWastedMs(maxWasted),
-      numericValue: maxWasted,
+      score: ByteEfficiencyAudit.scoreForWastedMs(maxWastedLcp),
+      numericValue: maxWastedLcp,
       numericUnit: 'millisecond',
-      displayValue: maxWasted ?
-        str_(i18n.UIStrings.displayValueMsSavings, {wastedMs: maxWasted}) :
+      displayValue: maxWastedLcp ?
+        str_(i18n.UIStrings.displayValueMsSavings, {wastedMs: maxWastedLcp}) :
         '',
       warnings,
       details,
+      metricSavings: {LCP: maxWastedLcp, FCP: maxWastedFcp},
     };
   }
 }

package/core/gather/driver/execution-context.d.ts

@@ -11,6 +11,15 @@ export class ExecutionContext {
      * @return {string}
      */
     static serializeArguments(args: unknown[]): string;
+    /**
+     * Serializes an array of functions or strings.
+     *
+     * Also makes sure that an esbuild-bundled version of Lighthouse will
+     * continue to create working code to be executed within the browser.
+     * @param {Array<Function|string>=} deps
+     * @return {string}
+     */
+    static serializeDeps(deps?: Array<Function | string> | undefined): string;
     /** @param {LH.Gatherer.ProtocolSession} session */
     constructor(session: LH.Gatherer.ProtocolSession);
     _session: LH.Gatherer.ProtocolSession;
@@ -47,15 +56,6 @@ export class ExecutionContext {
      * @return {Promise<*>}
      */
     _evaluateInContext(expression: string, contextId: number | undefined): Promise<any>;
-    /**
-     * Serializes an array of functions or strings.
-     *
-     * Also makes sure that an esbuild-bundled version of Lighthouse will
-     * continue to create working code to be executed within the browser.
-     * @param {Array<Function|string>=} deps
-     * @return {string}
-     */
-    _serializeDeps(deps?: Array<Function | string> | undefined): string;
     /**
      * Note: Prefer `evaluate` instead.
      * Evaluate an expression in the context of the current page. If useIsolation is true, the expression

package/core/gather/driver/execution-context.js

@@ -155,28 +155,6 @@ class ExecutionContext {
     }
   }
 
-  /**
-   * Serializes an array of functions or strings.
-   *
-   * Also makes sure that an esbuild-bundled version of Lighthouse will
-   * continue to create working code to be executed within the browser.
-   * @param {Array<Function|string>=} deps
-   * @return {string}
-   */
-  _serializeDeps(deps) {
-    deps = [pageFunctions.esbuildFunctionNameStubString, ...deps || []];
-    return deps.map(dep => {
-      if (typeof dep === 'function') {
-        // esbuild will change the actual function name (ie. function actualName() {})
-        // always, despite minification settings, but preserve the real name in `actualName.name`
-        // (see esbuildFunctionNameStubString).
-        return `const ${dep.name} = ${dep}`;
-      } else {
-        return dep;
-      }
-    }).join('\n');
-  }
-
   /**
    * Note: Prefer `evaluate` instead.
    * Evaluate an expression in the context of the current page. If useIsolation is true, the expression
@@ -219,7 +197,7 @@ class ExecutionContext {
    */
   evaluate(mainFn, options) {
     const argsSerialized = ExecutionContext.serializeArguments(options.args);
-    const depsSerialized = this._serializeDeps(options.deps);
+    const depsSerialized = ExecutionContext.serializeDeps(options.deps);
 
     const expression = `(() => {
       ${depsSerialized}
@@ -239,7 +217,7 @@ class ExecutionContext {
    */
   async evaluateOnNewDocument(mainFn, options) {
     const argsSerialized = ExecutionContext.serializeArguments(options.args);
-    const depsSerialized = this._serializeDeps(options.deps);
+    const depsSerialized = ExecutionContext.serializeDeps(options.deps);
 
     const expression = `(() => {
       ${ExecutionContext._cachedNativesPreamble};
@@ -289,6 +267,28 @@ class ExecutionContext {
   static serializeArguments(args) {
     return args.map(arg => arg === undefined ? 'undefined' : JSON.stringify(arg)).join(',');
   }
+
+  /**
+   * Serializes an array of functions or strings.
+   *
+   * Also makes sure that an esbuild-bundled version of Lighthouse will
+   * continue to create working code to be executed within the browser.
+   * @param {Array<Function|string>=} deps
+   * @return {string}
+   */
+  static serializeDeps(deps) {
+    deps = [pageFunctions.esbuildFunctionNameStubString, ...deps || []];
+    return deps.map(dep => {
+      if (typeof dep === 'function') {
+        // esbuild will change the actual function name (ie. function actualName() {})
+        // always, despite minification settings, but preserve the real name in `actualName.name`
+        // (see esbuildFunctionNameStubString).
+        return `const ${dep.name} = ${dep}`;
+      } else {
+        return dep;
+      }
+    }).join('\n');
+  }
 }
 
 export {ExecutionContext};

package/core/lib/dependency-graph/simulator/network-analyzer.d.ts

@@ -65,39 +65,55 @@ export class NetworkAnalyzer {
      * single handshake.
      * This is the most accurate and preferred method of measurement when the data is available.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, number[]>}
+     * @param {RequestInfo} info
+     * @return {number[]|number|undefined}
      */
-    static _estimateRTTByOriginViaConnectionTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    static _estimateRTTViaConnectionTiming(info: {
+        record: LH.Artifacts.NetworkRequest;
+        timing: LH.Crdp.Network.ResourceTiming;
+        connectionReused?: boolean | undefined;
+    }): number[] | number | undefined;
     /**
      * Estimates the observed RTT to each origin based on how long a download took on a fresh connection.
      * NOTE: this will tend to overestimate the actual RTT quite significantly as the download can be
      * slow for other reasons as well such as bandwidth constraints.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, number[]>}
+     * @param {RequestInfo} info
+     * @return {number|undefined}
      */
-    static _estimateRTTByOriginViaDownloadTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    static _estimateRTTViaDownloadTiming(info: {
+        record: LH.Artifacts.NetworkRequest;
+        timing: LH.Crdp.Network.ResourceTiming;
+        connectionReused?: boolean | undefined;
+    }): number | undefined;
     /**
      * Estimates the observed RTT to each origin based on how long it took until Chrome could
      * start sending the actual request when a new connection was required.
      * NOTE: this will tend to overestimate the actual RTT as the request can be delayed for other
      * reasons as well such as more SSL handshakes if TLS False Start is not enabled.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, number[]>}
+     * @param {RequestInfo} info
+     * @return {number|undefined}
      */
-    static _estimateRTTByOriginViaSendStartTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    static _estimateRTTViaSendStartTiming(info: {
+        record: LH.Artifacts.NetworkRequest;
+        timing: LH.Crdp.Network.ResourceTiming;
+        connectionReused?: boolean | undefined;
+    }): number | undefined;
     /**
      * Estimates the observed RTT to each origin based on how long it took until Chrome received the
      * headers of the response (~TTFB).
      * NOTE: this is the most inaccurate way to estimate the RTT, but in some environments it's all
      * we have access to :(
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, number[]>}
+     * @param {RequestInfo} info
+     * @return {number|undefined}
      */
-    static _estimateRTTByOriginViaHeadersEndTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    static _estimateRTTViaHeadersEndTiming(info: {
+        record: LH.Artifacts.NetworkRequest;
+        timing: LH.Crdp.Network.ResourceTiming;
+        connectionReused?: boolean | undefined;
+    }): number | undefined;
     /**
      * Given the RTT to each origin, estimates the observed server response times.
      *

package/core/lib/dependency-graph/simulator/network-analyzer.js

@@ -132,33 +132,32 @@ class NetworkAnalyzer {
    * single handshake.
    * This is the most accurate and preferred method of measurement when the data is available.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, number[]>}
+   * @param {RequestInfo} info
+   * @return {number[]|number|undefined}
    */
-  static _estimateRTTByOriginViaConnectionTiming(records) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({timing, connectionReused, record}) => {
-      if (connectionReused) return;
-
-      // In LR, network records are missing connection timing, but we've smuggled it in via headers.
-      if (global.isLightrider && record.lrStatistics) {
-        if (record.protocol.startsWith('h3')) {
-          return record.lrStatistics.TCPMs;
-        } else {
-          return [record.lrStatistics.TCPMs / 2, record.lrStatistics.TCPMs / 2];
-        }
+  static _estimateRTTViaConnectionTiming(info) {
+    const {timing, connectionReused, record} = info;
+    if (connectionReused) return;
+
+    // In LR, network records are missing connection timing, but we've smuggled it in via headers.
+    if (global.isLightrider && record.lrStatistics) {
+      if (record.protocol.startsWith('h3')) {
+        return record.lrStatistics.TCPMs;
+      } else {
+        return [record.lrStatistics.TCPMs / 2, record.lrStatistics.TCPMs / 2];
       }
+    }
 
-      const {connectStart, sslStart, sslEnd, connectEnd} = timing;
-      if (connectEnd >= 0 && connectStart >= 0 && record.protocol.startsWith('h3')) {
-        // These values are equal to sslStart and sslEnd for h3.
-        return connectEnd - connectStart;
-      } else if (sslStart >= 0 && sslEnd >= 0 && sslStart !== connectStart) {
-        // SSL can also be more than 1 RT but assume False Start was used.
-        return [connectEnd - sslStart, sslStart - connectStart];
-      } else if (connectStart >= 0 && connectEnd >= 0) {
-        return connectEnd - connectStart;
-      }
-    });
+    const {connectStart, sslStart, sslEnd, connectEnd} = timing;
+    if (connectEnd >= 0 && connectStart >= 0 && record.protocol.startsWith('h3')) {
+      // These values are equal to sslStart and sslEnd for h3.
+      return connectEnd - connectStart;
+    } else if (sslStart >= 0 && sslEnd >= 0 && sslStart !== connectStart) {
+      // SSL can also be more than 1 RT but assume False Start was used.
+      return [connectEnd - sslStart, sslStart - connectStart];
+    } else if (connectStart >= 0 && connectEnd >= 0) {
+      return connectEnd - connectStart;
+    }
   }
 
   /**
@@ -166,26 +165,27 @@ class NetworkAnalyzer {
    * NOTE: this will tend to overestimate the actual RTT quite significantly as the download can be
    * slow for other reasons as well such as bandwidth constraints.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, number[]>}
+   * @param {RequestInfo} info
+   * @return {number|undefined}
    */
-  static _estimateRTTByOriginViaDownloadTiming(records) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing, connectionReused}) => {
-      if (connectionReused) return;
-      // Only look at downloads that went past the initial congestion window
-      if (record.transferSize <= INITIAL_CWD) return;
-      if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
+  static _estimateRTTViaDownloadTiming(info) {
+    const {timing, connectionReused, record} = info;
+    if (connectionReused) return;
 
-      // Compute the amount of time downloading everything after the first congestion window took
-      const totalTime = record.networkEndTime - record.networkRequestTime;
-      const downloadTimeAfterFirstByte = totalTime - timing.receiveHeadersEnd;
-      const numberOfRoundTrips = Math.log2(record.transferSize / INITIAL_CWD);
+    // Only look at downloads that went past the initial congestion window
+    if (record.transferSize <= INITIAL_CWD) return;
+    if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
 
-      // Ignore requests that required a high number of round trips since bandwidth starts to play
-      // a larger role than latency
-      if (numberOfRoundTrips > 5) return;
-      return downloadTimeAfterFirstByte / numberOfRoundTrips;
-    });
+    // Compute the amount of time downloading everything after the first congestion window took
+    const totalTime = record.networkEndTime - record.networkRequestTime;
+    const downloadTimeAfterFirstByte = totalTime - timing.receiveHeadersEnd;
+    const numberOfRoundTrips = Math.log2(record.transferSize / INITIAL_CWD);
+
+    // Ignore requests that required a high number of round trips since bandwidth starts to play
+    // a larger role than latency
+    if (numberOfRoundTrips > 5) return;
+
+    return downloadTimeAfterFirstByte / numberOfRoundTrips;
   }
 
   /**
@@ -194,21 +194,21 @@ class NetworkAnalyzer {
    * NOTE: this will tend to overestimate the actual RTT as the request can be delayed for other
    * reasons as well such as more SSL handshakes if TLS False Start is not enabled.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, number[]>}
+   * @param {RequestInfo} info
+   * @return {number|undefined}
    */
-  static _estimateRTTByOriginViaSendStartTiming(records) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing, connectionReused}) => {
-      if (connectionReused) return;
-      if (!Number.isFinite(timing.sendStart) || timing.sendStart < 0) return;
-
-      // Assume everything before sendStart was just DNS + (SSL)? + TCP handshake
-      // 1 RT for DNS, 1 RT (maybe) for SSL, 1 RT for TCP
-      let roundTrips = 1;
-      if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
-      if (record.parsedURL.scheme === 'https') roundTrips += 1;
-      return timing.sendStart / roundTrips;
-    });
+  static _estimateRTTViaSendStartTiming(info) {
+    const {timing, connectionReused, record} = info;
+    if (connectionReused) return;
+
+    if (!Number.isFinite(timing.sendStart) || timing.sendStart < 0) return;
+
+    // Assume everything before sendStart was just DNS + (SSL)? + TCP handshake
+    // 1 RT for DNS, 1 RT (maybe) for SSL, 1 RT for TCP
+    let roundTrips = 1;
+    if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
+    if (record.parsedURL.scheme === 'https') roundTrips += 1;
+    return timing.sendStart / roundTrips;
   }
 
   /**
@@ -217,34 +217,33 @@ class NetworkAnalyzer {
    * NOTE: this is the most inaccurate way to estimate the RTT, but in some environments it's all
    * we have access to :(
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, number[]>}
+   * @param {RequestInfo} info
+   * @return {number|undefined}
    */
-  static _estimateRTTByOriginViaHeadersEndTiming(records) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing, connectionReused}) => {
-      if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
-      if (!record.resourceType) return;
-
-      const serverResponseTimePercentage =
-        SERVER_RESPONSE_PERCENTAGE_OF_TTFB[record.resourceType] ||
-        DEFAULT_SERVER_RESPONSE_PERCENTAGE;
-      const estimatedServerResponseTime = timing.receiveHeadersEnd * serverResponseTimePercentage;
-
-      // When connection was reused...
-      // TTFB = 1 RT for request + server response time
-      let roundTrips = 1;
-
-      // When connection was fresh...
-      // TTFB = DNS + (SSL)? + TCP handshake + 1 RT for request + server response time
-      if (!connectionReused) {
-        roundTrips += 1; // DNS
-        if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
-        if (record.parsedURL.scheme === 'https') roundTrips += 1; // SSL
-      }
+  static _estimateRTTViaHeadersEndTiming(info) {
+    const {timing, connectionReused, record} = info;
+    if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
+    if (!record.resourceType) return;
+
+    const serverResponseTimePercentage =
+      SERVER_RESPONSE_PERCENTAGE_OF_TTFB[record.resourceType] ||
+      DEFAULT_SERVER_RESPONSE_PERCENTAGE;
+    const estimatedServerResponseTime = timing.receiveHeadersEnd * serverResponseTimePercentage;
+
+    // When connection was reused...
+    // TTFB = 1 RT for request + server response time
+    let roundTrips = 1;
+
+    // When connection was fresh...
+    // TTFB = DNS + (SSL)? + TCP handshake + 1 RT for request + server response time
+    if (!connectionReused) {
+      roundTrips += 1; // DNS
+      if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
+      if (record.parsedURL.scheme === 'https') roundTrips += 1; // SSL
+    }
 
-      // subtract out our estimated server response time
-      return Math.max((timing.receiveHeadersEnd - estimatedServerResponseTime) / roundTrips, 3);
-    });
+    // subtract out our estimated server response time
+    return Math.max((timing.receiveHeadersEnd - estimatedServerResponseTime) / roundTrips, 3);
   }
 
   /**
@@ -350,32 +349,61 @@ class NetworkAnalyzer {
       useHeadersEndEstimates = true,
     } = options || {};
 
-    let estimatesByOrigin = NetworkAnalyzer._estimateRTTByOriginViaConnectionTiming(records);
-    if (!estimatesByOrigin.size || forceCoarseEstimates) {
-      estimatesByOrigin = new Map();
-      const estimatesViaDownload = NetworkAnalyzer._estimateRTTByOriginViaDownloadTiming(records);
-      const estimatesViaSendStart = NetworkAnalyzer._estimateRTTByOriginViaSendStartTiming(records);
-      const estimatesViaTTFB = NetworkAnalyzer._estimateRTTByOriginViaHeadersEndTiming(records);
+    const connectionWasReused = NetworkAnalyzer.estimateIfConnectionWasReused(records);
+    const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
 
-      for (const [origin, estimates] of estimatesViaDownload.entries()) {
-        if (!useDownloadEstimates) continue;
-        estimatesByOrigin.set(origin, estimates);
+    const estimatesByOrigin = new Map();
+    for (const [origin, originRecords] of groupedByOrigin.entries()) {
+      /** @type {number[]} */
+      const originEstimates = [];
+
+      /**
+       * @param {(e: RequestInfo) => number[]|number|undefined} estimator
+       */
+      // eslint-disable-next-line no-inner-declarations
+      function collectEstimates(estimator, multiplier = 1) {
+        for (const record of originRecords) {
+          const timing = record.timing;
+          if (!timing) continue;
+
+          const estimates = estimator({
+            record,
+            timing,
+            connectionReused: connectionWasReused.get(record.requestId),
+          });
+          if (estimates === undefined) continue;
+
+          if (!Array.isArray(estimates)) {
+            originEstimates.push(estimates * multiplier);
+          } else {
+            originEstimates.push(...estimates.map(e => e * multiplier));
+          }
+        }
       }
 
-      for (const [origin, estimates] of estimatesViaSendStart.entries()) {
-        if (!useSendStartEstimates) continue;
-        const existing = estimatesByOrigin.get(origin) || [];
-        estimatesByOrigin.set(origin, existing.concat(estimates));
+      if (!forceCoarseEstimates) {
+        collectEstimates(this._estimateRTTViaConnectionTiming);
       }
 
-      for (const [origin, estimates] of estimatesViaTTFB.entries()) {
-        if (!useHeadersEndEstimates) continue;
-        const existing = estimatesByOrigin.get(origin) || [];
-        estimatesByOrigin.set(origin, existing.concat(estimates));
+      // Connection timing can be missing for a few reasons:
+      // - Origin was preconnected, which we don't have instrumentation for.
+      // - Trace began recording after a connection has already been established (for example, in timespan mode)
+      // - Perhaps Chrome established a connection already in the background (service worker? Just guessing here)
+      // - Not provided in LR netstack.
+      if (!originEstimates.length) {
+        if (useDownloadEstimates) {
+          collectEstimates(this._estimateRTTViaDownloadTiming, coarseEstimateMultiplier);
+        }
+        if (useSendStartEstimates) {
+          collectEstimates(this._estimateRTTViaSendStartTiming, coarseEstimateMultiplier);
+        }
+        if (useHeadersEndEstimates) {
+          collectEstimates(this._estimateRTTViaHeadersEndTiming, coarseEstimateMultiplier);
+        }
       }
 
-      for (const estimates of estimatesByOrigin.values()) {
-        estimates.forEach((x, i) => (estimates[i] = x * coarseEstimateMultiplier));
+      if (originEstimates.length) {
+        estimatesByOrigin.set(origin, originEstimates);
       }
     }
 

package/core/lib/page-functions.js

@@ -514,12 +514,11 @@ function truncate(string, characterLimit) {
 }
 
 // This is to support bundled lighthouse.
-// esbuild calls every function with a builtin `__name`, whose purpose is to store the
-// real name of the function so that esbuild can rename it to avoid collisions. There is no way to
-// disable this renaming, even if esbuild minification (and thus function name mangling) is disabled.
-// Anywhere we inject dynamically generated code at runtime for the browser to process,
-// we must manually include this function (because esbuild only does so once at the top scope
-// of the bundle, which is irrelevant for code executed in the browser).
+// esbuild calls every function with a builtin `__name` (since we set keepNames: true),
+// whose purpose is to store the real name of the function so that esbuild can rename it to avoid
+// collisions. Anywhere we inject dynamically generated code at runtime for the browser to process,
+// we must manually include this function (because esbuild only does so once at the top scope of
+// the bundle, which is irrelevant for code executed in the browser).
 const esbuildFunctionNameStubString = 'var __name=(fn)=>fn;';
 
 /** @type {string} */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "10.4.0-dev.20230717",
+  "version": "10.4.0-dev.20230719",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/tsconfig.json

@@ -30,6 +30,7 @@
     "shared/localization/locales/en-US.json",
   ],
   "exclude": [
+    "build/test/*test-case*.js",
     "core/test/audits/**/*.js",
     "core/test/fixtures/**/*.js",
     "core/test/computed/**/*.js",