lighthouse 9.5.0-dev.20230130 → 9.5.0-dev.20230131

package/core/audits/byte-efficiency/offscreen-images.js

@@ -102,7 +102,7 @@ class OffscreenImages extends ByteEfficiencyAudit {
     return {
       node: ByteEfficiencyAudit.makeNodeItem(image.node),
       url,
-      requestStartTime: networkRecord.startTime,
+      requestStartTime: networkRecord.networkRequestTime,
       totalBytes,
       wastedBytes,
       wastedPercent: 100 * wastedRatio,

package/core/audits/critical-request-chains.d.ts

@@ -1,23 +1,23 @@
 export default CriticalRequestChains;
 declare class CriticalRequestChains extends Audit {
-    /** @typedef {{depth: number, id: string, chainDuration: number, chainTransferSize: number, node: LH.Audit.Details.SimpleCriticalRequestNode[string]}} CrcNodeInfo */
+    /** @typedef {{depth: number, id: string, chainDuration: number, chainTransferSize: number, node: LH.Artifacts.CriticalRequestNode[string]}} CrcNodeInfo */
     /**
-     * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+     * @param {LH.Artifacts.CriticalRequestNode} tree
      * @param {function(CrcNodeInfo): void} cb
      */
-    static _traverse(tree: LH.Audit.Details.SimpleCriticalRequestNode, cb: (arg0: {
+    static _traverse(tree: LH.Artifacts.CriticalRequestNode, cb: (arg0: {
         depth: number;
         id: string;
         chainDuration: number;
         chainTransferSize: number;
-        node: LH.Audit.Details.SimpleCriticalRequestNode[string];
+        node: LH.Artifacts.CriticalRequestNode[string];
     }) => void): void;
     /**
      * Get stats about the longest initiator chain (as determined by time duration)
-     * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+     * @param {LH.Artifacts.CriticalRequestNode} tree
      * @return {{duration: number, length: number, transferSize: number}}
      */
-    static _getLongestChain(tree: LH.Audit.Details.SimpleCriticalRequestNode): {
+    static _getLongestChain(tree: LH.Artifacts.CriticalRequestNode): {
         duration: number;
         length: number;
         transferSize: number;

package/core/audits/critical-request-chains.js

@@ -41,28 +41,28 @@ class CriticalRequestChains extends Audit {
     };
   }
 
-  /** @typedef {{depth: number, id: string, chainDuration: number, chainTransferSize: number, node: LH.Audit.Details.SimpleCriticalRequestNode[string]}} CrcNodeInfo */
+  /** @typedef {{depth: number, id: string, chainDuration: number, chainTransferSize: number, node: LH.Artifacts.CriticalRequestNode[string]}} CrcNodeInfo */
 
   /**
-   * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+   * @param {LH.Artifacts.CriticalRequestNode} tree
    * @param {function(CrcNodeInfo): void} cb
    */
   static _traverse(tree, cb) {
     /**
-     * @param {LH.Audit.Details.SimpleCriticalRequestNode} node
+     * @param {LH.Artifacts.CriticalRequestNode} node
      * @param {number} depth
-     * @param {number=} startTime
+     * @param {number=} networkRequestTime
      * @param {number=} transferSize
      */
-    function walk(node, depth, startTime, transferSize = 0) {
+    function walk(node, depth, networkRequestTime, transferSize = 0) {
       const children = Object.keys(node);
       if (children.length === 0) {
         return;
       }
       children.forEach(id => {
         const child = node[id];
-        if (!startTime) {
-          startTime = child.request.startTime;
+        if (!networkRequestTime) {
+          networkRequestTime = child.request.networkRequestTime;
         }
 
         // Call the callback with the info for this child.
@@ -70,13 +70,13 @@ class CriticalRequestChains extends Audit {
           depth,
           id,
           node: child,
-          chainDuration: child.request.endTime - startTime,
+          chainDuration: child.request.networkEndTime - networkRequestTime,
           chainTransferSize: transferSize + child.request.transferSize,
         });
 
         // Carry on walking.
         if (child.children) {
-          walk(child.children, depth + 1, startTime);
+          walk(child.children, depth + 1, networkRequestTime);
         }
       }, '');
     }
@@ -86,7 +86,7 @@ class CriticalRequestChains extends Audit {
 
   /**
    * Get stats about the longest initiator chain (as determined by time duration)
-   * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+   * @param {LH.Artifacts.CriticalRequestNode} tree
    * @return {{duration: number, length: number, transferSize: number}}
    */
   static _getLongestChain(tree) {
@@ -96,7 +96,7 @@ class CriticalRequestChains extends Audit {
       transferSize: 0,
     };
     CriticalRequestChains._traverse(tree, opts => {
-      const duration = opts.chainDuration * 1000;
+      const duration = opts.chainDuration;
       if (duration > longest.duration) {
         longest.duration = duration;
         longest.transferSize = opts.chainTransferSize;
@@ -123,9 +123,9 @@ class CriticalRequestChains extends Audit {
       const request = opts.node.request;
       const simpleRequest = {
         url: request.url,
-        startTime: request.startTime / 1000,
-        endTime: request.endTime / 1000,
-        responseReceivedTime: request.responseReceivedTime / 1000,
+        startTime: request.networkRequestTime / 1000,
+        endTime: request.networkEndTime / 1000,
+        responseReceivedTime: request.responseHeadersEndTime / 1000,
         transferSize: request.transferSize,
       };
 
@@ -199,7 +199,7 @@ class CriticalRequestChains extends Audit {
       walk(initialNavChildren, 0);
     }
 
-    const longestChain = CriticalRequestChains._getLongestChain(flattenedChains);
+    const longestChain = CriticalRequestChains._getLongestChain(chains);
 
     return {
       score: Number(chainCount === 0),

package/core/audits/dobetterweb/doctype.js

@@ -18,10 +18,10 @@ const UIStrings = {
     '[Learn more about the doctype declaration](https://developer.chrome.com/docs/lighthouse/best-practices/doctype/).',
   /** Explanatory message stating that the document has no doctype. */
   explanationNoDoctype: 'Document must contain a doctype',
-  /** Explanatory message stating that the document has wrong doctype */
-  explanationWrongDoctype: 'Document contains a doctype that triggers quirks-mode',
-  /** Explanatory message stating that the document has wrong doctype */
-  explanationLimitedQuirks: 'Document contains a doctype that triggers limited-quirks-mode',
+  /** Explanatory message stating that the document has wrong doctype that triggers `quirks-mode` */
+  explanationWrongDoctype: 'Document contains a `doctype` that triggers `quirks-mode`',
+  /** Explanatory message stating that the document has wrong doctype that triggers `limited-quirks-mode` */
+  explanationLimitedQuirks: 'Document contains a `doctype` that triggers `limited-quirks-mode`',
   /** Explanatory message stating that the publicId field is not empty. */
   explanationPublicId: 'Expected publicId to be an empty string',
   /** Explanatory message stating that the systemId field is not empty. */

package/core/audits/font-display.js

@@ -165,7 +165,7 @@ class FontDisplay extends Audit {
       .map(record => {
         // In reality the end time should be calculated with paint time included
         // all browsers wait 3000ms to block text so we make sure 3000 is our max wasted time
-        const wastedMs = Math.min(record.endTime - record.startTime, 3000);
+        const wastedMs = Math.min(record.networkEndTime - record.networkRequestTime, 3000);
 
         return {
           url: record.url,

package/core/audits/network-requests.js

@@ -65,8 +65,8 @@ class NetworkRequests extends Audit {
         url: UrlUtils.elideDataURI(record.url),
         protocol: record.protocol,
         rendererStartTime: normalizeTime(record.rendererStartTime),
-        startTime: normalizeTime(record.startTime),
-        endTime: normalizeTime(record.endTime),
+        networkRequestTime: normalizeTime(record.networkRequestTime),
+        networkEndTime: normalizeTime(record.networkEndTime),
         finished: record.finished,
         transferSize: record.transferSize,
         resourceSize: record.resourceSize,
@@ -88,8 +88,8 @@ class NetworkRequests extends Audit {
     const headings = [
       {key: 'url', valueType: 'url', label: 'URL'},
       {key: 'protocol', valueType: 'text', label: 'Protocol'},
-      {key: 'startTime', valueType: 'ms', granularity: 1, label: 'Start Time'},
-      {key: 'endTime', valueType: 'ms', granularity: 1, label: 'End Time'},
+      {key: 'networkRequestTime', valueType: 'ms', granularity: 1, label: 'Network Request Time'},
+      {key: 'networkEndTime', valueType: 'ms', granularity: 1, label: 'Network End Time'},
       {
         key: 'transferSize',
         valueType: 'bytes',

package/core/audits/redirects.js

@@ -125,7 +125,8 @@ class Redirects extends Audit {
       }
 
       const lanternTimingDeltaMs = redirectedTiming.startTime - initialTiming.startTime;
-      const observedTimingDeltaMs = redirectedRequest.startTime - initialRequest.startTime;
+      const observedTimingDeltaMs = redirectedRequest.networkRequestTime -
+          initialRequest.networkRequestTime;
       const wastedMs = settings.throttlingMethod === 'simulate' ?
         lanternTimingDeltaMs : observedTimingDeltaMs;
       totalWastedMs += wastedMs;

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

@@ -95,7 +95,8 @@ class UsesRelPreconnectAudit extends Audit {
    * @return {boolean}
    */
   static socketStartTimeIsBelowThreshold(record, mainResource) {
-    return Math.max(0, record.startTime - mainResource.endTime) < PRECONNECT_SOCKET_MAX_IDLE_IN_MS;
+    const timeSinceMainEnd = Math.max(0, record.networkRequestTime - mainResource.networkEndTime);
+    return timeSinceMainEnd < PRECONNECT_SOCKET_MAX_IDLE_IN_MS;
   }
 
   /**
@@ -169,7 +170,7 @@ class UsesRelPreconnectAudit extends Audit {
       // Sometimes requests are done simultaneous and the connection has not been made
       // chrome will try to connect for each network record, we get the first record
       const firstRecordOfOrigin = records.reduce((firstRecord, record) => {
-        return (record.startTime < firstRecord.startTime) ? record : firstRecord;
+        return (record.networkRequestTime < firstRecord.networkRequestTime) ? record : firstRecord;
       });
 
       // Skip the origin if we don't have timing information
@@ -186,8 +187,8 @@ class UsesRelPreconnectAudit extends Audit {
       if (firstRecordOfOrigin.parsedURL.scheme === 'https') connectionTime = connectionTime * 2;
 
       const timeBetweenMainResourceAndDnsStart =
-        firstRecordOfOrigin.startTime -
-        mainResource.endTime +
+        firstRecordOfOrigin.networkRequestTime -
+        mainResource.networkEndTime +
         firstRecordOfOrigin.timing.dnsStart;
 
       const wastedMs = Math.min(connectionTime, timeBetweenMainResourceAndDnsStart);

package/core/gather/driver/network-monitor.js

@@ -218,9 +218,9 @@ class NetworkMonitor extends NetworkMonitorEventEmitter {
       if (request.protocol === 'ws' || request.protocol === 'wss') return;
 
       // convert the network timestamp to ms
-      timeBoundaries.push({time: request.startTime * 1000, isStart: true});
+      timeBoundaries.push({time: request.networkRequestTime * 1000, isStart: true});
       if (request.finished) {
-        timeBoundaries.push({time: request.endTime * 1000, isStart: false});
+        timeBoundaries.push({time: request.networkEndTime * 1000, isStart: false});
       }
     });
 

package/core/gather/gatherers/dobetterweb/tags-blocking-first-paint.js

@@ -155,7 +155,7 @@ class TagsBlockingFirstPaint extends FRGatherer {
    */
   static async findBlockingTags(driver, networkRecords) {
     const firstRequestEndTime = networkRecords.reduce(
-      (min, record) => Math.min(min, record.endTime),
+      (min, record) => Math.min(min, record.networkEndTime),
       Infinity
     );
     const tags = await driver.executionContext.evaluate(collectTagsThatBlockFirstPaint, {args: []});
@@ -167,7 +167,7 @@ class TagsBlockingFirstPaint extends FRGatherer {
       const request = requests.get(tag.url);
       if (!request || request.isLinkPreload) continue;
 
-      let endTime = request.endTime;
+      let endTime = request.networkEndTime;
       let mediaChanges;
 
       if (tag.tagName === 'LINK') {
@@ -180,7 +180,7 @@ class TagsBlockingFirstPaint extends FRGatherer {
         if (timesResourceBecameNonBlocking.length > 0) {
           const earliestNonBlockingTime = Math.min(...timesResourceBecameNonBlocking);
           const lastTimeResourceWasBlocking = Math.max(
-            request.startTime,
+            request.networkRequestTime,
             firstRequestEndTime + earliestNonBlockingTime / 1000
           );
           endTime = Math.min(endTime, lastTimeResourceWasBlocking);
@@ -194,7 +194,7 @@ class TagsBlockingFirstPaint extends FRGatherer {
       result.push({
         tag: {tagName, url, mediaChanges},
         transferSize: request.transferSize,
-        startTime: request.startTime,
+        startTime: request.networkRequestTime,
         endTime,
       });
 

package/core/lib/bf-cache-strings.js

@@ -367,7 +367,7 @@ const UIStrings = {
       * @description Description text for not restored reason InjectedJavascript.
       */
   injectedJavascript:
-      'IPages that JavaScript is injected into by extensions are not currently eligible for back/forward cache.',
+      'Pages that JavaScript is injected into by extensions are not currently eligible for back/forward cache.',
   /**
       * @description Description text for not restored reason InjectedStyleSheet.
       */

package/core/lib/dependency-graph/network-node.js

@@ -26,14 +26,14 @@ class NetworkNode extends BaseNode {
    * @return {number}
    */
   get startTime() {
-    return this._record.startTime * 1000;
+    return this._record.networkRequestTime * 1000;
   }
 
   /**
    * @return {number}
    */
   get endTime() {
-    return this._record.endTime * 1000;
+    return this._record.networkEndTime * 1000;
   }
 
   /**

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

@@ -150,7 +150,7 @@ class NetworkAnalyzer {
       if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
 
       // Compute the amount of time downloading everything after the first congestion window took
-      const totalTime = record.endTime - record.startTime;
+      const totalTime = record.networkEndTime - record.networkRequestTime;
       const downloadTimeAfterFirstByte = totalTime - timing.receiveHeadersEnd;
       const numberOfRoundTrips = Math.log2(record.transferSize / INITIAL_CWD);
 
@@ -279,17 +279,19 @@ class NetworkAnalyzer {
     const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
     for (const [_, originRecords] of groupedByOrigin.entries()) {
       const earliestReusePossible = originRecords
-        .map(record => record.endTime)
+        .map(record => record.networkEndTime)
         .reduce((a, b) => Math.min(a, b), Infinity);
 
       for (const record of originRecords) {
         connectionWasReused.set(
           record.requestId,
-          record.startTime >= earliestReusePossible || record.protocol === 'h2'
+          record.networkRequestTime >= earliestReusePossible || record.protocol === 'h2'
         );
       }
 
-      const firstRecord = originRecords.reduce((a, b) => (a.startTime > b.startTime ? b : a));
+      const firstRecord = originRecords.reduce((a, b) => {
+        return a.networkRequestTime > b.networkRequestTime ? b : a;
+      });
       connectionWasReused.set(firstRecord.requestId, false);
     }
 
@@ -399,8 +401,8 @@ class NetworkAnalyzer {
 
       // If we've made it this far, all the times we need should be valid (i.e. not undefined/-1).
       totalBytes += record.transferSize;
-      boundaries.push({time: record.responseReceivedTime / 1000, isStart: true});
-      boundaries.push({time: record.endTime / 1000, isStart: false});
+      boundaries.push({time: record.responseHeadersEndTime / 1000, isStart: true});
+      boundaries.push({time: record.networkEndTime / 1000, isStart: false});
       return boundaries;
     }, /** @type {Array<{time: number, isStart: boolean}>} */([])).sort((a, b) => a.time - b.time);
 

package/core/lib/lighthouse-compatibility.d.ts

@@ -0,0 +1,8 @@
+export type ItemValueType = import('../../types/lhr/audit-details').default.ItemValueType;
+/** @typedef {import('../../types/lhr/audit-details').default.ItemValueType} ItemValueType */
+/**
+ * Upgrades an lhr object in-place to account for changes in the data structure over major versions.
+ * @param {LH.Result} lhr
+ */
+export function upgradeLhrForCompatibility(lhr: LH.Result): void;
+//# sourceMappingURL=lighthouse-compatibility.d.ts.map

package/core/lib/lighthouse-compatibility.js

@@ -0,0 +1,139 @@
+/**
+ * @license Copyright 2023 The Lighthouse Authors. All Rights Reserved.
+ * 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.
+ */
+
+import {Util} from '../../shared/util.js';
+
+const SCREENSHOT_PREFIX = 'data:image/jpeg;base64,';
+
+/** @typedef {import('../../types/lhr/audit-details').default.ItemValueType} ItemValueType */
+
+/**
+ * Upgrades an lhr object in-place to account for changes in the data structure over major versions.
+ * @param {LH.Result} lhr
+ */
+function upgradeLhrForCompatibility(lhr) {
+  // If LHR is older (≤3.0.3), it has no locale setting. Set default.
+  if (!lhr.configSettings.locale) {
+    lhr.configSettings.locale = 'en';
+  }
+  if (!lhr.configSettings.formFactor) {
+    // @ts-expect-error fallback handling for emulatedFormFactor
+    lhr.configSettings.formFactor = lhr.configSettings.emulatedFormFactor;
+  }
+
+  lhr.finalDisplayedUrl = Util.getFinalDisplayedUrl(lhr);
+  lhr.mainDocumentUrl = Util.getMainDocumentUrl(lhr);
+
+  for (const audit of Object.values(lhr.audits)) {
+    // Turn 'not-applicable' (LHR <4.0) and 'not_applicable' (older proto versions)
+    // into 'notApplicable' (LHR ≥4.0).
+    // @ts-expect-error tsc rightly flags that these values shouldn't occur.
+    // eslint-disable-next-line max-len
+    if (audit.scoreDisplayMode === 'not_applicable' || audit.scoreDisplayMode === 'not-applicable') {
+      audit.scoreDisplayMode = 'notApplicable';
+    }
+
+    if (audit.details) {
+      // Turn `auditDetails.type` of undefined (LHR <4.2) and 'diagnostic' (LHR <5.0)
+      // into 'debugdata' (LHR ≥5.0).
+      // @ts-expect-error tsc rightly flags that these values shouldn't occur.
+      if (audit.details.type === undefined || audit.details.type === 'diagnostic') {
+        // @ts-expect-error details is of type never.
+        audit.details.type = 'debugdata';
+      }
+
+      // Add the jpg data URL prefix to filmstrip screenshots without them (LHR <5.0).
+      if (audit.details.type === 'filmstrip') {
+        for (const screenshot of audit.details.items) {
+          if (!screenshot.data.startsWith(SCREENSHOT_PREFIX)) {
+            screenshot.data = SCREENSHOT_PREFIX + screenshot.data;
+          }
+        }
+      }
+
+      // Circa 10.0, table items were refactored.
+      if (audit.details.type === 'table') {
+        for (const heading of audit.details.headings) {
+          /** @type {{itemType: ItemValueType|undefined, text: string|undefined}} */
+          // @ts-expect-error
+          const {itemType, text} = heading;
+          if (itemType !== undefined) {
+            heading.valueType = itemType;
+            // @ts-expect-error
+            delete heading.itemType;
+          }
+          if (text !== undefined) {
+            heading.label = text;
+            // @ts-expect-error
+            delete heading.text;
+          }
+
+          // @ts-expect-error
+          const subItemsItemType = heading.subItemsHeading?.itemType;
+          if (heading.subItemsHeading && subItemsItemType !== undefined) {
+            heading.subItemsHeading.valueType = subItemsItemType;
+            // @ts-expect-error
+            delete heading.subItemsHeading.itemType;
+          }
+        }
+      }
+
+      // TODO: convert printf-style displayValue.
+      // Added:   #5099, v3
+      // Removed: #6767, v4
+    }
+  }
+
+  // This backcompat converts old LHRs (<9.0.0) to use the new "hidden" group.
+  // Old LHRs used "no group" to identify audits that should be hidden in performance instead of the "hidden" group.
+  // Newer LHRs use "no group" to identify opportunities and diagnostics whose groups are assigned by details type.
+  const [majorVersion] = lhr.lighthouseVersion.split('.').map(Number);
+  const perfCategory = lhr.categories['performance'];
+  if (majorVersion < 9 && perfCategory) {
+    if (!lhr.categoryGroups) lhr.categoryGroups = {};
+    lhr.categoryGroups['hidden'] = {title: ''};
+    for (const auditRef of perfCategory.auditRefs) {
+      if (!auditRef.group) {
+        auditRef.group = 'hidden';
+      } else if (['load-opportunities', 'diagnostics'].includes(auditRef.group)) {
+        delete auditRef.group;
+      }
+    }
+  }
+
+  // Add some minimal stuff so older reports still work.
+  if (!lhr.environment) {
+    // @ts-expect-error
+    lhr.environment = {benchmarkIndex: 0};
+  }
+  if (!lhr.configSettings.screenEmulation) {
+    // @ts-expect-error
+    lhr.configSettings.screenEmulation = {};
+  }
+  if (!lhr.i18n) {
+    // @ts-expect-error
+    lhr.i18n = {};
+  }
+
+  // In 10.0, full-page-screenshot became a top-level property on the LHR.
+  if (lhr.audits['full-page-screenshot']) {
+    const details = /** @type {LH.Result.FullPageScreenshot=} */ (
+      lhr.audits['full-page-screenshot'].details);
+    if (details) {
+      lhr.fullPageScreenshot = {
+        screenshot: details.screenshot,
+        nodes: details.nodes,
+      };
+    } else {
+      lhr.fullPageScreenshot = null;
+    }
+    delete lhr.audits['full-page-screenshot'];
+  }
+}
+
+export {
+  upgradeLhrForCompatibility,
+};

package/core/lib/navigation-error.js

@@ -125,7 +125,9 @@ function getPageLoadError(navigationError, context) {
       record.resourceType === NetworkRequest.TYPES.Document
     );
     if (documentRequests.length) {
-      mainRecord = documentRequests.reduce((min, r) => (r.startTime < min.startTime ? r : min));
+      mainRecord = documentRequests.reduce((min, r) => {
+        return r.networkRequestTime < min.networkRequestTime ? r : min;
+      });
     }
   }
 

package/core/lib/network-recorder.js

@@ -248,7 +248,7 @@ class NetworkRecorder extends RequestEventEmitter {
 
     let candidates = recordsByURL.get(initiatorURL) || [];
     // The initiator must come before the initiated request.
-    candidates = candidates.filter(cand => cand.responseReceivedTime <= record.startTime);
+    candidates = candidates.filter(c => c.responseHeadersEndTime <= record.networkRequestTime);
     if (candidates.length > 1) {
       // Disambiguate based on prefetch. Prefetch requests have type 'Other' and cannot
       // initiate requests, so we drop them here.

package/core/lib/network-request.d.ts

@@ -14,7 +14,7 @@ export type ParsedURL = {
     securityOrigin: string;
 };
 /**
- * The difference in endTime between the observed Lighthouse endTime and Lightrider's derived endTime.
+ * The difference in networkEndTime between the observed Lighthouse networkEndTime and Lightrider's derived networkEndTime.
  */
 export type LightriderStatistics = {
     /**
@@ -92,11 +92,11 @@ export class NetworkRequest {
      * When the network service is about to handle a request, ie. just before going to the
      * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
      */
-    startTime: number;
-    /** When the last byte of the response body is received, in milliseconds. */
-    endTime: number;
+    networkRequestTime: number;
     /** When the last byte of the response headers is received, in milliseconds. */
-    responseReceivedTime: number;
+    responseHeadersEndTime: number;
+    /** When the last byte of the response body is received, in milliseconds. */
+    networkEndTime: number;
     transferSize: number;
     resourceSize: number;
     fromDiskCache: boolean;
@@ -194,10 +194,10 @@ export class NetworkRequest {
      */
     _recomputeTimesWithResourceTiming(timing: LH.Crdp.Network.ResourceTiming): void;
     /**
-     * Update responseReceivedTime to the endTime if endTime is earlier.
+     * Update responseHeadersEndTime to the networkEndTime if networkEndTime is earlier.
      * A response can't be received after the entire request finished.
      */
-    _updateResponseReceivedTimeIfNecessary(): void;
+    _updateResponseHeadersEndTimeIfNecessary(): void;
     /**
      * LR loses transfer size information, but passes it in the 'X-TotalFetchedSize' header.
      * 'X-TotalFetchedSize' is the canonical transfer size in LR. Nothing should supersede it.