lighthouse 12.0.0-dev.20240610 → 12.0.0-dev.20240611

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,9 +70,9 @@ 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');
@@ -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

@@ -13,7 +13,7 @@ import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../tbt-utils.
 
 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,12 +65,12 @@ 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;
+    static createGraph(mainThreadEvents: Lantern.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: Lantern.Simulation.URL): Node;
     /**
      * @param {Node} rootNode
      */

package/core/lib/lantern/page-dependency-graph.js

@@ -8,11 +8,18 @@ import * as Lantern from './types/lantern.js';
 import {NetworkRequestTypes} from './lantern.js';
 import {NetworkNode} from './network-node.js';
 import {CPUNode} from './cpu-node.js';
-import {TraceProcessor} from '../tracehouse/trace-processor.js';
 import {NetworkAnalyzer} from './simulator/network-analyzer.js';
 
+// COMPAT: m71+ We added RunTask to `disabled-by-default-lighthouse`
+const SCHEDULABLE_TASK_TITLE_LH = 'RunTask';
+// m69-70 DoWork is different and we now need RunTask, see https://bugs.chromium.org/p/chromium/issues/detail?id=871204#c11
+const SCHEDULABLE_TASK_TITLE_ALT1 = 'ThreadControllerImpl::RunTask';
+// In m66-68 refactored to this task title, https://crrev.com/c/883346
+const SCHEDULABLE_TASK_TITLE_ALT2 = 'ThreadControllerImpl::DoWork';
+// m65 and earlier
+const SCHEDULABLE_TASK_TITLE_ALT3 = 'TaskQueueManager::ProcessTaskFromWorkQueue';
+
 /** @typedef {import('./base-node.js').Node} Node */
