lighthouse 12.0.0-dev.20240609 → 12.0.0-dev.20240611

package/core/lib/lantern/lantern.js

@@ -6,10 +6,7 @@
 
 import * as Lantern from './types/lantern.js';
 
-/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName} MetricName */
-/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore} MetricScore */
-
-/** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
+/** @type {Lantern.Util.SelfMap<Lantern.ResourceType>} */
 const NetworkRequestTypes = {
   XHR: 'XHR',
   Fetch: 'Fetch',
@@ -31,48 +28,48 @@ const NetworkRequestTypes = {
   Prefetch: 'Prefetch',
 };
 
-/**
- * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
- * @return {Lantern.Simulation.ProcessedNavigation}
- */
-function createProcessedNavigation(traceEngineResult) {
-  const Meta = traceEngineResult.data.Meta;
-  const frameId = Meta.mainFrameId;
-  const scoresByNav = traceEngineResult.data.PageLoadMetrics.metricScoresByFrameId.get(frameId);
-  if (!scoresByNav) {
-    throw new Error('missing metric scores for main frame');
-  }
+const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
+const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
 
-  const lastNavigationId = Meta.mainFrameNavigations.at(-1)?.args.data?.navigationId;
-  const scores = lastNavigationId && scoresByNav.get(lastNavigationId);
-  if (!scores) {
-    throw new Error('missing metric scores for specified navigation');
-  }
+const throttling = {
+  DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+  DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+  // These values align with WebPageTest's definition of "Fast 3G"
+  // But offer similar characteristics to roughly the 75th percentile of 4G connections.
+  mobileSlow4G: {
+    rttMs: 150,
+    throughputKbps: 1.6 * 1024,
+    requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+    downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+    uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+    cpuSlowdownMultiplier: 4,
+  },
+  // These values partially align with WebPageTest's definition of "Regular 3G".
+  // These values are meant to roughly align with Chrome UX report's 3G definition which are based
+  // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.
+  mobileRegular3G: {
+    rttMs: 300,
+    throughputKbps: 700,
+    requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+    downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+    uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+    cpuSlowdownMultiplier: 4,
+  },
+  // Using a "broadband" connection type
+  // Corresponds to "Dense 4G 25th percentile" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v
+  desktopDense4G: {
+    rttMs: 40,
+    throughputKbps: 10 * 1024,
+    cpuSlowdownMultiplier: 1,
+    requestLatencyMs: 0, // 0 means unset
+    downloadThroughputKbps: 0,
+    uploadThroughputKbps: 0,
+  },
+};
 
-  /** @param {MetricName} metric */
-  const getTimestampOrUndefined = metric => {
-    const metricScore = scores.get(metric);
-    if (!metricScore?.event) return;
-    return metricScore.event.ts;
-  };
-  /** @param {MetricName} metric */
-  const getTimestamp = metric => {
-    const metricScore = scores.get(metric);
-    if (!metricScore?.event) throw new Error(`missing metric: ${metric}`);
-    return metricScore.event.ts;
-  };
-  // TODO: should use `MetricName.LCP`, but it is a const enum.
-  const FCP = /** @type {MetricName} */('FCP');
-  const LCP = /** @type {MetricName} */('LCP');
-  return {
-    timestamps: {
-      firstContentfulPaint: getTimestamp(FCP),
-      largestContentfulPaint: getTimestampOrUndefined(LCP),
-    },
-  };
-}
+const constants = {throttling};
 
 export {
   NetworkRequestTypes,
-  createProcessedNavigation,
+  constants,
 };

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

@@ -3,12 +3,10 @@ export type NetworkNode = import('./network-node.js').NetworkNode;
 export type Simulator = import('./simulator/simulator.js').Simulator;
 export type Extras = {
     optimistic: boolean;
-    fcpResult?: LH.Artifacts.LanternMetric | undefined;
-    lcpResult?: LH.Artifacts.LanternMetric | undefined;
-    interactiveResult?: LH.Artifacts.LanternMetric | undefined;
-    speedline?: {
-        speedIndex: number;
-    } | undefined;
+    fcpResult?: Lantern.Metric | undefined;
+    lcpResult?: Lantern.Metric | undefined;
+    interactiveResult?: Lantern.Metric | undefined;
+    observedSpeedIndex?: number | undefined;
 };
 /** @typedef {import('./base-node.js').Node} Node */
 /** @typedef {import('./network-node.js').NetworkNode} NetworkNode */
@@ -16,10 +14,10 @@ export type Extras = {
 /**
  * @typedef Extras
  * @property {boolean} optimistic
- * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} lcpResult
- * @property {LH.Artifacts.LanternMetric=} interactiveResult
- * @property {{speedIndex: number}=} speedline
+ * @property {Lantern.Metric=} fcpResult
+ * @property {Lantern.Metric=} lcpResult
+ * @property {Lantern.Metric=} interactiveResult
+ * @property {number=} observedSpeedIndex
  */
 export class Metric {
     /**
@@ -63,9 +61,9 @@ export class Metric {
     /**
      * @param {Lantern.Simulation.MetricComputationDataInput} data
      * @param {Omit<Extras, 'optimistic'>=} extras
-     * @return {Promise<LH.Artifacts.LanternMetric>}
+     * @return {Promise<Lantern.Metric>}
      */
-    static compute(data: Lantern.Simulation.MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static compute(data: Lantern.Simulation.MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<Lantern.Metric>;
 }
 import * as Lantern from './types/lantern.js';
 //# sourceMappingURL=metric.d.ts.map

package/core/lib/lantern/metric.js

@@ -5,8 +5,8 @@
  */
 
 import * as Lantern from './types/lantern.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
-import {RESOURCE_TYPES} from '../../lib/network-request.js';
+import {BaseNode} from './base-node.js';
+import {RESOURCE_TYPES} from '../network-request.js';
 
 /** @typedef {import('./base-node.js').Node} Node */
 /** @typedef {import('./network-node.js').NetworkNode} NetworkNode */
@@ -15,10 +15,10 @@ import {RESOURCE_TYPES} from '../../lib/network-request.js';
 /**
  * @typedef Extras
  * @property {boolean} optimistic
- * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} lcpResult
- * @property {LH.Artifacts.LanternMetric=} interactiveResult
- * @property {{speedIndex: number}=} speedline
+ * @property {Lantern.Metric=} fcpResult
+ * @property {Lantern.Metric=} lcpResult
+ * @property {Lantern.Metric=} interactiveResult
+ * @property {number=} observedSpeedIndex
  */
 
 class Metric {
@@ -92,7 +92,7 @@ class Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static async compute(data, extras) {
     const {simulator, graph, processedNavigation} = data;

package/core/lib/lantern/metrics/interactive.d.ts

@@ -11,16 +11,11 @@ export class Interactive extends Metric {
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
     /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @return {number}
      */
-    static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
+    static getLastLongTaskEndTime(nodeTimings: Lantern.Simulation.Result['nodeTimings'], duration?: number): number;
 }
 import { Metric } from '../metric.js';
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=interactive.d.ts.map

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

@@ -16,7 +16,7 @@ const CRITICAL_LONG_TASK_THRESHOLD = 20;
 
 class Interactive extends Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -61,9 +61,9 @@ class Interactive extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {Lantern.Simulation.Result} simulationResult
    * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
     if (!extras.lcpResult) throw new Error('missing lcpResult');
@@ -81,7 +81,7 @@ class Interactive extends Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static async compute(data, extras) {
     const lcpResult = extras?.lcpResult;
@@ -95,7 +95,7 @@ class Interactive extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @return {number}
    */
   static getLastLongTaskEndTime(nodeTimings, duration = 50) {

package/core/lib/lantern/metrics/largest-contentful-paint.d.ts

@@ -10,10 +10,11 @@ export class LargestContentfulPaint extends Metric {
      */
     static isNotLowPriorityImageNode(node: Node): boolean;
     /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @return {LH.Gatherer.Simulation.Result}
+     * @param {Lantern.Simulation.Result} simulationResult
+     * @return {Lantern.Simulation.Result}
      */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result): LH.Gatherer.Simulation.Result;
+    static getEstimateFromSimulation(simulationResult: Lantern.Simulation.Result): Lantern.Simulation.Result;
 }
 import { Metric } from '../metric.js';
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=largest-contentful-paint.d.ts.map

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

@@ -13,7 +13,7 @@ import {LanternError} from '../lantern-error.js';
 
 class LargestContentfulPaint extends Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -74,8 +74,8 @@ class LargestContentfulPaint extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulationResult
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult) {
     const nodeTimesNotOffscreenImages = Array.from(simulationResult.nodeTimings.entries())
@@ -91,7 +91,7 @@ class LargestContentfulPaint extends Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;

package/core/lib/lantern/metrics/max-potential-fid.d.ts

@@ -12,19 +12,14 @@ export class MaxPotentialFID extends Metric {
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
     /**
-     * @param {LH.Gatherer.Simulation.Result} simulation
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} fcpTimeInMs
      * @return {Array<{duration: number}>}
      */
-    static getTimingsAfterFCP(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
+    static getTimingsAfterFCP(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
         duration: number;
     }>;
 }
 import { Metric } from '../metric.js';
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=max-potential-fid.d.ts.map

package/core/lib/lantern/metrics/max-potential-fid.js

@@ -12,7 +12,7 @@ import {BaseNode} from '../base-node.js';
 
 class MaxPotentialFID extends Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -39,9 +39,9 @@ class MaxPotentialFID extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {Lantern.Simulation.Result} simulation
    * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -66,7 +66,7 @@ class MaxPotentialFID extends Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -78,7 +78,7 @@ class MaxPotentialFID extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} fcpTimeInMs
    * @return {Array<{duration: number}>}
    */

package/core/lib/lantern/metrics/speed-index.d.ts

@@ -11,12 +11,6 @@ export class SpeedIndex extends Metric {
      * @return {Node}
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
     /**
      * Approximate speed index using layout events from the simulated node timings.
      * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
@@ -28,11 +22,12 @@ export class SpeedIndex extends Metric {
      * different methods. Read more in the evaluation doc.
      *
      * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} fcpTimeInMs
      * @return {number}
      */
-    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+    static computeLayoutBasedSpeedIndex(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
 }
 import { Metric } from '../metric.js';
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=speed-index.d.ts.map

package/core/lib/lantern/metrics/speed-index.js

@@ -14,7 +14,7 @@ const mobileSlow4GRtt = 150;
 
 class SpeedIndex extends Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -28,7 +28,7 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
     // We want to scale our default coefficients based on the speed of the connection.
@@ -70,17 +70,17 @@ class SpeedIndex extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {Lantern.Simulation.Result} simulationResult
    * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.speedline) throw new Error('missing speedline');
+    if (extras.observedSpeedIndex === undefined) throw new Error('missing observedSpeedIndex');
 
     const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
     const estimate = extras.optimistic
-      ? extras.speedline.speedIndex
+      ? extras.observedSpeedIndex
       : SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
     return {
       timeInMs: estimate,
@@ -91,7 +91,7 @@ class SpeedIndex extends Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -115,7 +115,7 @@ class SpeedIndex extends Metric {
    * different methods. Read more in the evaluation doc.
    *
    * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} fcpTimeInMs
    * @return {number}
    */

package/core/lib/lantern/metrics/total-blocking-time.d.ts

@@ -12,20 +12,15 @@ export class TotalBlockingTime extends Metric {
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
     /**
-     * @param {LH.Gatherer.Simulation.Result} simulation
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} minDurationMs
      */
-    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
+    static getTopLevelEvents(nodeTimings: Lantern.Simulation.Result['nodeTimings'], minDurationMs: number): {
         start: number;
         end: number;
         duration: number;
     }[];
 }
 import { Metric } from '../metric.js';
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=total-blocking-time.d.ts.map

package/core/lib/lantern/metrics/total-blocking-time.js

@@ -7,13 +7,13 @@
 import * as Lantern from '../types/lantern.js';
 import {Metric} from '../metric.js';
 import {BaseNode} from '../base-node.js';
-import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../../../computed/metrics/tbt-utils.js';
+import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../tbt-utils.js';
 
 /** @typedef {import('../base-node.js').Node} Node */
 
 class TotalBlockingTime extends Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -40,9 +40,9 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {Lantern.Simulation.Result} simulation
    * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -84,7 +84,7 @@ class TotalBlockingTime extends Metric {
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
    * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<Lantern.Metric>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -101,7 +101,7 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} minDurationMs
    */
   static getTopLevelEvents(nodeTimings, minDurationMs) {

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

@@ -1,5 +1,4 @@
 export type Node = import('./base-node.js').Node;
-export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
 export type NetworkNodeOutput = {
     nodes: Array<NetworkNode>;
     idToNodeMap: Map<string, NetworkNode>;
@@ -18,10 +17,22 @@ export class PageDependencyGraph {
      */
     static getNetworkNodeOutput(networkRequests: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
     /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {Lantern.TraceEvent} evt
+     * @return {boolean}
+     */
+    static isScheduleableTask(evt: Lantern.TraceEvent): boolean;
+    /**
+     * There should *always* be at least one top level event, having 0 typically means something is
+     * drastically wrong with the trace and we should just give up early and loudly.
+     *
+     * @param {Lantern.TraceEvent[]} events
+     */
+    static assertHasToplevelEvents(events: Lantern.TraceEvent[]): void;
+    /**
+     * @param {Lantern.TraceEvent[]} mainThreadEvents
      * @return {Array<CPUNode>}
      */
-    static getCPUNodes(mainThreadEvents: LH.TraceEvent[]): Array<CPUNode>;
+    static getCPUNodes(mainThreadEvents: Lantern.TraceEvent[]): Array<CPUNode>;
     /**
      * @param {NetworkNode} rootNode
      * @param {NetworkNodeOutput} networkNodeOutput
@@ -54,56 +65,13 @@ export class PageDependencyGraph {
      */
     static _debugNormalizeRequests(lanternRequests: Lantern.NetworkRequest[]): never;
     /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {Lantern.TraceEvent[]} mainThreadEvents
      * @param {Lantern.NetworkRequest[]} networkRequests
-     * @param {URLArtifact} URL
+     * @param {Lantern.Simulation.URL} URL
      * @return {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;
+    static createGraph(mainThreadEvents: Lantern.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: Lantern.Simulation.URL): Node;
     /**
-     * @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
      */
     static printGraph(rootNode: Node, widthInCharacters?: number): void;