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

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

@@ -8,12 +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';
-import {RESOURCE_TYPES} from '../network-request.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
@@ -110,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) {
@@ -118,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;
       }
 
@@ -133,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));
@@ -211,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,
     ]);
@@ -507,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) {
@@ -543,347 +575,6 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {Lantern.NetworkRequest} request The request to find the initiator of
-   * @param {Map<string, Lantern.NetworkRequest[]>} requestsByURL
-   * @return {Lantern.NetworkRequest|null}
-   */
-  static chooseInitiatorRequest(request, requestsByURL) {
-    if (request.redirectSource) {
-      return request.redirectSource;
-    }
-
-    const initiatorURL = PageDependencyGraph.getNetworkInitiators(request)[0];
-    let candidates = requestsByURL.get(initiatorURL) || [];
-    // The (valid) initiator must come before the initiated request.
-    candidates = candidates.filter(c => {
-      return c.responseHeadersEndTime <= request.rendererStartTime &&
-          c.finished && !c.failed;
-    });
-    if (candidates.length > 1) {
-      // Disambiguate based on prefetch. Prefetch requests have type 'Other' and cannot
-      // initiate requests, so we drop them here.
-      const nonPrefetchCandidates = candidates.filter(
-          cand => cand.resourceType !== RESOURCE_TYPES.Other);
-      if (nonPrefetchCandidates.length) {
-        candidates = nonPrefetchCandidates;
-      }
-    }
-    if (candidates.length > 1) {
-      // Disambiguate based on frame. It's likely that the initiator comes from the same frame.
-      const sameFrameCandidates = candidates.filter(cand => cand.frameId === request.frameId);
-      if (sameFrameCandidates.length) {
-        candidates = sameFrameCandidates;
-      }
-    }
-    if (candidates.length > 1 && request.initiator.type === 'parser') {
-      // Filter to just Documents when initiator type is parser.
-      const documentCandidates = candidates.filter(cand =>
-        cand.resourceType === RESOURCE_TYPES.Document);
-      if (documentCandidates.length) {
-        candidates = documentCandidates;
-      }
-    }
-    if (candidates.length > 1) {
-      // If all real loads came from successful preloads (url preloaded and
-      // loads came from the cache), filter to link rel=preload request(s).
-      const linkPreloadCandidates = candidates.filter(c => c.isLinkPreload);
-      if (linkPreloadCandidates.length) {
-        const nonPreloadCandidates = candidates.filter(c => !c.isLinkPreload);
-        const allPreloaded = nonPreloadCandidates.every(c => c.fromDiskCache || c.fromMemoryCache);
-        if (nonPreloadCandidates.length && allPreloaded) {
-          candidates = linkPreloadCandidates;
-        }
-      }
-    }
-
-    // Only return an initiator if the result is unambiguous.
-    return candidates.length === 1 ? candidates[0] : null;
-  }
-
-  /**
-   * Returns a map of `pid` -> `tid[]`.
-   * @param {LH.Trace} trace
-   * @return {Map<number, number[]>}
-   */
-  static _findWorkerThreads(trace) {
-    // TODO: WorkersHandler in TraceEngine needs to be updated to also include `pid` (only had `tid`).
-    const workerThreads = new Map();
-    const workerCreationEvents = ['ServiceWorker thread', 'DedicatedWorker thread'];
-
-    for (const event of trace.traceEvents) {
-      if (event.name !== 'thread_name' || !event.args.name) {
-        continue;
-      }
-      if (!workerCreationEvents.includes(event.args.name)) {
-        continue;
-      }
-
-      const tids = workerThreads.get(event.pid);
-      if (tids) {
-        tids.push(event.tid);
-      } else {
-        workerThreads.set(event.pid, [event.tid]);
-      }
-    }
-
-    return workerThreads;
-  }
-
-  /**
-   * @param {URL|string} url
-   */
-  static _createParsedUrl(url) {
-    if (typeof url === 'string') {
-      url = new URL(url);
-    }
-    return {
-      scheme: url.protocol.split(':')[0],
-      // Intentional, DevTools uses different terminology
-      host: url.hostname,
-      securityOrigin: url.origin,
-    };
-  }
-
-  /**
-   * @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, workerThreads, request) {
-    if (request.args.data.connectionId === undefined ||
-        request.args.data.connectionReused === undefined) {
-      throw new Error('Trace is too old');
-    }
-
-    let url;
-    try {
-      url = new URL(request.args.data.url);
-    } catch (e) {
-      return;
-    }
-
-    const timing = request.args.data.timing ? {
-      // These two timings are not included in the trace.
-      workerFetchStart: -1,
-      workerRespondWithSettled: -1,
-      ...request.args.data.timing,
-    } : undefined;
-
-    const networkRequestTime = timing ?
-      timing.requestTime * 1000 :
-      request.args.data.syntheticData.downloadStart / 1000;
-
-    let fromWorker = false;
-    const tids = workerThreads.get(request.pid);
-    if (tids?.includes(request.tid)) {
-      fromWorker = true;
-    }
-
-    // TraceEngine collects worker thread ids in a different manner than `workerThreads` does.
-    // AFAIK these should be equivalent, but in case they are not let's also check this for now.
-    if (traceEngineResult.data.Workers.workerIdByThread.has(request.tid)) {
-      fromWorker = true;
-    }
-
-    // `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.
-    // Most importantly, there seems to be fewer frames in the trace than the equivalent
-    // events over the CDP. This results in less accuracy in determining the initiator 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'};
-    if (request.args.data.stackTrace) {
-      const callFrames = request.args.data.stackTrace.map(f => {
-        return {
-          scriptId: String(f.scriptId),
-          url: f.url,
-          lineNumber: f.lineNumber - 1,
-          columnNumber: f.columnNumber - 1,
-          functionName: f.functionName,
-        };
-      });
-      initiator.stack = {callFrames};
-    }
-
-    let resourceType = request.args.data.resourceType;
-    if (request.args.data.initiator?.fetchType === 'xmlhttprequest') {
-      // @ts-expect-error yes XHR is a valid ResourceType. TypeScript const enums are so unhelpful.
-      resourceType = 'XHR';
-    } else if (request.args.data.initiator?.fetchType === 'fetch') {
-      // @ts-expect-error yes Fetch is a valid ResourceType. TypeScript const enums are so unhelpful.
-      resourceType = 'Fetch';
-    }
-
-    // TODO: set decodedBodyLength for data urls in Trace Engine.
-    let resourceSize = request.args.data.decodedBodyLength ?? 0;
-    if (url.protocol === 'data:' && resourceSize === 0) {
-      const needle = 'base64,';
-      const index = url.pathname.indexOf(needle);
-      if (index !== -1) {
-        resourceSize = atob(url.pathname.substring(index + needle.length)).length;
-      }
-    }
-
-    return {
-      rawRequest: request,
-      requestId: request.args.data.requestId,
-      connectionId: request.args.data.connectionId,
-      connectionReused: request.args.data.connectionReused,
-      url: request.args.data.url,
-      protocol: request.args.data.protocol,
-      parsedURL: this._createParsedUrl(url),
-      documentURL: request.args.data.requestingFrameUrl,
-      rendererStartTime: request.ts / 1000,
-      networkRequestTime,
-      responseHeadersEndTime: request.args.data.syntheticData.downloadStart / 1000,
-      networkEndTime: request.args.data.syntheticData.finishTime / 1000,
-      transferSize: request.args.data.encodedDataLength,
-      resourceSize,
-      fromDiskCache: request.args.data.syntheticData.isDiskCached,
-      fromMemoryCache: request.args.data.syntheticData.isMemoryCached,
-      isLinkPreload: request.args.data.isLinkPreload,
-      finished: request.args.data.finished,
-      failed: request.args.data.failed,
-      statusCode: request.args.data.statusCode,
-      initiator,
-      timing,
-      resourceType,
-      mimeType: request.args.data.mimeType,
-      priority: request.args.data.priority,
-      frameId: request.args.data.frame,
-      fromWorker,
-      // Set later.
-      redirects: undefined,
-      redirectSource: undefined,
-      redirectDestination: undefined,
-      initiatorRequest: undefined,
-    };
-  }
-
-  /**
-   *
-   * @param {Lantern.NetworkRequest[]} lanternRequests
-   */
-  static _linkInitiators(lanternRequests) {
-    /** @type {Map<string, Lantern.NetworkRequest[]>} */
-    const requestsByURL = new Map();
-    for (const request of lanternRequests) {
-      const requests = requestsByURL.get(request.url) || [];
-      requests.push(request);
-      requestsByURL.set(request.url, requests);
-    }
-
-    for (const request of lanternRequests) {
-      const initiatorRequest = PageDependencyGraph.chooseInitiatorRequest(request, requestsByURL);
-      if (initiatorRequest) {
-        request.initiatorRequest = initiatorRequest;
-      }
-    }
-  }
-
-  /**
-   * @param {LH.TraceEvent[]} mainThreadEvents
-   * @param {LH.Trace} trace
-   * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
-   * @param {LH.Artifacts.URL} URL
-   */
-  static async createGraphFromTrace(mainThreadEvents, trace, traceEngineResult, URL) {
-    const workerThreads = this._findWorkerThreads(trace);
-
-    /** @type {Lantern.NetworkRequest[]} */
-    const lanternRequests = [];
-    for (const request of traceEngineResult.data.NetworkRequests.byTime) {
-      const lanternRequest = this._createLanternRequest(traceEngineResult, workerThreads, request);
-      if (lanternRequest) {
-        lanternRequests.push(lanternRequest);
-      }
-    }
-
-    // TraceEngine consolidates all redirects into a single request object, but lantern needs
-    // an entry for each redirected request.
-    for (const request of [...lanternRequests]) {
-      if (!request.rawRequest) continue;
-
-      const redirects = request.rawRequest.args.data.redirects;
-      if (!redirects.length) continue;
-
-      const requestChain = [];
-      for (const redirect of redirects) {
-        const redirectedRequest = structuredClone(request);
-
-        redirectedRequest.networkRequestTime = redirect.ts / 1000;
-        redirectedRequest.rendererStartTime = redirectedRequest.networkRequestTime;
-
-        redirectedRequest.networkEndTime = (redirect.ts + redirect.dur) / 1000;
-        redirectedRequest.responseHeadersEndTime = redirectedRequest.networkEndTime;
-
-        redirectedRequest.timing = {
-          requestTime: redirectedRequest.networkRequestTime / 1000,
-          receiveHeadersStart: redirectedRequest.responseHeadersEndTime,
-          receiveHeadersEnd: redirectedRequest.responseHeadersEndTime,
-          proxyStart: -1,
-          proxyEnd: -1,
-          dnsStart: -1,
-          dnsEnd: -1,
-          connectStart: -1,
-          connectEnd: -1,
-          sslStart: -1,
-          sslEnd: -1,
-          sendStart: -1,
-          sendEnd: -1,
-          workerStart: -1,
-          workerReady: -1,
-          workerFetchStart: -1,
-          workerRespondWithSettled: -1,
-          pushStart: -1,
-          pushEnd: -1,
-        };
-
-        redirectedRequest.url = redirect.url;
-        redirectedRequest.parsedURL = this._createParsedUrl(redirect.url);
-        // TODO: TraceEngine is not retaining the actual status code.
-        redirectedRequest.statusCode = 302;
-        redirectedRequest.resourceType = undefined;
-        // TODO: TraceEngine is not retaining transfer size of redirected request.
-        redirectedRequest.transferSize = 400;
-        requestChain.push(redirectedRequest);
-        lanternRequests.push(redirectedRequest);
-      }
-      requestChain.push(request);
-
-      for (let i = 0; i < requestChain.length; i++) {
-        const request = requestChain[i];
-        if (i > 0) {
-          request.redirectSource = requestChain[i - 1];
-          request.redirects = requestChain.slice(0, i);
-        }
-        if (i !== requestChain.length - 1) {
-          request.redirectDestination = requestChain[i + 1];
-        }
-      }
-
-      // Apply the `:redirect` requestId convention: only redirects[0].requestId is the actual
-      // requestId, all the rest have n occurences of `:redirect` as a suffix.
-      for (let i = 1; i < requestChain.length; i++) {
-        requestChain[i].requestId = `${requestChain[i - 1].requestId}:redirect`;
-      }
-    }
-
-    this._linkInitiators(lanternRequests);
-
-    // This would already be sorted by rendererStartTime, if not for the redirect unwrapping done
-    // above.
-    lanternRequests.sort((a, b) => a.rendererStartTime - b.rendererStartTime);
-
-    const graph = PageDependencyGraph.createGraph(mainThreadEvents, lanternRequests, URL);
-    return {graph, records: lanternRequests};
-  }
-
-  /**
-   *
    * @param {Node} rootNode
    */
   static printGraph(rootNode, widthInCharacters = 100) {

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

@@ -0,0 +1,25 @@
+export type MetricName = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName;
+export type MetricScore = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore;
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName} MetricName */
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore} MetricScore */
+/**
+ * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
+ * @return {Lantern.Simulation.ProcessedNavigation}
+ */
+export function createProcessedNavigation(traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.Simulation.ProcessedNavigation;
+/**
+ * @param {Lantern.Trace} trace
+ * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
+ * @return {Lantern.NetworkRequest[]}
+ */
+export function createNetworkRequests(trace: Lantern.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.NetworkRequest[];
+/**
+ * @param {Lantern.NetworkRequest[]} requests
+ * @param {Lantern.Trace} trace
+ * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
+ * @param {Lantern.Simulation.URL=} URL
+ */
+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