lighthouse 12.0.0-dev.20240603 → 12.0.0-dev.20240604

package/core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -120,7 +120,7 @@ class ByteEfficiencyAudit extends Audit {
     const originalTransferSizes = new Map();
     graph.traverse(node => {
       if (node.type !== 'network') return;
-      const wastedBytes = wastedBytesByUrl.get(node.record.url);
+      const wastedBytes = wastedBytesByUrl.get(node.request.url);
       if (!wastedBytes) return;
 
       const original = node.request.transferSize;

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

@@ -128,7 +128,7 @@ class OffscreenImages extends ByteEfficiencyAudit {
       if (node.type === 'cpu' && timing.duration >= 50) {
         lastLongTaskStartTime = Math.max(lastLongTaskStartTime, timing.startTime);
       } else if (node.type === 'network') {
-        startTimesByURL.set(node.record.url, timing.startTime);
+        startTimesByURL.set(node.request.url, timing.startTime);
       }
     }
 

package/core/audits/byte-efficiency/render-blocking-resources.js

@@ -94,7 +94,7 @@ function computeStackSpecificTiming(node, nodeTiming, Stacks) {
     // https://github.com/ampproject/amphtml/blob/8e03ac2f315774070651584a7e046ff24212c9b1/src/font-stylesheet-timeout.js#L54-L59
     // Any potential savings must only include time spent on AMP stylesheet nodes before 2.1 seconds.
     if (node.type === BaseNode.TYPES.NETWORK &&
-        node.record.resourceType === NetworkRequest.TYPES.Stylesheet &&
+        node.request.resourceType === NetworkRequest.TYPES.Stylesheet &&
         nodeTiming.endTime > 2100) {
       stackSpecificTiming.endTime = Math.max(nodeTiming.startTime, 2100);
       stackSpecificTiming.duration = stackSpecificTiming.endTime - stackSpecificTiming.startTime;
@@ -228,11 +228,11 @@ class RenderBlockingResources extends Audit {
       if (node.type !== BaseNode.TYPES.NETWORK) return !canDeferRequest;
 
       const isStylesheet =
-        node.record.resourceType === NetworkRequest.TYPES.Stylesheet;
+        node.request.resourceType === NetworkRequest.TYPES.Stylesheet;
       if (canDeferRequest && isStylesheet) {
         // We'll inline the used bytes of the stylesheet and assume the rest can be deferred
-        const wastedBytes = wastedCssBytesByUrl.get(node.record.url) || 0;
-        totalChildNetworkBytes += (node.record.transferSize || 0) - wastedBytes;
+        const wastedBytes = wastedCssBytesByUrl.get(node.request.url) || 0;
+        totalChildNetworkBytes += (node.request.transferSize || 0) - wastedBytes;
       }
       return !canDeferRequest;
     });
@@ -247,7 +247,7 @@ class RenderBlockingResources extends Audit {
     ));
 
     // Add the inlined bytes to the HTML response
-    const originalTransferSize = minimalFCPGraph.record.transferSize;
+    const originalTransferSize = minimalFCPGraph.request.transferSize;
     const safeTransferSize = originalTransferSize || 0;
     minimalFCPGraph.request.transferSize = safeTransferSize + totalChildNetworkBytes;
     const estimateAfterInline = simulator.simulate(minimalFCPGraph).timeInMs;

package/core/audits/dobetterweb/uses-http2.js

@@ -87,9 +87,9 @@ class UsesHTTP2Audit extends Audit {
     const originalProtocols = new Map();
     graph.traverse(node => {
       if (node.type !== 'network') return;
-      if (!urlsToChange.has(node.record.url)) return;
+      if (!urlsToChange.has(node.request.url)) return;
 
-      originalProtocols.set(node.request.requestId, node.record.protocol);
+      originalProtocols.set(node.request.requestId, node.request.protocol);
       node.request.protocol = 'h2';
     });
 

package/core/audits/prioritize-lcp-image.js

@@ -222,7 +222,7 @@ class PrioritizeLcpImage extends Audit {
       wastedMs,
       results: [{
         node: Audit.makeNodeItem(lcpElement.node),
-        url: lcpNode.record.url,
+        url: lcpNode.request.url,
         wastedMs,
       }],
     };

package/core/audits/third-party-facades.js

@@ -225,7 +225,7 @@ class ThirdPartyFacades extends Audit {
         itemCount: results.length,
       }),
       details: Audit.makeTableDetails(headings, results),
-      metricSavings: {TBT: tbtImpact},
+      metricSavings: {TBT: Math.round(tbtImpact)},
     };
   }
 }

package/core/audits/third-party-summary.js

@@ -223,7 +223,7 @@ class ThirdPartySummary extends Audit {
       }),
       details,
       metricSavings: {
-        TBT: overallSummary.tbtImpact,
+        TBT: Math.round(overallSummary.tbtImpact),
       },
     };
   }

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

