lighthouse 12.0.0-dev.20240602 → 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

@@ -53,7 +53,7 @@ function getNodesAndTimingByRequestId(nodeTimings) {
   for (const [node, nodeTiming] of nodeTimings) {
     if (node.type !== 'network') continue;
 
-    requestIdToNode.set(node.record.requestId, {node, nodeTiming});
+    requestIdToNode.set(node.request.requestId, {node, nodeTiming});
   }
 
   return requestIdToNode;
@@ -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.record.requestId, node.record.protocol);
+      originalProtocols.set(node.request.requestId, node.request.protocol);
       node.request.protocol = 'h2';
     });
 
@@ -98,7 +98,7 @@ class UsesHTTP2Audit extends Audit {
     // Restore the original protocol after we've done our simulation
     graph.traverse(node => {
       if (node.type !== 'network') return;
-      const originalProtocol = originalProtocols.get(node.record.requestId);
+      const originalProtocol = originalProtocols.get(node.request.requestId);
       if (originalProtocol === undefined) return;
       node.request.protocol = originalProtocol;
     });

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

@@ -69,7 +69,7 @@ class PrioritizeLcpImage extends Audit {
   static findLCPNode(graph, lcpRecord) {
     for (const {node} of graph.traverseGenerator()) {
       if (node.type !== 'network') continue;
-      if (node.record.requestId === lcpRecord.requestId) {
+      if (node.request.requestId === lcpRecord.requestId) {
         return node;
       }
     }
@@ -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/redirects.js

@@ -98,7 +98,7 @@ class Redirects extends Audit {
     const nodeTimingsById = new Map();
     for (const [node, timing] of metricResult.pessimisticEstimate.nodeTimings.entries()) {
       if (node.type === 'network') {
-        nodeTimingsById.set(node.record.requestId, timing);
+        nodeTimingsById.set(node.request.requestId, timing);
       }
     }
 

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

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

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

@@ -7,14 +7,14 @@
 import {LanternError} from '../../lib/lantern/lantern-error.js';
 import {LighthouseError} from '../../lib/lh-error.js';
 import {LoadSimulator} from '../load-simulator.js';
-import {PageDependencyGraph} from '../page-dependency-graph.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
+import {PageDependencyGraph} from '../page-dependency-graph.js';
 
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
  * @param {LH.Artifacts.ComputedContext} context
  */
-async function getComputationDataParams(data, context) {
+async function getComputationDataParamsFromDevtoolsLog(data, context) {
   if (data.gatherContext.gatherMode !== 'navigation') {
     throw new Error(`Lantern metrics can only be computed on navigations`);
   }
@@ -26,6 +26,22 @@ async function getComputationDataParams(data, context) {
   return {simulator, graph, processedNavigation};
 }
 
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+async function getComputationDataParamsFromTrace(data, context) {
+  if (data.gatherContext.gatherMode !== 'navigation') {
+    throw new Error(`Lantern metrics can only be computed on navigations`);
+  }
+
+  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));
+
+  return {simulator, graph, processedNavigation};
+}
+
 /**
  * @param {unknown} err
  * @return {never}
@@ -43,7 +59,23 @@ function lanternErrorAdapter(err) {
   throw err;
 }
 
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+function getComputationDataParams(data, context) {
+  // TODO(15841): remove devtools impl when ready to make breaking change.
+  if (process.env.INTERNAL_LANTERN_USE_TRACE !== undefined) {
+    return getComputationDataParamsFromTrace(data, context);
+  } else {
+    // This is the default behavior.
+    return getComputationDataParamsFromDevtoolsLog(data, context);
+  }
+}
+
 export {
+  getComputationDataParamsFromTrace,
+  getComputationDataParamsFromDevtoolsLog,
   getComputationDataParams,
   lanternErrorAdapter,
 };

package/core/computed/navigation-insights.d.ts

@@ -11,6 +11,7 @@ declare const NavigationInsightsComputed: typeof NavigationInsights & {
         Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
         Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
         PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+        Workers: typeof import("@paulirish/trace_engine/models/trace/handlers/WorkersHandler.js");
     }>>;
 };
 /**
@@ -31,6 +32,7 @@ declare class NavigationInsights {
         Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
         Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
         PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+        Workers: typeof import("@paulirish/trace_engine/models/trace/handlers/WorkersHandler.js");
     }>>;
 }
 //# sourceMappingURL=navigation-insights.d.ts.map

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/computed/trace-engine-result.d.ts

@@ -16,6 +16,7 @@ declare namespace ENABLED_HANDLERS {
     const Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
     const Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
     const PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+    const Workers: typeof import("@paulirish/trace_engine/models/trace/handlers/WorkersHandler.js");
 }
 /**
  * @fileoverview Processes trace with the shared trace engine.

package/core/computed/trace-engine-result.js

@@ -21,6 +21,7 @@ const ENABLED_HANDLERS = {
   Samples: TraceEngine.TraceHandlers.Samples,
   Screenshots: TraceEngine.TraceHandlers.Screenshots,
   PageLoadMetrics: TraceEngine.TraceHandlers.PageLoadMetrics,
+  Workers: TraceEngine.TraceHandlers.Workers,
 };
 
 /**

package/core/lib/lantern/metric.js

@@ -6,7 +6,7 @@
 
 import * as Lantern from './types/lantern.js';
 import {BaseNode} from '../../lib/lantern/base-node.js';
-import {NetworkRequest} from '../../lib/network-request.js';
+import {RESOURCE_TYPES} from '../../lib/network-request.js';
 
 /** @typedef {import('./base-node.js').Node} Node */
 /** @typedef {import('./network-node.js').NetworkNode} NetworkNode */
@@ -33,9 +33,9 @@ class Metric {
 
     dependencyGraph.traverse(node => {
       if (node.type !== BaseNode.TYPES.NETWORK) return;
-      if (node.record.resourceType !== NetworkRequest.TYPES.Script) return;
+      if (node.request.resourceType !== RESOURCE_TYPES.Script) return;
       if (treatNodeAsRenderBlocking?.(node)) {
-        scriptUrls.add(node.record.url);
+        scriptUrls.add(node.request.url);
       }
     });
 

package/core/lib/lantern/metrics/first-contentful-paint.js

@@ -153,7 +153,7 @@ class FirstContentfulPaint extends Metric {
         const endedAfterPaint = node.endTime > cutoffTimestamp || node.startTime > cutoffTimestamp;
         if (endedAfterPaint && !node.isMainDocument()) return false;
 
-        const url = node.record.url;
+        const url = node.request.url;
         // If the URL definitely wasn't render-blocking then we filter it out.
         if (definitelyNotRenderBlockingScriptUrls.has(url)) {
           return false;

package/core/lib/lantern/metrics/interactive.js

@@ -41,13 +41,13 @@ class Interactive extends Metric {
       }
 
       // Include all scripts and high priority requests, exclude all images
-      const isImage = node.record.resourceType === NetworkRequestTypes.Image;
-      const isScript = node.record.resourceType === NetworkRequestTypes.Script;
+      const isImage = node.request.resourceType === NetworkRequestTypes.Image;
+      const isScript = node.request.resourceType === NetworkRequestTypes.Script;
       return (
         !isImage &&
         (isScript ||
-          node.record.priority === 'High' ||
-          node.record.priority === 'VeryHigh')
+          node.request.priority === 'High' ||
+          node.request.priority === 'VeryHigh')
       );
     });
   }

package/core/lib/lantern/metrics/largest-contentful-paint.js

@@ -32,8 +32,8 @@ class LargestContentfulPaint extends Metric {
    */
   static isNotLowPriorityImageNode(node) {
     if (node.type !== 'network') return true;
-    const isImage = node.record.resourceType === 'Image';
-    const isLowPriority = node.record.priority === 'Low' || node.record.priority === 'VeryLow';
+    const isImage = node.request.resourceType === 'Image';
+    const isLowPriority = node.request.priority === 'Low' || node.request.priority === 'VeryLow';
     return !isImage || !isLowPriority;
   }
 

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>}
@@ -39,13 +39,69 @@ export class PageDependencyGraph {
      * @param {Node} node
      */
     static _pruneNode(node: Node): void;
+    /**
+     * TODO(15841): remove when CDT backend is gone. until then, this is a useful debugging tool
+     * to find delta between using CDP or the trace to create the network requests.
+     *
+     * When a test fails using the trace backend, I enabled this debug method and copied the network
+     * requests when CDP was used, then when trace is used, and diff'd them. This method helped
+     * remove non-logical differences from the comparison (order of properties, slight rounding
+     * discrepancies, removing object cycles, etc).
+     *
+     * When using for a unit test, make sure to do `.only` so you are getting what you expect.
+     * @param {Lantern.NetworkRequest[]} lanternRequests
+     * @return {never}
+     */
+    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} request The request to find the initiator of
+     * @param {Map<string, Lantern.NetworkRequest[]>} requestsByURL
+     * @return {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
+     * @return {Map<number, number[]>}
+     */
+    static _findWorkerThreads(trace: LH.Trace): Map<number, number[]>;
+    /**
+     * @param {URL|string} url
+     */
+    static _createParsedUrl(url: URL | string): {
+        scheme: string;
+        host: string;
+        securityOrigin: string;
+    };
+    /**
+     * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+     * @param {Map<number, number[]>} workerThreads
+     * @param {import('@paulirish/trace_engine/models/trace/types/TraceEvents.js').SyntheticNetworkRequest} request
+     * @return {Lantern.NetworkRequest=}
+     */
+    static _createLanternRequest(traceEngineResult: LH.Artifacts.TraceEngineResult, workerThreads: Map<number, number[]>, request: import('@paulirish/trace_engine/models/trace/types/TraceEvents.js').SyntheticNetworkRequest): Lantern.NetworkRequest | undefined;
+    /**
+     *
+     * @param {Lantern.NetworkRequest[]} lanternRequests
+     */
+    static _linkInitiators(lanternRequests: Lantern.NetworkRequest[]): void;
+    /**
+     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+     * @param {LH.Artifacts.URL} URL
+     */
+    static createGraphFromTrace(mainThreadEvents: LH.TraceEvent[], trace: LH.Trace, traceEngineResult: LH.Artifacts.TraceEngineResult, URL: LH.Artifacts.URL): Promise<{
+        graph: Node;
+        records: Lantern.NetworkRequest<any>[];
+    }>;
     /**
      *
      * @param {Node} rootNode