-/** @typedef {Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>} URLArtifact */
 
 /**
  * @typedef {Object} NetworkNodeOutput
@@ -109,7 +116,31 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.TraceEvent[]} mainThreadEvents
+   * @param {Lantern.TraceEvent} evt
+   * @return {boolean}
+   */
+  static isScheduleableTask(evt) {
+    return evt.name === SCHEDULABLE_TASK_TITLE_LH ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT1 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT2 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT3;
+  }
+
+  /**
+   * 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) {
+    const hasToplevelTask = events.some(this.isScheduleableTask);
+    if (!hasToplevelTask) {
+      throw new Error('Could not find any top level events');
+    }
+  }
+
+  /**
+   * @param {Lantern.TraceEvent[]} mainThreadEvents
    * @return {Array<CPUNode>}
    */
   static getCPUNodes(mainThreadEvents) {
@@ -117,14 +148,14 @@ class PageDependencyGraph {
     const nodes = [];
     let i = 0;
 
-    TraceProcessor.assertHasToplevelEvents(mainThreadEvents);
+    PageDependencyGraph.assertHasToplevelEvents(mainThreadEvents);
 
     while (i < mainThreadEvents.length) {
       const evt = mainThreadEvents[i];
       i++;
 
       // Skip all trace events that aren't schedulable tasks with sizable duration
-      if (!TraceProcessor.isScheduleableTask(evt) || !evt.dur) {
+      if (!PageDependencyGraph.isScheduleableTask(evt) || !evt.dur) {
         continue;
       }
 
@@ -132,23 +163,25 @@ class PageDependencyGraph {
       let correctedEndTs = undefined;
 
       // Capture all events that occurred within the task
-      /** @type {Array<LH.TraceEvent>} */
+      /** @type {Array<Lantern.TraceEvent>} */
       const children = [];
       for (
         const endTime = evt.ts + evt.dur;
         i < mainThreadEvents.length && mainThreadEvents[i].ts < endTime;
         i++
       ) {
+        const event = mainThreadEvents[i];
+
         // Temporary fix for a Chrome bug where some RunTask events can be overlapping.
         // We correct that here be ensuring each RunTask ends at least 1 microsecond before the next
         // https://github.com/GoogleChrome/lighthouse/issues/15896
         // https://issues.chromium.org/issues/329678173
-        if (TraceProcessor.isScheduleableTask(mainThreadEvents[i]) && mainThreadEvents[i].dur) {
-          correctedEndTs = mainThreadEvents[i].ts - 1;
+        if (PageDependencyGraph.isScheduleableTask(event) && event.dur) {
+          correctedEndTs = event.ts - 1;
           break;
         }
 
-        children.push(mainThreadEvents[i]);
+        children.push(event);
       }
 
       nodes.push(new CPUNode(evt, children, correctedEndTs));
@@ -210,7 +243,7 @@ class PageDependencyGraph {
    * @param {Array<CPUNode>} cpuNodes
    */
   static linkCPUNodes(rootNode, networkNodeOutput, cpuNodes) {
-    /** @type {Set<LH.Crdp.Network.ResourceType|undefined>} */
+    /** @type {Set<Lantern.ResourceType|undefined>} */
     const linkableResourceTypes = new Set([
       NetworkRequestTypes.XHR, NetworkRequestTypes.Fetch, NetworkRequestTypes.Script,
     ]);
@@ -506,9 +539,9 @@ class PageDependencyGraph {
   }
 
   /**
-   * @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, networkRequests, URL) {

package/core/lib/lantern/simulator/network-analyzer.d.ts

@@ -46,7 +46,7 @@ export class NetworkAnalyzer {
      * @return {Map<string, Summary>}
      */
     static summarize(values: Map<string, number[]>): Map<string, Summary>;
-    /** @typedef {{request: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /** @typedef {{request: Lantern.NetworkRequest, timing: Lantern.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
      * @param {Lantern.NetworkRequest[]} requests
      * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
@@ -54,7 +54,7 @@ export class NetworkAnalyzer {
      */
     static _estimateValueByOrigin(requests: Lantern.NetworkRequest[], iteratee: (e: {
         request: Lantern.NetworkRequest;
-        timing: LH.Crdp.Network.ResourceTiming;
+        timing: Lantern.ResourceTiming;
         connectionReused?: boolean | undefined;
     }) => number | number[] | undefined): Map<string, number[]>;
     /**
@@ -70,7 +70,7 @@ export class NetworkAnalyzer {
      */
     static _estimateRTTViaConnectionTiming(info: {
         request: Lantern.NetworkRequest;
-        timing: LH.Crdp.Network.ResourceTiming;
+        timing: Lantern.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number[] | number | undefined;
     /**
@@ -83,7 +83,7 @@ export class NetworkAnalyzer {
      */
     static _estimateRTTViaDownloadTiming(info: {
         request: Lantern.NetworkRequest;
-        timing: LH.Crdp.Network.ResourceTiming;
+        timing: Lantern.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**
@@ -97,7 +97,7 @@ export class NetworkAnalyzer {
      */
     static _estimateRTTViaSendStartTiming(info: {
         request: Lantern.NetworkRequest;
-        timing: LH.Crdp.Network.ResourceTiming;
+        timing: Lantern.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**
@@ -111,7 +111,7 @@ export class NetworkAnalyzer {
      */
     static _estimateRTTViaHeadersEndTiming(info: {
         request: Lantern.NetworkRequest;
-        timing: LH.Crdp.Network.ResourceTiming;
+        timing: Lantern.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**

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

@@ -15,7 +15,7 @@ const DEFAULT_SERVER_RESPONSE_PERCENTAGE = 0.4;
 /**
  * For certain resource types, server response time takes up a greater percentage of TTFB (dynamic
  * assets like HTML documents, XHR/API calls, etc)
- * @type {Partial<Record<LH.Crdp.Network.ResourceType, number>>}
+ * @type {Partial<Record<Lantern.ResourceType, number>>}
  */
 const SERVER_RESPONSE_PERCENTAGE_OF_TTFB = {
   Document: 0.9,
@@ -88,7 +88,7 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{request: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{request: Lantern.NetworkRequest, timing: Lantern.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
    * @param {Lantern.NetworkRequest[]} requests

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

@@ -10,9 +10,9 @@ import {TcpConnection} from './tcp-connection.js';
 import {ConnectionPool} from './connection-pool.js';
 import {DNSCache} from './dns-cache.js';
 import {SimulatorTimingMap} from './simulator-timing-map.js';
-import * as constants from '../../../config/constants.js';
+import {constants} from '../lantern.js';
 
-const mobileSlow4G = constants.throttling.mobileSlow4G;
+const defaultThrottling = constants.throttling.mobileSlow4G;
 
 /** @typedef {import('../base-node.js').Node} Node */
 /** @typedef {import('../network-node.js').NetworkNode} NetworkNode */
@@ -113,10 +113,10 @@ class Simulator {
     /** @type {Required<Lantern.Simulation.Options>} */
     this._options = Object.assign(
       {
-        rtt: mobileSlow4G.rttMs,
-        throughput: mobileSlow4G.throughputKbps * 1024,
+        rtt: defaultThrottling.rttMs,
+        throughput: defaultThrottling.throughputKbps * 1024,
         maximumConcurrentRequests: DEFAULT_MAXIMUM_CONCURRENT_REQUESTS,
-        cpuSlowdownMultiplier: mobileSlow4G.cpuSlowdownMultiplier,
+        cpuSlowdownMultiplier: defaultThrottling.cpuSlowdownMultiplier,
         layoutTaskMultiplier: DEFAULT_LAYOUT_TASK_MULTIPLIER,
         additionalRttByOrigin: new Map(),
         serverResponseTimeByOrigin: new Map(),
@@ -533,7 +533,7 @@ class Simulator {
       const minimumTime = this._findNextNodeCompletionTime();
       totalElapsedTime += minimumTime;
 
-      // While this is no longer strictly necessary, it's always better than LH hanging
+      // While this is no longer strictly necessary, it's always better than hanging
       if (!Number.isFinite(minimumTime) || iteration > 100000) {
         throw new Error('Simulation failed, depth exceeded');
       }

package/core/lib/lantern/trace-engine-computation-data.d.ts

@@ -8,18 +8,18 @@ export type MetricScore = import('@paulirish/trace_engine/models/trace/handlers/
  */
 export function createProcessedNavigation(traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.Simulation.ProcessedNavigation;
 /**
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
  * @return {Lantern.NetworkRequest[]}
  */
-export function createNetworkRequests(trace: LH.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.NetworkRequest[];
+export function createNetworkRequests(trace: Lantern.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.NetworkRequest[];
 /**
  * @param {Lantern.NetworkRequest[]} requests
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @param {LH.Artifacts.URL=} URL
+ * @param {Lantern.Simulation.URL=} URL
  */
-export function createGraph(requests: Lantern.NetworkRequest[], trace: LH.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData, URL?: LH.Artifacts.URL | undefined): import("./page-dependency-graph.js").Node;
+export function createGraph(requests: Lantern.NetworkRequest[], trace: Lantern.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData, URL?: Lantern.Simulation.URL | undefined): import("./page-dependency-graph.js").Node;
 import * as TraceEngine from '@paulirish/trace_engine';
 import * as Lantern from './types/lantern.js';
 //# sourceMappingURL=trace-engine-computation-data.d.ts.map

package/core/lib/lantern/trace-engine-computation-data.js

@@ -5,6 +5,7 @@
  */
 
 import * as TraceEngine from '@paulirish/trace_engine';
+import * as Protocol from '@paulirish/trace_engine/generated/protocol.js';
 
 import * as Lantern from './types/lantern.js';
 import {PageDependencyGraph} from './page-dependency-graph.js';
@@ -71,7 +72,7 @@ function createParsedUrl(url) {
 
 /**
  * Returns a map of `pid` -> `tid[]`.
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @return {Map<number, number[]>}
  */
 function findWorkerThreads(trace) {
@@ -140,6 +141,9 @@ function createLanternRequest(traceEngineData, workerThreads, request) {
     fromWorker = true;
   }
 
+  // typescript const enums.... gotta stop using those ...
+  const Other = /** @type {Protocol.Network.InitiatorType.Other} */ ('other');
+
   // `initiator` in the trace does not contain the stack trace for JS-initiated
   // requests. Instead, that is stored in the `stackTrace` property of the SyntheticNetworkRequest.
   // There are some minor differences in the fields, accounted for here.
@@ -148,11 +152,11 @@ function createLanternRequest(traceEngineData, workerThreads, request) {
   // which means less edges in the graph, which mean worse results.
   // TODO: Should fix in Chromium.
   /** @type {Lantern.NetworkRequest['initiator']} */
-  const initiator = request.args.data.initiator ?? {type: 'other'};
+  const initiator = request.args.data.initiator ?? {type: Other};
   if (request.args.data.stackTrace) {
     const callFrames = request.args.data.stackTrace.map(f => {
       return {
-        scriptId: String(f.scriptId),
+        scriptId: /** @type {Protocol.Runtime.ScriptId} */(String(f.scriptId)),
         url: f.url,
         lineNumber: f.lineNumber - 1,
         columnNumber: f.columnNumber - 1,
@@ -160,6 +164,7 @@ function createLanternRequest(traceEngineData, workerThreads, request) {
       };
     });
     initiator.stack = {callFrames};
+    // Note: there is no `parent` to set ...
   }
 
   let resourceType = request.args.data.resourceType;
@@ -296,7 +301,7 @@ function linkInitiators(lanternRequests) {
 }
 
 /**
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
  * @return {Lantern.NetworkRequest[]}
  */
@@ -390,9 +395,9 @@ function createNetworkRequests(trace, traceEngineData) {
 }
 
 /**
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @return {LH.TraceEvent[]}
+ * @return {Lantern.TraceEvent[]}
  */
 function collectMainThreadEvents(trace, traceEngineData) {
   const Meta = traceEngineData.Meta;
@@ -431,9 +436,9 @@ function collectMainThreadEvents(trace, traceEngineData) {
 
 /**
  * @param {Lantern.NetworkRequest[]} requests
- * @param {LH.Trace} trace
+ * @param {Lantern.Trace} trace
  * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @param {LH.Artifacts.URL=} URL
+ * @param {Lantern.Simulation.URL=} URL
  */
 function createGraph(requests, trace, traceEngineData, URL) {
   const mainThreadEvents = collectMainThreadEvents(trace, traceEngineData);
@@ -444,7 +449,6 @@ function createGraph(requests, trace, traceEngineData, URL) {
     URL = {
       requestedUrl: requests[0].url,
       mainDocumentUrl: '',
-      finalDisplayedUrl: '',
     };
 
     let request = requests[0];