lighthouse 12.0.0-dev.20240603 → 12.0.0-dev.20240605

package/core/lib/lantern/simulator/network-analyzer.js

@@ -88,30 +88,30 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{request: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} requests
    * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
    * @return {Map<string, number[]>}
    */
-  static _estimateValueByOrigin(records, iteratee) {
-    const connectionWasReused = NetworkAnalyzer.estimateIfConnectionWasReused(records);
-    const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
+  static _estimateValueByOrigin(requests, iteratee) {
+    const connectionWasReused = NetworkAnalyzer.estimateIfConnectionWasReused(requests);
+    const groupedByOrigin = NetworkAnalyzer.groupByOrigin(requests);
 
     const estimates = new Map();
-    for (const [origin, originRecords] of groupedByOrigin.entries()) {
+    for (const [origin, originRequests] of groupedByOrigin.entries()) {
       /** @type {number[]} */
       let originEstimates = [];
 
-      for (const record of originRecords) {
-        const timing = record.timing;
+      for (const request of originRequests) {
+        const timing = request.timing;
         if (!timing) continue;
 
         const value = iteratee({
-          record,
+          request,
           timing,
-          connectionReused: connectionWasReused.get(record.requestId),
+          connectionReused: connectionWasReused.get(request.requestId),
         });
         if (typeof value !== 'undefined') {
           originEstimates = originEstimates.concat(value);
@@ -137,11 +137,11 @@ class NetworkAnalyzer {
    * @return {number[]|number|undefined}
    */
   static _estimateRTTViaConnectionTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     const {connectStart, sslStart, sslEnd, connectEnd} = timing;
-    if (connectEnd >= 0 && connectStart >= 0 && record.protocol.startsWith('h3')) {
+    if (connectEnd >= 0 && connectStart >= 0 && request.protocol.startsWith('h3')) {
       // These values are equal to sslStart and sslEnd for h3.
       return connectEnd - connectStart;
     } else if (sslStart >= 0 && sslEnd >= 0 && sslStart !== connectStart) {
@@ -161,17 +161,17 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaDownloadTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     // Only look at downloads that went past the initial congestion window
-    if (record.transferSize <= INITIAL_CWD) return;
+    if (request.transferSize <= INITIAL_CWD) return;
     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.networkEndTime - record.networkRequestTime;
+    const totalTime = request.networkEndTime - request.networkRequestTime;
     const downloadTimeAfterFirstByte = totalTime - timing.receiveHeadersEnd;
-    const numberOfRoundTrips = Math.log2(record.transferSize / INITIAL_CWD);
+    const numberOfRoundTrips = Math.log2(request.transferSize / INITIAL_CWD);
 
     // Ignore requests that required a high number of round trips since bandwidth starts to play
     // a larger role than latency
@@ -190,7 +190,7 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaSendStartTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     if (!Number.isFinite(timing.sendStart) || timing.sendStart < 0) return;
@@ -198,8 +198,8 @@ class NetworkAnalyzer {
     // 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;
+    if (!request.protocol.startsWith('h3')) roundTrips += 1; // TCP
+    if (request.parsedURL.scheme === 'https') roundTrips += 1;
     return timing.sendStart / roundTrips;
   }
 
@@ -213,12 +213,12 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaHeadersEndTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
-    if (!record.resourceType) return;
+    if (!request.resourceType) return;
 
     const serverResponseTimePercentage =
-      SERVER_RESPONSE_PERCENTAGE_OF_TTFB[record.resourceType] ||
+      SERVER_RESPONSE_PERCENTAGE_OF_TTFB[request.resourceType] ||
       DEFAULT_SERVER_RESPONSE_PERCENTAGE;
     const estimatedServerResponseTime = timing.receiveHeadersEnd * serverResponseTimePercentage;
 
@@ -230,8 +230,8 @@ class NetworkAnalyzer {
     // 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
+      if (!request.protocol.startsWith('h3')) roundTrips += 1; // TCP
+      if (request.parsedURL.scheme === 'https') roundTrips += 1; // SSL
     }
 
     // subtract out our estimated server response time
@@ -246,28 +246,28 @@ class NetworkAnalyzer {
    * @return {Map<string, number[]>}
    */
   static _estimateResponseTimeByOrigin(records, rttByOrigin) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing}) => {
-      if (record.serverResponseTime !== undefined) return record.serverResponseTime;
+    return NetworkAnalyzer._estimateValueByOrigin(records, ({request, timing}) => {
+      if (request.serverResponseTime !== undefined) return request.serverResponseTime;
 
       if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
       if (!Number.isFinite(timing.sendEnd) || timing.sendEnd < 0) return;
 
       const ttfb = timing.receiveHeadersEnd - timing.sendEnd;
-      const origin = record.parsedURL.securityOrigin;
+      const origin = request.parsedURL.securityOrigin;
       const rtt = rttByOrigin.get(origin) || rttByOrigin.get(NetworkAnalyzer.SUMMARY) || 0;
       return Math.max(ttfb - rtt, 0);
     });
   }
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} requests
    * @return {boolean}
    */
-  static canTrustConnectionInformation(records) {
+  static canTrustConnectionInformation(requests) {
     const connectionIdWasStarted = new Map();
-    for (const record of records) {
-      const started = connectionIdWasStarted.get(record.connectionId) || !record.connectionReused;
-      connectionIdWasStarted.set(record.connectionId, started);
+    for (const request of requests) {
+      const started = connectionIdWasStarted.get(request.connectionId) || !request.connectionReused;
+      connectionIdWasStarted.set(request.connectionId, started);
     }
 
     // We probably can't trust the network information if all the connection IDs were the same
@@ -289,10 +289,10 @@ class NetworkAnalyzer {
 
     // Check if we can trust the connection information coming from the protocol
     if (!forceCoarseEstimates && NetworkAnalyzer.canTrustConnectionInformation(records)) {
-      return new Map(records.map(record => [record.requestId, !!record.connectionReused]));
+      return new Map(records.map(request => [request.requestId, !!request.connectionReused]));
     }
 
-    // Otherwise we're on our own, a record may not have needed a fresh connection if...
+    // Otherwise we're on our own, a request may not have needed a fresh connection if...
     //   - It was not the first request to the domain
     //   - It was H2
     //   - It was after the first request to the domain ended
@@ -300,13 +300,13 @@ class NetworkAnalyzer {
     const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
     for (const [_, originRecords] of groupedByOrigin.entries()) {
       const earliestReusePossible = originRecords
-        .map(record => record.networkEndTime)
+        .map(request => request.networkEndTime)
         .reduce((a, b) => Math.min(a, b), Infinity);
 
-      for (const record of originRecords) {
+      for (const request of originRecords) {
         connectionWasReused.set(
-          record.requestId,
-          record.networkRequestTime >= earliestReusePossible || record.protocol === 'h2'
+          request.requestId,
+          request.networkRequestTime >= earliestReusePossible || request.protocol === 'h2'
         );
       }
 
@@ -343,7 +343,7 @@ class NetworkAnalyzer {
     const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
 
     const estimatesByOrigin = new Map();
-    for (const [origin, originRecords] of groupedByOrigin.entries()) {
+    for (const [origin, originRequests] of groupedByOrigin.entries()) {
       /** @type {number[]} */
       const originEstimates = [];
 
@@ -352,14 +352,14 @@ class NetworkAnalyzer {
        */
       // eslint-disable-next-line no-inner-declarations
       function collectEstimates(estimator, multiplier = 1) {
-        for (const record of originRecords) {
-          const timing = record.timing;
+        for (const request of originRequests) {
+          const timing = request.timing;
           if (!timing) continue;
 
           const estimates = estimator({
-            record,
+            request,
             timing,
-            connectionReused: connectionWasReused.get(record.requestId),
+            connectionReused: connectionWasReused.get(request.requestId),
           });
           if (estimates === undefined) continue;
 
@@ -427,9 +427,9 @@ class NetworkAnalyzer {
 
 
   /**
-   * Computes the average throughput for the given records in bits/second.
+   * Computes the average throughput for the given requests in bits/second.
    * Excludes data URI, failed or otherwise incomplete, and cached requests.
-   * Returns Infinity if there were no analyzable network records.
+   * Returns Infinity if there were no analyzable network requests.
    *
    * @param {Lantern.NetworkRequest[]} records
    * @return {number}
@@ -438,21 +438,21 @@ class NetworkAnalyzer {
     let totalBytes = 0;
 
     // We will measure throughput by summing the total bytes downloaded by the total time spent
-    // downloading those bytes. We slice up all the network records into start/end boundaries, so
+    // downloading those bytes. We slice up all the network requests into start/end boundaries, so
     // it's easier to deal with the gaps in downloading.
-    const timeBoundaries = records.reduce((boundaries, record) => {
-      const scheme = record.parsedURL?.scheme;
+    const timeBoundaries = records.reduce((boundaries, request) => {
+      const scheme = request.parsedURL?.scheme;
       // Requests whose bodies didn't come over the network or didn't completely finish will mess
       // with the computation, just skip over them.
-      if (scheme === 'data' || record.failed || !record.finished ||
-          record.statusCode > 300 || !record.transferSize) {
+      if (scheme === 'data' || request.failed || !request.finished ||
+          request.statusCode > 300 || !request.transferSize) {
         return boundaries;
       }
 
       // 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.responseHeadersEndTime / 1000, isStart: true});
-      boundaries.push({time: record.networkEndTime / 1000, isStart: false});
+      totalBytes += request.transferSize;
+      boundaries.push({time: request.responseHeadersEndTime / 1000, isStart: true});
+      boundaries.push({time: request.networkEndTime / 1000, isStart: false});
       return boundaries;
     }, /** @type {Array<{time: number, isStart: boolean}>} */([])).sort((a, b) => a.time - b.time);
 

package/core/lib/lantern/simulator/simulator.d.ts

@@ -14,7 +14,7 @@ export class Simulator<T = any> {
     /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */
     static get ALL_NODE_TIMINGS(): Map<string, Map<Node, CompleteNodeTiming>>;
     /**
-     * We attempt to start nodes by their observed start time using the record priority as a tie breaker.
+     * We attempt to start nodes by their observed start time using the request priority as a tie breaker.
      * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
      * it would have happened like that when the network was slower.
      * @param {Node} node
@@ -73,10 +73,10 @@ export class Simulator<T = any> {
      */
     _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./simulator-timing-map.js").ConnectionTiming | undefined): void;
     /**
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      * @return {?TcpConnection}
      */
-    _acquireConnection(record: Lantern.NetworkRequest): TcpConnection | null;
+    _acquireConnection(request: Lantern.NetworkRequest): TcpConnection | null;
     /**
      * @return {Node[]}
      */
@@ -136,7 +136,7 @@ export class Simulator<T = any> {
      *
      * Simulator/connection pool are allowed to deviate from what was
      * observed in the trace/devtoolsLog and start requests as soon as they are queued (i.e. do not
-     * wait around for a warm connection to be available if the original record was fetched on a warm
+     * wait around for a warm connection to be available if the original request was fetched on a warm
      * connection).
      *
      * @param {Node} graph

package/core/lib/lantern/simulator/simulator.js

@@ -34,7 +34,7 @@ const NodeState = {
   Complete: 3,
 };
 
-/** @type {Record<NetworkNode['record']['priority'], number>} */
+/** @type {Record<NetworkNode['request']['priority'], number>} */
 const PriorityStartTimePenalty = {
   VeryHigh: 0,
   High: 0.25,
@@ -248,11 +248,11 @@ class Simulator {
   }
 
   /**
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {?TcpConnection}
    */
-  _acquireConnection(record) {
-    return this._connectionPool.acquire(record);
+  _acquireConnection(request) {
+    return this._connectionPool.acquire(request);
   }
 
   /**
@@ -342,7 +342,7 @@ class Simulator {
    * @return {number}
    */
   _estimateNetworkTimeRemaining(networkNode) {
-    const record = networkNode.request;
+    const request = networkNode.request;
     const timingData = this._nodeTimings.getNetworkStarted(networkNode);
 
     let timeElapsed = 0;
@@ -350,23 +350,23 @@ class Simulator {
       // Rough access time for seeking to location on disk and reading sequentially.
       // 8ms per seek + 20ms/MB
       // @see http://norvig.com/21-days.html#answers
-      const sizeInMb = (record.resourceSize || 0) / 1024 / 1024;
+      const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
       timeElapsed = 8 + 20 * sizeInMb - timingData.timeElapsed;
     } else if (networkNode.isNonNetworkProtocol) {
       // Estimates for the overhead of a data URL in Chromium and the decoding time for base64-encoded data.
       // 2ms per request + 10ms/MB
       // @see traces on https://dopiaza.org/tools/datauri/examples/index.php
-      const sizeInMb = (record.resourceSize || 0) / 1024 / 1024;
+      const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
       timeElapsed = 2 + 10 * sizeInMb - timingData.timeElapsed;
     } else {
-      const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
-      const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
+      const connection = this._connectionPool.acquireActiveConnectionFromRequest(request);
+      const dnsResolutionTime = this._dns.getTimeUntilResolution(request, {
         requestedAt: timingData.startTime,
         shouldUpdateCache: true,
       });
       const timeAlreadyElapsed = timingData.timeElapsed;
       const calculation = connection.simulateDownloadUntil(
-        record.transferSize - timingData.bytesDownloaded,
+        request.transferSize - timingData.bytesDownloaded,
         {timeAlreadyElapsed, dnsResolutionTime, maximumTimeToElapse: Infinity}
       );
 
@@ -410,14 +410,14 @@ class Simulator {
     if (node.type !== BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
     if (!('bytesDownloaded' in timingData)) throw new Error('Invalid timing data');
 
-    const record = node.request;
-    const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
-    const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
+    const request = node.request;
+    const connection = this._connectionPool.acquireActiveConnectionFromRequest(request);
+    const dnsResolutionTime = this._dns.getTimeUntilResolution(request, {
       requestedAt: timingData.startTime,
       shouldUpdateCache: true,
     });
     const calculation = connection.simulateDownloadUntil(
-      record.transferSize - timingData.bytesDownloaded,
+      request.transferSize - timingData.bytesDownloaded,
       {
         dnsResolutionTime,
         timeAlreadyElapsed: timingData.timeElapsed,
@@ -430,7 +430,7 @@ class Simulator {
 
     if (isFinished) {
       connection.setWarmed(true);
-      this._connectionPool.release(record);
+      this._connectionPool.release(request);
       this._markNodeAsComplete(node, totalElapsedTime, calculation.connectionTiming);
     } else {
       timingData.timeElapsed += calculation.timeElapsed;
@@ -480,7 +480,7 @@ class Simulator {
    *
    * Simulator/connection pool are allowed to deviate from what was
    * observed in the trace/devtoolsLog and start requests as soon as they are queued (i.e. do not
-   * wait around for a warm connection to be available if the original record was fetched on a warm
+   * wait around for a warm connection to be available if the original request was fetched on a warm
    * connection).
    *
    * @param {Node} graph
@@ -580,7 +580,7 @@ class Simulator {
   }
 
   /**
-   * We attempt to start nodes by their observed start time using the record priority as a tie breaker.
+   * We attempt to start nodes by their observed start time using the request priority as a tie breaker.
    * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
    * it would have happened like that when the network was slower.
    * @param {Node} node

package/core/lib/lantern/types/lantern.d.ts

@@ -38,12 +38,13 @@ type LightriderStatistics = {
 
 export class NetworkRequest<T = any> {
     /**
-     * The canonical network record.
-     * Users of Lantern must create NetworkRequests matching this interface,
-     * but can store the source-of-truth for their network model in this `record`
-     * property. This is then accessible as a read-only property on NetworkNode.
+     * Implementation-specifc canoncial data structure that this Lantern NetworkRequest
+     * was derived from.
+     * Users of Lantern create a NetworkRequest matching this interface,
+     * but can store the source-of-truth for their network model in this property.
+     * This is then accessible as a read-only property on NetworkNode.
      */
-    record?: T;
+    rawRequest?: T;
 
     requestId: string;
     connectionId: number;
@@ -59,7 +60,11 @@ export class NetworkRequest<T = any> {
      * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
      */
     networkRequestTime: number;
-    /** When the last byte of the response headers is received, in milliseconds. */
+    /**
+     * When the last byte of the response headers is received, in milliseconds.
+     * Equal to networkRequestTime if no data is recieved over the
+     * network (ex: cached requests or data urls).
+     */
     responseHeadersEndTime: number;
     /** When the last byte of the response body is received, in milliseconds. */
     networkEndTime: number;

package/core/lib/lantern-trace-saver.js

@@ -33,7 +33,7 @@ function convertNodeTimingsToTrace(nodeTimings) {
       traceEvents.push(...createFakeTaskEvents(node, timing));
     } else {
       /** @type {LH.Artifacts.NetworkRequest} */
-      const record = node.record;
+      const record = node.rawRequest;
       // Ignore data URIs as they don't really add much value
       if (/^data/.test(record.url)) continue;
       traceEvents.push(...createFakeNetworkEvents(requestId, record, timing));

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

@@ -104,7 +104,11 @@ export class NetworkRequest {
      * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
      */
     networkRequestTime: number;
-    /** When the last byte of the response headers is received, in milliseconds. */
+    /**
+     * When the last byte of the response headers is received, in milliseconds.
+     * Equal to networkRequestTime if no data is recieved over the
+     * network (ex: cached requests or data urls).
+     */
     responseHeadersEndTime: number;
     /** When the last byte of the response body is received, in milliseconds. */
     networkEndTime: number;
@@ -203,6 +207,7 @@ export class NetworkRequest {
      * @param {LH.Crdp.Network.ResponseReceivedEvent['type']=} resourceType
      */
     _onResponse(response: LH.Crdp.Network.Response, timestamp: number, resourceType?: LH.Crdp.Network.ResponseReceivedEvent['type'] | undefined): void;
+    responseTimestamp: number | undefined;
     /**
      * Resolve differences between conflicting timing signals. Based on the property setters in DevTools.
      * @see https://github.com/ChromeDevTools/devtools-frontend/blob/56a99365197b85c24b732ac92b0ac70feed80179/front_end/sdk/NetworkRequest.js#L485-L502

package/core/lib/network-request.js

@@ -129,7 +129,11 @@ class NetworkRequest {
      * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
      */
     this.networkRequestTime = -1;
-    /** When the last byte of the response headers is received, in milliseconds. */
+    /**
+     * When the last byte of the response headers is received, in milliseconds.
+     * Equal to networkRequestTime if no data is recieved over the
+     * network (ex: cached requests or data urls).
+     */
     this.responseHeadersEndTime = -1;
     /** When the last byte of the response body is received, in milliseconds. */
     this.networkEndTime = -1;
@@ -222,8 +226,9 @@ class NetworkRequest {
     this.isSecure = UrlUtils.isSecureScheme(this.parsedURL.scheme);
 
     this.rendererStartTime = data.timestamp * 1000;
-    // Expected to be overridden with better value in `_recomputeTimesWithResourceTiming`.
+    // These are expected to be overridden with better value in `_recomputeTimesWithResourceTiming`.
     this.networkRequestTime = this.rendererStartTime;
+    this.responseHeadersEndTime = this.rendererStartTime;
 
     this.requestMethod = data.request.method;
 
@@ -350,8 +355,7 @@ class NetworkRequest {
 
     if (response.protocol) this.protocol = response.protocol;
 
-    // This is updated in _recomputeTimesWithResourceTiming, if timings are present.
-    this.responseHeadersEndTime = timestamp * 1000;
+    this.responseTimestamp = timestamp * 1000;
 
     this.transferSize = response.encodedDataLength;
     this.responseHeadersTransferSize = response.encodedDataLength;
@@ -381,7 +385,7 @@ class NetworkRequest {
   _recomputeTimesWithResourceTiming(timing) {
     // Don't recompute times if the data is invalid. RequestTime should always be a thread timestamp.
     // If we don't have receiveHeadersEnd, we really don't have more accurate data.
-    if (timing.requestTime === 0 || timing.receiveHeadersEnd === -1) return;
+    if (timing.requestTime === -1 || timing.receiveHeadersEnd === -1) return;
 
     // Take networkRequestTime and responseHeadersEndTime from timing data for better accuracy.
     // Before this, networkRequestTime and responseHeadersEndTime were set to bogus values based on
@@ -392,15 +396,15 @@ class NetworkRequest {
     // See https://raw.githubusercontent.com/GoogleChrome/lighthouse/main/docs/Network-Timings.svg
     this.networkRequestTime = timing.requestTime * 1000;
     const headersReceivedTime = this.networkRequestTime + timing.receiveHeadersEnd;
-    // This was set in `_onResponse` as that event's timestamp.
-    const responseTimestamp = this.responseHeadersEndTime;
 
     // Update this.responseHeadersEndTime. All timing values from the netstack (timing) are well-ordered, and
     // so are the timestamps from CDP (which this.responseHeadersEndTime belongs to). It shouldn't be possible
     // that this timing from the netstack is greater than the onResponse timestamp, but just to ensure proper order
     // is maintained we bound the new timing by the network request time and the response timestamp.
     this.responseHeadersEndTime = headersReceivedTime;
-    this.responseHeadersEndTime = Math.min(this.responseHeadersEndTime, responseTimestamp);
+    if (this.responseTimestamp !== undefined) {
+      this.responseHeadersEndTime = Math.min(this.responseHeadersEndTime, this.responseTimestamp);
+    }
     this.responseHeadersEndTime = Math.max(this.responseHeadersEndTime, this.networkRequestTime);
 
     // We're only at responseReceived (_onResponse) at this point.
@@ -604,10 +608,10 @@ class NetworkRequest {
     record.fromWorker = record.sessionTargetType === 'worker';
 
     return {
+      rawRequest: record,
       ...record,
       timing,
       serverResponseTime,
-      record,
     };
   }
 

package/package.json

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

package/shared/localization/locales/en-US.json

@@ -18,13 +18,13 @@
     "message": "`[aria-*]` attributes match their roles"
   },
   "core/audits/accessibility/aria-allowed-role.js | description": {
-    "message": "ARIA `role`s enable assistive technologies to know the role of each element on the web page. If the `role` values are misspelled, not existing ARIA `role` values, or abstract roles, then the purpose of the element will not be communicated to users of assistive technologies. [Learn more about ARIA roles](https://dequeuniversity.com/rules/axe/4.9/aria-allowed-role)."
+    "message": "Many HTML elements can only be assigned certain ARIA roles. Using ARIA roles where they are not allowed can interfere with the accessibility of the web page. [Learn more about ARIA roles](https://dequeuniversity.com/rules/axe/4.9/aria-allowed-role)."
   },
   "core/audits/accessibility/aria-allowed-role.js | failureTitle": {
-    "message": "Values assigned to `role=\"\"` are not valid ARIA roles."
+    "message": "Uses ARIA roles on incompatible elements"
   },
   "core/audits/accessibility/aria-allowed-role.js | title": {
-    "message": "Values assigned to `role=\"\"` are valid ARIA roles."
+    "message": "Uses ARIA roles only on compatible elements"
   },
   "core/audits/accessibility/aria-command-name.js | description": {
     "message": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to make command elements more accessible](https://dequeuniversity.com/rules/axe/4.9/aria-command-name)."

package/shared/localization/locales/en-XL.json

@@ -18,13 +18,13 @@
     "message": "`[aria-*]` ât́t̂ŕîb́ût́êś m̂át̂ćĥ t́ĥéîŕ r̂ól̂éŝ"
   },
   "core/audits/accessibility/aria-allowed-role.js | description": {
-    "message": "ÂŔÎÁ `role`ŝ én̂áb̂ĺê áŝśîśt̂ív̂é t̂éĉh́n̂ól̂óĝíêś t̂ó k̂ńôẃ t̂h́ê ŕôĺê óf̂ éâćĥ él̂ém̂én̂t́ ôń t̂h́ê ẃêb́ p̂áĝé. Îf́ t̂h́ê `role` v́âĺûéŝ ár̂é m̂íŝśp̂él̂ĺêd́, n̂ót̂ éx̂íŝt́îńĝ ÁR̂ÍÂ `role` v́âĺûéŝ, ór̂ áb̂śt̂ŕâćt̂ ŕôĺêś, t̂h́êń t̂h́ê ṕûŕp̂óŝé ôf́ t̂h́ê él̂ém̂én̂t́ ŵíl̂ĺ n̂ót̂ b́ê ćôḿm̂ún̂íĉát̂éd̂ t́ô úŝér̂ś ôf́ âśŝíŝt́îv́ê t́êćĥńôĺôǵîéŝ. [Ĺêár̂ń m̂ór̂é âb́ôút̂ ÁR̂ÍÂ ŕôĺêś](https://dequeuniversity.com/rules/axe/4.9/aria-allowed-role)."
+    "message": "M̂án̂ý ĤT́M̂Ĺ êĺêḿêńt̂ś ĉán̂ ón̂ĺŷ b́ê áŝśîǵn̂éd̂ ćêŕt̂áîń ÂŔÎÁ r̂ól̂éŝ. Úŝín̂ǵ ÂŔÎÁ r̂ól̂éŝ ẃĥér̂é t̂h́êý âŕê ńôt́ âĺl̂óŵéd̂ ćâń îńt̂ér̂f́êŕê ẃît́ĥ t́ĥé âćĉéŝśîb́îĺît́ŷ óf̂ t́ĥé ŵéb̂ ṕâǵê. [Ĺêár̂ń m̂ór̂é âb́ôút̂ ÁR̂ÍÂ ŕôĺêś](https://dequeuniversity.com/rules/axe/4.9/aria-allowed-role)."
   },
   "core/audits/accessibility/aria-allowed-role.js | failureTitle": {
-    "message": "V̂ál̂úêś âśŝíĝńêd́ t̂ó `role=\"\"` âŕê ńôt́ v̂ál̂íd̂ ÁR̂ÍÂ ŕôĺêś."
+    "message": "Ûśêś ÂŔÎÁ r̂ól̂éŝ ón̂ ín̂ćôḿp̂át̂íb̂ĺê él̂ém̂én̂t́ŝ"
   },
   "core/audits/accessibility/aria-allowed-role.js | title": {
-    "message": "V̂ál̂úêś âśŝíĝńêd́ t̂ó `role=\"\"` âŕê v́âĺîd́ ÂŔÎÁ r̂ól̂éŝ."
+    "message": "Ûśêś ÂŔÎÁ r̂ól̂éŝ ón̂ĺŷ ón̂ ćôḿp̂át̂íb̂ĺê él̂ém̂én̂t́ŝ"
   },
   "core/audits/accessibility/aria-command-name.js | description": {
     "message": "Ŵh́êń âń êĺêḿêńt̂ d́ôéŝń't̂ h́âv́ê án̂ áĉćêśŝíb̂ĺê ńâḿê, śĉŕêén̂ ŕêád̂ér̂ś âńn̂óûńĉé ît́ ŵít̂h́ â ǵêńêŕîć n̂ám̂é, m̂ák̂ín̂ǵ ît́ ûńûśâb́l̂é f̂ór̂ úŝér̂ś ŵh́ô ŕêĺŷ ón̂ śĉŕêén̂ ŕêád̂ér̂ś. [L̂éâŕn̂ h́ôẃ t̂ó m̂ák̂é ĉóm̂ḿâńd̂ él̂ém̂én̂t́ŝ ḿôŕê áĉćêśŝíb̂ĺê](https://dequeuniversity.com/rules/axe/4.9/aria-command-name)."