@@ -146,14 +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.request.url);
     });
 
     const fcpGraph =
       await LanternFirstContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
     const fcpGraphURLs = new Set();
     fcpGraph.traverse(node => {
-      if (node.type === 'network') fcpGraphURLs.add(node.record.url);
+      if (node.type === 'network') fcpGraphURLs.add(node.request.url);
     });
 
     /** @type {Map<string, LH.Artifacts.NetworkRequest[]>}  */

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

@@ -61,8 +61,8 @@ class UsesRelPreloadAudit extends Audit {
       if (node.type !== 'network') return;
       // Don't include the node itself or any CPU nodes in the initiatorPath
       const path = traversalPath.slice(1).filter(initiator => initiator.type === 'network');
-      if (!UsesRelPreloadAudit.shouldPreloadRequest(node.record, mainResource, path)) return;
-      urls.add(node.record.url);
+      if (!UsesRelPreloadAudit.shouldPreloadRequest(node.rawRequest, mainResource, path)) return;
+      urls.add(node.rawRequest.url);
     });
 
     return urls;
@@ -77,7 +77,7 @@ class UsesRelPreloadAudit extends Audit {
   static getURLsFailedToPreload(graph) {
     /** @type {Array<LH.Artifacts.NetworkRequest>} */
     const requests = [];
-    graph.traverse(node => node.type === 'network' && requests.push(node.record));
+    graph.traverse(node => node.type === 'network' && requests.push(node.rawRequest));
 
     const preloadRequests = requests.filter(req => req.isLinkPreload);
     const preloadURLsByFrame = new Map();
@@ -157,7 +157,7 @@ class UsesRelPreloadAudit extends Audit {
 
       if (node.isMainDocument()) {
         mainDocumentNode = node;
-      } else if (node.record && urls.has(node.record.url)) {
+      } else if (node.rawRequest && urls.has(node.rawRequest.url)) {
         nodesToPreload.push(node);
       }
     });
@@ -176,20 +176,20 @@ class UsesRelPreloadAudit extends Audit {
 
     // Once we've modified the dependencies, simulate the new graph.
     const simulationAfterChanges = simulator.simulate(modifiedGraph);
-    const originalNodesByRecord = Array.from(simulationBeforeChanges.nodeTimings.keys())
-        // @ts-expect-error we don't care if all nodes without a record collect on `undefined`
-        .reduce((map, node) => map.set(node.record, node), new Map());
+    const originalNodesByRequest = Array.from(simulationBeforeChanges.nodeTimings.keys())
+        // @ts-expect-error we don't care if all nodes without a request collect on `undefined`
+        .reduce((map, node) => map.set(node.request, node), new Map());
 
     const results = [];
     for (const node of nodesToPreload) {
-      const originalNode = originalNodesByRecord.get(node.record);
+      const originalNode = originalNodesByRequest.get(node.request);
       const timingAfter = simulationAfterChanges.nodeTimings.get(node);
       const timingBefore = simulationBeforeChanges.nodeTimings.get(originalNode);
       if (!timingBefore || !timingAfter) throw new Error('Missing preload node');
 
       const wastedMs = Math.round(timingBefore.endTime - timingAfter.endTime);
       if (wastedMs < THRESHOLD_IN_MS) continue;
-      results.push({url: node.record.url, wastedMs});
+      results.push({url: node.rawRequest.url, wastedMs});
     }
 
     if (!results.length) {

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

@@ -105,19 +105,19 @@ class CriticalRequestChains {
     graph.traverse((node, traversalPath) => {
       seenNodes.add(node);
       if (node.type !== 'network') return;
-      if (!CriticalRequestChains.isCritical(node.record, mainResource)) return;
+      if (!CriticalRequestChains.isCritical(node.rawRequest, mainResource)) return;
 
       const networkPath = traversalPath
         .filter(/** @return {n is LH.Gatherer.Simulation.GraphNetworkNode} */
           n => n.type === 'network')
         .reverse()
-        .map(node => node.record);
+        .map(node => node.rawRequest);
 
       // Ignore if some ancestor is not a critical request.
       if (networkPath.some(r => !CriticalRequestChains.isCritical(r, mainResource))) return;
 
       // Ignore non-network things (like data urls).
-      if (NetworkRequest.isNonNetworkRequest(node.record)) return;
+      if (NetworkRequest.isNonNetworkRequest(node.rawRequest)) return;
 
       addChain(networkPath);
     }, getNextNodes);

package/core/computed/metrics/lantern-metric.d.ts

@@ -4,7 +4,7 @@
  */
 export function getComputationDataParamsFromTrace(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
     simulator: import("../../lib/lantern/simulator/simulator.js").Simulator<any>;
-    graph: import("../../lib/lantern/page-dependency-graph.js").Node;
+    graph: import("../page-dependency-graph.js").Node;
     processedNavigation: import("../../index.js").Artifacts.ProcessedNavigation;
 }>;
 /**
@@ -22,7 +22,7 @@ export function getComputationDataParamsFromDevtoolsLog(data: LH.Artifacts.Metri
  */
 export function getComputationDataParams(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
     simulator: import("../../lib/lantern/simulator/simulator.js").Simulator<any>;
-    graph: import("../../lib/lantern/page-dependency-graph.js").Node;
+    graph: import("../page-dependency-graph.js").Node;
     processedNavigation: import("../../index.js").Artifacts.ProcessedNavigation;
 }>;
 /**

package/core/computed/metrics/lantern-metric.js

@@ -5,15 +5,11 @@
  */
 
 import {LanternError} from '../../lib/lantern/lantern-error.js';
-import {PageDependencyGraph as LanternPageDependencyGraph} from '../../lib/lantern/page-dependency-graph.js';
 import {LighthouseError} from '../../lib/lh-error.js';
 import {LoadSimulator} from '../load-simulator.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
-import {ProcessedTrace} from '../processed-trace.js';
-import {TraceEngineResult} from '../trace-engine-result.js';
 import {PageDependencyGraph} from '../page-dependency-graph.js';
 
-// TODO: we need to update all test traces (that use lantern) before this can be removed
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
  * @param {LH.Artifacts.ComputedContext} context
@@ -30,18 +26,6 @@ async function getComputationDataParamsFromDevtoolsLog(data, context) {
   return {simulator, graph, processedNavigation};
 }
 
-/**
- * @param {LH.Artifacts.URL} theURL
- * @param {LH.Trace} trace
- * @param {LH.Artifacts.ComputedContext} context
- */
-async function createGraphFromTrace(theURL, trace, context) {
-  const {mainThreadEvents} = await ProcessedTrace.request(trace, context);
-  const traceEngineResult = await TraceEngineResult.request({trace}, context);
-  return LanternPageDependencyGraph.createGraphFromTrace(
-    mainThreadEvents, trace, traceEngineResult, theURL);
-}
-
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
  * @param {LH.Artifacts.ComputedContext} context
@@ -51,8 +35,7 @@ async function getComputationDataParamsFromTrace(data, context) {
     throw new Error(`Lantern metrics can only be computed on navigations`);
   }
 
-  const {trace, URL} = data;
-  const {graph} = await createGraphFromTrace(URL, trace, context);
+  const graph = await PageDependencyGraph.request({...data, fromTrace: true}, context);
   const processedNavigation = await ProcessedNavigation.request(data.trace, context);
   const simulator = data.simulator || (await LoadSimulator.request(data, context));
 
@@ -81,7 +64,7 @@ function lanternErrorAdapter(err) {
  * @param {LH.Artifacts.ComputedContext} context
  */
 function getComputationDataParams(data, context) {
-  // TODO(15841): remove when all tests use the trace, and we want to remove CDT graph impl.
+  // TODO(15841): remove devtools impl when ready to make breaking change.
   if (process.env.INTERNAL_LANTERN_USE_TRACE !== undefined) {
     return getComputationDataParamsFromTrace(data, context);
   } else {

package/core/computed/page-dependency-graph.d.ts

@@ -5,6 +5,7 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
         trace: LH.Trace;
         devtoolsLog: import("../index.js").DevtoolsLog;
         URL: LH.Artifacts['URL'];
+        fromTrace?: boolean | undefined;
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<Node>;
@@ -13,7 +14,7 @@ import { NetworkRequest } from '../lib/network-request.js';
 /** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 declare class PageDependencyGraph {
     /**
-     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<Node>}
      */
@@ -21,6 +22,7 @@ declare class PageDependencyGraph {
         trace: LH.Trace;
         devtoolsLog: import("../index.js").DevtoolsLog;
         URL: LH.Artifacts['URL'];
+        fromTrace?: boolean | undefined;
     }, context: LH.Artifacts.ComputedContext): Promise<Node>;
 }
 //# sourceMappingURL=page-dependency-graph.d.ts.map

package/core/computed/page-dependency-graph.js

@@ -9,28 +9,35 @@ import {PageDependencyGraph as LanternPageDependencyGraph} from '../lib/lantern/
 import {NetworkRequest} from '../lib/network-request.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
+import {TraceEngineResult} from './trace-engine-result.js';
 
 /** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
 class PageDependencyGraph {
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
     const {trace, devtoolsLog, URL} = data;
-    const [processedTrace, networkRecords] = await Promise.all([
+    const [{mainThreadEvents}, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    const mainThreadEvents = processedTrace.mainThreadEvents;
+    if (data.fromTrace) {
+      const traceEngineResult = await TraceEngineResult.request({trace}, context);
+      const {graph} = await LanternPageDependencyGraph.createGraphFromTrace(
+        mainThreadEvents, trace, traceEngineResult, URL);
+      return graph;
+    }
+
     const lanternRequests = networkRecords.map(NetworkRequest.asLanternNetworkRequest);
     return LanternPageDependencyGraph.createGraph(mainThreadEvents, lanternRequests, URL);
   }
 }
 
 const PageDependencyGraphComputed =
-  makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL']);
+  makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL', 'fromTrace']);
 export {PageDependencyGraphComputed as PageDependencyGraph};

package/core/lib/lantern/network-node.d.ts

@@ -13,7 +13,7 @@ export class NetworkNode<T = any> extends BaseNode<T> {
     /**
      * @return {Readonly<T>}
      */
-    get record(): Readonly<T>;
+    get rawRequest(): Readonly<T>;
     /**
      * @return {Lantern.NetworkRequest<T>}
      */
@@ -31,7 +31,7 @@ export class NetworkNode<T = any> extends BaseNode<T> {
      */
     get isNonNetworkProtocol(): boolean;
     /**
-     * Returns whether this network record can be downloaded without a TCP connection.
+     * Returns whether this network request can be downloaded without a TCP connection.
      * During simulation we treat data coming in over a network connection separately from on-device data.
      * @return {boolean}
      */

package/core/lib/lantern/network-node.js

@@ -18,7 +18,6 @@ const NON_NETWORK_SCHEMES = [
 ];
 
 /**
- * Use `NetworkRequest.isNonNetworkRequest(req)` if working with a request.
  * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
  *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
  * However, a `new URL(href).protocol` has a colon suffix.
@@ -69,8 +68,8 @@ class NetworkNode extends BaseNode {
   /**
    * @return {Readonly<T>}
    */
-  get record() {
-    return /** @type {Required<T>} */ (this._request.record);
+  get rawRequest() {
+    return /** @type {Required<T>} */ (this._request.rawRequest);
   }
 
   /**
@@ -105,7 +104,7 @@ class NetworkNode extends BaseNode {
   }
 
   /**
-   * Returns whether this network record can be downloaded without a TCP connection.
+   * Returns whether this network request can be downloaded without a TCP connection.
    * During simulation we treat data coming in over a network connection separately from on-device data.
    * @return {boolean}
    */

package/core/lib/lantern/page-dependency-graph.d.ts

@@ -8,15 +8,15 @@ export type NetworkNodeOutput = {
 };
 export class PageDependencyGraph {
     /**
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      * @return {Array<string>}
      */
-    static getNetworkInitiators(record: Lantern.NetworkRequest): Array<string>;
+    static getNetworkInitiators(request: Lantern.NetworkRequest): Array<string>;
     /**
-     * @param {Array<Lantern.NetworkRequest>} networkRecords
+     * @param {Array<Lantern.NetworkRequest>} networkRequests
      * @return {NetworkNodeOutput}
      */
-    static getNetworkNodeOutput(networkRecords: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
+    static getNetworkNodeOutput(networkRequests: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
     /**
      * @param {LH.TraceEvent[]} mainThreadEvents
      * @return {Array<CPUNode>}
@@ -55,17 +55,17 @@ export class PageDependencyGraph {
     static _debugNormalizeRequests(lanternRequests: Lantern.NetworkRequest[]): never;
     /**
      * @param {LH.TraceEvent[]} mainThreadEvents
-     * @param {Array<Lantern.NetworkRequest>} networkRecords
+     * @param {Lantern.NetworkRequest[]} networkRequests
      * @param {URLArtifact} URL
      * @return {Node}
      */
-    static createGraph(mainThreadEvents: LH.TraceEvent[], networkRecords: Array<Lantern.NetworkRequest>, URL: URLArtifact): Node;
+    static createGraph(mainThreadEvents: LH.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: URLArtifact): Node;
     /**
-     * @param {Lantern.NetworkRequest} record The record to find the initiator of
-     * @param {Map<string, Lantern.NetworkRequest[]>} recordsByURL
+     * @param {Lantern.NetworkRequest} request The request to find the initiator of
+     * @param {Map<string, Lantern.NetworkRequest[]>} requestsByURL
      * @return {Lantern.NetworkRequest|null}
      */
-    static chooseInitiatorRequest(record: Lantern.NetworkRequest, recordsByURL: Map<string, Lantern.NetworkRequest[]>): Lantern.NetworkRequest | null;
+    static chooseInitiatorRequest(request: Lantern.NetworkRequest, requestsByURL: Map<string, Lantern.NetworkRequest[]>): Lantern.NetworkRequest | null;
     /**
      * Returns a map of `pid` -> `tid[]`.
      * @param {LH.Trace} trace