lighthouse 10.4.0 → 11.0.0

package/core/index.cjs

@@ -11,12 +11,6 @@ const lighthouse = async function lighthouse(...args) {
   return lighthouse(...args);
 };
 
-/** @type {import('./index.js')['legacyNavigation']} */
-const legacyNavigation = async function legacyNavigation(...args) {
-  const {legacyNavigation} = await import('./index.js');
-  return legacyNavigation(...args);
-};
-
 /** @type {import('./index.js')['startFlow']} */
 const startFlow = async function startFlow(...args) {
   const {startFlow} = await import('./index.js');
@@ -42,7 +36,6 @@ const snapshot = async function snapshot(...args) {
 };
 
 module.exports = lighthouse;
-module.exports.legacyNavigation = legacyNavigation;
 module.exports.startFlow = startFlow;
 module.exports.navigation = navigation;
 module.exports.startTimespan = startTimespan;

package/core/index.d.ts

@@ -5,8 +5,6 @@ export { NetworkRecords } from "./computed/network-records.js";
 export { default as defaultConfig } from "./config/default-config.js";
 export { default as desktopConfig } from "./config/desktop-config.js";
 export * from "../types/lh.js";
-export type Connection = import('./legacy/gather/connections/connection.js').Connection;
-/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
 /**
  * Run Lighthouse.
  * @param {string=} url The URL to test. Optional if running in auditMode.
@@ -18,19 +16,6 @@ export type Connection = import('./legacy/gather/connections/connection.js').Con
  * @return {Promise<LH.RunnerResult|undefined>}
  */
 declare function lighthouse(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, page?: LH.Puppeteer.Page | undefined): Promise<LH.RunnerResult | undefined>;
-/**
- * Run Lighthouse using the legacy navigation runner.
- * This is left in place for any clients that don't support FR navigations yet (e.g. Lightrider)
- * @deprecated
- * @param {string=} url The URL to test. Optional if running in auditMode.
- * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
- *   they will override any settings in the config.
- * @param {LH.Config=} config Configuration for the Lighthouse run. If
- *   not present, the default config is used.
- * @param {Connection=} userConnection
- * @return {Promise<LH.RunnerResult|undefined>}
- */
-export function legacyNavigation(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, userConnection?: Connection | undefined): Promise<LH.RunnerResult | undefined>;
 /**
  * @param {LH.Puppeteer.Page} page
  * @param {LH.UserFlow.Options} [options]

package/core/index.js

@@ -4,13 +4,8 @@
  * 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.
  */
 
-import log from 'lighthouse-logger';
-
+import Trace from './gather/gatherers/trace.js';
 import {Runner} from './runner.js';
-import {CriConnection} from './legacy/gather/connections/cri.js';
-import {LegacyResolvedConfig} from './legacy/config/config.js';
-import UrlUtils from './lib/url-utils.js';
-import {Driver} from './legacy/gather/driver.js';
 import {UserFlow, auditGatherSteps} from './user-flow.js';
 import {ReportGenerator} from '../report/generator/report-generator.js';
 import {startTimespanGather} from './gather/timespan-runner.js';
@@ -18,8 +13,6 @@ import {snapshotGather} from './gather/snapshot-runner.js';
 import {navigationGather} from './gather/navigation-runner.js';
 import * as LH from '../types/lh.js';
 
-/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
-
 /*
  * The relationship between these root modules:
  *
@@ -47,36 +40,6 @@ async function lighthouse(url, flags = {}, config, page) {
   return navigation(page, url, {config, flags});
 }
 
-/**
- * Run Lighthouse using the legacy navigation runner.
- * This is left in place for any clients that don't support FR navigations yet (e.g. Lightrider)
- * @deprecated
- * @param {string=} url The URL to test. Optional if running in auditMode.
- * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
- *   they will override any settings in the config.
- * @param {LH.Config=} config Configuration for the Lighthouse run. If
- *   not present, the default config is used.
- * @param {Connection=} userConnection
- * @return {Promise<LH.RunnerResult|undefined>}
- */
-async function legacyNavigation(url, flags = {}, config, userConnection) {
-  // set logging preferences, assume quiet
-  flags.logLevel = flags.logLevel || 'error';
-  log.setLevel(flags.logLevel);
-
-  const resolvedConfig = await LegacyResolvedConfig.fromJson(config, flags);
-  const computedCache = new Map();
-  const options = {resolvedConfig, computedCache};
-  const connection = userConnection || new CriConnection(flags.port, flags.hostname);
-
-  // kick off a lighthouse run
-  const artifacts = await Runner.gather(() => {
-    const requestedUrl = UrlUtils.normalizeUrl(url);
-    return Runner._gatherArtifactsFromBrowser(requestedUrl, options, connection);
-  }, options);
-  return Runner.audit(artifacts, options);
-}
-
 /**
  * @param {LH.Puppeteer.Page} page
  * @param {LH.UserFlow.Options} [options]
@@ -150,7 +113,7 @@ function getAuditList() {
   return Runner.getAuditList();
 }
 
-const traceCategories = Driver.traceCategories;
+const traceCategories = Trace.getDefaultTraceCategories();
 
 export default lighthouse;
 export {Audit} from './audits/audit.js';
@@ -160,7 +123,6 @@ export {default as defaultConfig} from './config/default-config.js';
 export {default as desktopConfig} from './config/desktop-config.js';
 export * from '../types/lh.js';
 export {
-  legacyNavigation,
   startFlow,
   navigation,
   startTimespan,

package/core/lib/asset-saver.js

@@ -62,6 +62,9 @@ function loadArtifacts(basePath) {
     if (passName === 'defaultPass') {
       artifacts.DevtoolsLog = devtoolsLog;
     }
+    if (passName === 'pageLoadError-defaultPass') {
+      artifacts.DevtoolsLogError = devtoolsLog;
+    }
   });
 
   // load traces
@@ -74,6 +77,9 @@ function loadArtifacts(basePath) {
     if (passName === 'defaultPass') {
       artifacts.Trace = artifacts.traces[passName];
     }
+    if (passName === 'pageLoadError-defaultPass') {
+      artifacts.TraceError = artifacts.traces[passName];
+    }
   });
 
   if (Array.isArray(artifacts.Timing)) {
@@ -220,13 +226,17 @@ async function saveArtifacts(artifacts, basePath) {
   const {traces, devtoolsLogs, DevtoolsLog, Trace, ...restArtifacts} = artifacts;
 
   // save traces
-  for (const [passName, trace] of Object.entries(traces)) {
-    await saveTrace(trace, `${basePath}/${passName}${traceSuffix}`);
+  if (traces) {
+    for (const [passName, trace] of Object.entries(traces)) {
+      await saveTrace(trace, `${basePath}/${passName}${traceSuffix}`);
+    }
   }
 
   // save devtools log
-  for (const [passName, devtoolsLog] of Object.entries(devtoolsLogs)) {
-    await saveDevtoolsLog(devtoolsLog, `${basePath}/${passName}${devtoolsLogSuffix}`);
+  if (devtoolsLogs) {
+    for (const [passName, devtoolsLog] of Object.entries(devtoolsLogs)) {
+      await saveDevtoolsLog(devtoolsLog, `${basePath}/${passName}${devtoolsLogSuffix}`);
+    }
   }
 
   // save everything else, using a replacer to serialize LighthouseErrors in the artifacts.

package/core/lib/axe.js

@@ -7,7 +7,7 @@
 import fs from 'fs';
 import {createRequire} from 'module';
 
-// This is removed by rollup, because the only usage is to resolve a module path
+// This is removed by esbuild (if minified), because the only usage is to resolve a module path
 // but that is replaced by the inline-fs plugin, leaving `require` unused.
 const require = /* #__PURE__ */ createRequire(import.meta.url);
 const axeSource = fs.readFileSync(require.resolve('axe-core/axe.min.js'), 'utf8');

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/emulation.d.ts

@@ -1,43 +1,43 @@
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
  * @return {Promise<void>}
  */
-export function emulate(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings): Promise<void>;
+export function emulate(session: LH.Gatherer.ProtocolSession, settings: LH.Config.Settings): Promise<void>;
 /**
  * Sets the throttling options specified in config settings, clearing existing network throttling if
  * throttlingMethod is not `devtools` (but not CPU throttling, suspected requirement of WPT-compat).
  *
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
  * @return {Promise<void>}
  */
-export function throttle(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings): Promise<void>;
+export function throttle(session: LH.Gatherer.ProtocolSession, settings: LH.Config.Settings): Promise<void>;
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
-export function clearThrottling(session: LH.Gatherer.FRProtocolSession): Promise<void>;
+export function clearThrottling(session: LH.Gatherer.ProtocolSession): Promise<void>;
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {Required<LH.ThrottlingSettings>} throttlingSettings
  * @return {Promise<void>}
  */
-export function enableNetworkThrottling(session: LH.Gatherer.FRProtocolSession, throttlingSettings: Required<LH.ThrottlingSettings>): Promise<void>;
+export function enableNetworkThrottling(session: LH.Gatherer.ProtocolSession, throttlingSettings: Required<LH.ThrottlingSettings>): Promise<void>;
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
-export function clearNetworkThrottling(session: LH.Gatherer.FRProtocolSession): Promise<void>;
+export function clearNetworkThrottling(session: LH.Gatherer.ProtocolSession): Promise<void>;
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {Required<LH.ThrottlingSettings>} throttlingSettings
  * @return {Promise<void>}
  */
-export function enableCPUThrottling(session: LH.Gatherer.FRProtocolSession, throttlingSettings: Required<LH.ThrottlingSettings>): Promise<void>;
+export function enableCPUThrottling(session: LH.Gatherer.ProtocolSession, throttlingSettings: Required<LH.ThrottlingSettings>): Promise<void>;
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
-export function clearCPUThrottling(session: LH.Gatherer.FRProtocolSession): Promise<void>;
+export function clearCPUThrottling(session: LH.Gatherer.ProtocolSession): Promise<void>;
 //# sourceMappingURL=emulation.d.ts.map

package/core/lib/emulation.js

@@ -58,7 +58,7 @@ function parseUseragentIntoMetadata(userAgent, formFactor) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
  * @return {Promise<void>}
  */
@@ -85,7 +85,7 @@ async function emulate(session, settings) {
  * Sets the throttling options specified in config settings, clearing existing network throttling if
  * throttlingMethod is not `devtools` (but not CPU throttling, suspected requirement of WPT-compat).
  *
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
  * @return {Promise<void>}
  */
@@ -99,7 +99,7 @@ async function throttle(session, settings) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
 async function clearThrottling(session) {
@@ -107,7 +107,7 @@ async function clearThrottling(session) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {Required<LH.ThrottlingSettings>} throttlingSettings
  * @return {Promise<void>}
  */
@@ -127,7 +127,7 @@ function enableNetworkThrottling(session, throttlingSettings) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
 function clearNetworkThrottling(session) {
@@ -135,7 +135,7 @@ function clearNetworkThrottling(session) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @param {Required<LH.ThrottlingSettings>} throttlingSettings
  * @return {Promise<void>}
  */
@@ -145,7 +145,7 @@ function enableCPUThrottling(session, throttlingSettings) {
 }
 
 /**
- * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Gatherer.ProtocolSession} session
  * @return {Promise<void>}
  */
 function clearCPUThrottling(session) {