lighthouse 11.6.0-dev.20240304 → 11.6.0-dev.20240305

package/core/audits/prioritize-lcp-image.d.ts

@@ -39,7 +39,7 @@ declare class PrioritizeLcpImage extends Audit {
      * @return {{lcpNodeToPreload?: LH.Gatherer.Simulation.GraphNetworkNode, initiatorPath?: InitiatorPath}}
      */
     static getLCPNodeToPreload(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode, lcpRecord: NetworkRequest | undefined): {
-        lcpNodeToPreload?: import("../../types/gatherer.js").default.Simulation.GraphNetworkNode | undefined;
+        lcpNodeToPreload?: import("../lib/lantern/network-node.js").NetworkNode<NetworkRequest> | undefined;
         initiatorPath?: InitiatorPath | undefined;
     };
     /**

package/core/computed/load-simulator.d.ts

@@ -1,12 +1,14 @@
 export { LoadSimulatorComputed as LoadSimulator };
+export type SimulationOptions = import('../../types/internal/lantern.js').Lantern.Simulation.Options;
 declare const LoadSimulatorComputed: typeof LoadSimulator & {
     request: (dependencies: {
         devtoolsLog: import("../index.js").DevtoolsLog;
         settings: LH.Audit.Context['settings'];
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<Simulator>;
+    }>) => Promise<Simulator<any>>;
 };
+/** @typedef {import('../../types/internal/lantern.js').Lantern.Simulation.Options} SimulationOptions */
 declare class LoadSimulator {
     /**
      * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data

package/core/computed/load-simulator.js

@@ -9,6 +9,8 @@ import * as constants from '../config/constants.js';
 import {Simulator} from '../lib/lantern/simulator/simulator.js';
 import {NetworkAnalysis} from './network-analysis.js';
 
+/** @typedef {import('../../types/internal/lantern.js').Lantern.Simulation.Options} SimulationOptions */
+
 class LoadSimulator {
   /**
    * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
@@ -19,7 +21,7 @@ class LoadSimulator {
     const {throttlingMethod, throttling, precomputedLanternData} = data.settings;
     const networkAnalysis = await NetworkAnalysis.request(data.devtoolsLog, context);
 
-    /** @type {LH.Gatherer.Simulation.Options} */
+    /** @type {SimulationOptions} */
     const options = {
       additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
       serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,

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

@@ -31,7 +31,7 @@ export class LanternMetric {
     /**
      * @return {LH.Gatherer.Simulation.MetricCoefficients}
      */
-    static get COEFFICIENTS(): import("../../../types/gatherer.js").default.Simulation.MetricCoefficients;
+    static get COEFFICIENTS(): import("../../../types/internal/lantern.js").Lantern.Simulation.MetricCoefficients;
     /**
      * Returns the coefficients, scaled by the throttling settings if needed by the metric.
      * Some lantern metrics (speed-index) use components in their estimate that are not

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

@@ -1,12 +1,5 @@
 export { PageDependencyGraphComputed as PageDependencyGraph };
 export type Node = import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
-export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
-export type NetworkNodeOutput = {
-    nodes: Array<NetworkNode<LH.Artifacts.NetworkRequest>>;
-    idToNodeMap: Map<string, NetworkNode<LH.Artifacts.NetworkRequest>>;
-    urlToNodeMap: Map<string, Array<NetworkNode<LH.Artifacts.NetworkRequest>>>;
-    frameIdToNodeMap: Map<string, NetworkNode<LH.Artifacts.NetworkRequest> | null>;
-};
 declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     request: (dependencies: {
         trace: LH.Trace;
@@ -17,52 +10,8 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     }>) => Promise<Node>;
 };
 import { NetworkRequest } from '../lib/network-request.js';
-import { NetworkNode } from '../lib/lantern/network-node.js';
+/** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 declare class PageDependencyGraph {
-    /**
-     * @param {LH.Artifacts.NetworkRequest} record
-     * @return {Array<string>}
-     */
-    static getNetworkInitiators(record: LH.Artifacts.NetworkRequest): Array<string>;
-    /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @return {NetworkNodeOutput}
-     */
-    static getNetworkNodeOutput(networkRecords: Array<LH.Artifacts.NetworkRequest>): NetworkNodeOutput;
-    /**
-     * @param {LH.Artifacts.ProcessedTrace} processedTrace
-     * @return {Array<CPUNode>}
-     */
-    static getCPUNodes({ mainThreadEvents }: LH.Artifacts.ProcessedTrace): Array<CPUNode>;
-    /**
-     * @param {NetworkNode} rootNode
-     * @param {NetworkNodeOutput} networkNodeOutput
-     */
-    static linkNetworkNodes(rootNode: NetworkNode, networkNodeOutput: NetworkNodeOutput): void;
-    /**
-     * @param {Node} rootNode
-     * @param {NetworkNodeOutput} networkNodeOutput
-     * @param {Array<CPUNode>} cpuNodes
-     */
-    static linkCPUNodes(rootNode: Node, networkNodeOutput: NetworkNodeOutput, cpuNodes: Array<CPUNode>): void;
-    /**
-     * Removes the given node from the graph, but retains all paths between its dependencies and
-     * dependents.
-     * @param {Node} node
-     */
-    static _pruneNode(node: Node): void;
-    /**
-     * @param {LH.Artifacts.ProcessedTrace} processedTrace
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @param {URLArtifact} URL
-     * @return {Node}
-     */
-    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<LH.Artifacts.NetworkRequest>, URL: URLArtifact): Node;
-    /**
-     *
-     * @param {Node} rootNode
-     */
-    static printGraph(rootNode: Node, widthInCharacters?: number): void;
     /**
      * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -74,6 +23,4 @@ declare class PageDependencyGraph {
         URL: LH.Artifacts['URL'];
     }, context: LH.Artifacts.ComputedContext): Promise<Node>;
 }
-import { ProcessedTrace } from './processed-trace.js';
-import { CPUNode } from '../lib/lantern/cpu-node.js';
 //# sourceMappingURL=page-dependency-graph.d.ts.map

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

@@ -5,463 +5,15 @@
  */
 
 import {makeComputedArtifact} from './computed-artifact.js';
-import {NetworkNode} from '../lib/lantern/network-node.js';
-import {CPUNode} from '../lib/lantern/cpu-node.js';
-import {TraceProcessor} from '../lib/tracehouse/trace-processor.js';
+import {PageDependencyGraph as LanternPageDependencyGraph} from '../lib/lantern/page-dependency-graph.js';
 import {NetworkRequest} from '../lib/network-request.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
-import {NetworkAnalyzer} from '../lib/lantern/simulator/network-analyzer.js';
 import {DocumentUrls} from './document-urls.js';
 
 /** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-/** @typedef {Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>} URLArtifact */
-
-/**
- * @typedef {Object} NetworkNodeOutput
- * @property {Array<NetworkNode<LH.Artifacts.NetworkRequest>>} nodes
- * @property {Map<string, NetworkNode<LH.Artifacts.NetworkRequest>>} idToNodeMap
- * @property {Map<string, Array<NetworkNode<LH.Artifacts.NetworkRequest>>>} urlToNodeMap
- * @property {Map<string, NetworkNode<LH.Artifacts.NetworkRequest>|null>} frameIdToNodeMap
- */
-
-// Shorter tasks have negligible impact on simulation results.
-const SIGNIFICANT_DUR_THRESHOLD_MS = 10;
-
-// TODO: video files tend to be enormous and throw off all graph traversals, move this ignore
-//    into estimation logic when we use the dependency graph for other purposes.
-const IGNORED_MIME_TYPES_REGEX = /^video/;
 
 class PageDependencyGraph {
-  /**
-   * @param {LH.Artifacts.NetworkRequest} record
-   * @return {Array<string>}
-   */
-  static getNetworkInitiators(record) {
-    if (!record.initiator) return [];
-    if (record.initiator.url) return [record.initiator.url];
-    if (record.initiator.type === 'script') {
-      // Script initiators have the stack of callFrames from all functions that led to this request.
-      // If async stacks are enabled, then the stack will also have the parent functions that asynchronously
-      // led to this request chained in the `parent` property.
-      /** @type {Set<string>} */
-      const scriptURLs = new Set();
-      let stack = record.initiator.stack;
-      while (stack) {
-        const callFrames = stack.callFrames || [];
-        for (const frame of callFrames) {
-          if (frame.url) scriptURLs.add(frame.url);
-        }
-
-        stack = stack.parent;
-      }
-
-      return Array.from(scriptURLs);
-    }
-
-    return [];
-  }
-
-  /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @return {NetworkNodeOutput}
-   */
-  static getNetworkNodeOutput(networkRecords) {
-    /** @type {Array<NetworkNode>} */
-    const nodes = [];
-    /** @type {Map<string, NetworkNode>} */
-    const idToNodeMap = new Map();
-    /** @type {Map<string, Array<NetworkNode>>} */
-    const urlToNodeMap = new Map();
-    /** @type {Map<string, NetworkNode|null>} */
-    const frameIdToNodeMap = new Map();
-
-    networkRecords.forEach(record => {
-      if (IGNORED_MIME_TYPES_REGEX.test(record.mimeType)) return;
-      if (record.sessionTargetType === 'worker') return;
-
-      // Network record requestIds can be duplicated for an unknown reason
-      // Suffix all subsequent records with `:duplicate` until it's unique
-      // NOTE: This should never happen with modern NetworkRequest library, but old fixtures
-      // might still have this issue.
-      while (idToNodeMap.has(record.requestId)) {
-        record.requestId += ':duplicate';
-      }
-
-      const node = new NetworkNode(NetworkRequest.asLanternNetworkRequest(record));
-      nodes.push(node);
-
-      const urlList = urlToNodeMap.get(record.url) || [];
-      urlList.push(node);
-
-      idToNodeMap.set(record.requestId, node);
-      urlToNodeMap.set(record.url, urlList);
-
-      // If the request was for the root document of an iframe, save an entry in our
-      // map so we can link up the task `args.data.frame` dependencies later in graph creation.
-      if (record.frameId &&
-          record.resourceType === NetworkRequest.TYPES.Document &&
-          record.documentURL === record.url) {
-        // If there's ever any ambiguity, permanently set the value to `false` to avoid loops in the graph.
-        const value = frameIdToNodeMap.has(record.frameId) ? null : node;
-        frameIdToNodeMap.set(record.frameId, value);
-      }
-    });
-
-    return {nodes, idToNodeMap, urlToNodeMap, frameIdToNodeMap};
-  }
-
-  /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @return {Array<CPUNode>}
-   */
-  static getCPUNodes({mainThreadEvents}) {
-    /** @type {Array<CPUNode>} */
-    const nodes = [];
-    let i = 0;
-
-    TraceProcessor.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) {
-        continue;
-      }
-
-      // Capture all events that occurred within the task
-      /** @type {Array<LH.TraceEvent>} */
-      const children = [];
-      for (
-        const endTime = evt.ts + evt.dur;
-        i < mainThreadEvents.length && mainThreadEvents[i].ts < endTime;
-        i++
-      ) {
-        children.push(mainThreadEvents[i]);
-      }
-
-      nodes.push(new CPUNode(evt, children));
-    }
-
-    return nodes;
-  }
-
-  /**
-   * @param {NetworkNode} rootNode
-   * @param {NetworkNodeOutput} networkNodeOutput
-   */
-  static linkNetworkNodes(rootNode, networkNodeOutput) {
-    networkNodeOutput.nodes.forEach(node => {
-      const directInitiatorRequest = node.record.initiatorRequest || rootNode.record;
-      const directInitiatorNode =
-        networkNodeOutput.idToNodeMap.get(directInitiatorRequest.requestId) || rootNode;
-      const canDependOnInitiator =
-        !directInitiatorNode.isDependentOn(node) &&
-        node.canDependOn(directInitiatorNode);
-      const initiators = PageDependencyGraph.getNetworkInitiators(node.record);
-      if (initiators.length) {
-        initiators.forEach(initiator => {
-          const parentCandidates = networkNodeOutput.urlToNodeMap.get(initiator) || [];
-          // Only add the edge if the parent is unambiguous with valid timing and isn't circular.
-          if (parentCandidates.length === 1 &&
-              parentCandidates[0].startTime <= node.startTime &&
-              !parentCandidates[0].isDependentOn(node)) {
-            node.addDependency(parentCandidates[0]);
-          } else if (canDependOnInitiator) {
-            directInitiatorNode.addDependent(node);
-          }
-        });
-      } else if (canDependOnInitiator) {
-        directInitiatorNode.addDependent(node);
-      }
-
-      // Make sure the nodes are attached to the graph if the initiator information was invalid.
-      if (node !== rootNode && node.getDependencies().length === 0 && node.canDependOn(rootNode)) {
-        node.addDependency(rootNode);
-      }
-
-      if (!node.record.redirects) return;
-
-      const redirects = [...node.record.redirects, node.record];
-      for (let i = 1; i < redirects.length; i++) {
-        const redirectNode = networkNodeOutput.idToNodeMap.get(redirects[i - 1].requestId);
-        const actualNode = networkNodeOutput.idToNodeMap.get(redirects[i].requestId);
-        if (actualNode && redirectNode) {
-          actualNode.addDependency(redirectNode);
-        }
-      }
-    });
-  }
-
-  /**
-   * @param {Node} rootNode
-   * @param {NetworkNodeOutput} networkNodeOutput
-   * @param {Array<CPUNode>} cpuNodes
-   */
-  static linkCPUNodes(rootNode, networkNodeOutput, cpuNodes) {
-    /** @type {Set<LH.Crdp.Network.ResourceType|undefined>} */
-    const linkableResourceTypes = new Set([
-      NetworkRequest.TYPES.XHR, NetworkRequest.TYPES.Fetch, NetworkRequest.TYPES.Script,
-    ]);
-
-    /** @param {CPUNode} cpuNode @param {string} reqId */
-    function addDependentNetworkRequest(cpuNode, reqId) {
-      const networkNode = networkNodeOutput.idToNodeMap.get(reqId);
-      if (!networkNode ||
-          // Ignore all network nodes that started before this CPU task started
-          // A network request that started earlier could not possibly have been started by this task
-          networkNode.startTime <= cpuNode.startTime) return;
-      const {record} = networkNode;
-      const resourceType = record.resourceType ||
-        record.redirectDestination?.resourceType;
-      if (!linkableResourceTypes.has(resourceType)) {
-        // We only link some resources to CPU nodes because we observe LCP simulation
-        // regressions when including images, etc.
-        return;
-      }
-      cpuNode.addDependent(networkNode);
-    }
-
-    /**
-     * If the node has an associated frameId, then create a dependency on the root document request
-     * for the frame. The task obviously couldn't have started before the frame was even downloaded.
-     *
-     * @param {CPUNode} cpuNode
-     * @param {string|undefined} frameId
-     */
-    function addDependencyOnFrame(cpuNode, frameId) {
-      if (!frameId) return;
-      const networkNode = networkNodeOutput.frameIdToNodeMap.get(frameId);
-      if (!networkNode) return;
-      // Ignore all network nodes that started after this CPU task started
-      // A network request that started after could not possibly be required this task
-      if (networkNode.startTime >= cpuNode.startTime) return;
-      cpuNode.addDependency(networkNode);
-    }
-
-    /** @param {CPUNode} cpuNode @param {string} url */
-    function addDependencyOnUrl(cpuNode, url) {
-      if (!url) return;
-      // Allow network requests that end up to 100ms before the task started
-      // Some script evaluations can start before the script finishes downloading
-      const minimumAllowableTimeSinceNetworkNodeEnd = -100 * 1000;
-      const candidates = networkNodeOutput.urlToNodeMap.get(url) || [];
-
-      let minCandidate = null;
-      let minDistance = Infinity;
-      // Find the closest request that finished before this CPU task started
-      for (const candidate of candidates) {
-        // Explicitly ignore all requests that started after this CPU node
-        // A network request that started after this task started cannot possibly be a dependency
-        if (cpuNode.startTime <= candidate.startTime) return;
-
-        const distance = cpuNode.startTime - candidate.endTime;
-        if (distance >= minimumAllowableTimeSinceNetworkNodeEnd && distance < minDistance) {
-          minCandidate = candidate;
-          minDistance = distance;
-        }
-      }
-
-      if (!minCandidate) return;
-      cpuNode.addDependency(minCandidate);
-    }
-
-    /** @type {Map<string, CPUNode>} */
-    const timers = new Map();
-    for (const node of cpuNodes) {
-      for (const evt of node.childEvents) {
-        if (!evt.args.data) continue;
-
-        const argsUrl = evt.args.data.url;
-        const stackTraceUrls = (evt.args.data.stackTrace || []).map(l => l.url).filter(Boolean);
-
-        switch (evt.name) {
-          case 'TimerInstall':
-            // @ts-expect-error - 'TimerInstall' event means timerId exists.
-            timers.set(evt.args.data.timerId, node);
-            stackTraceUrls.forEach(url => addDependencyOnUrl(node, url));
-            break;
-          case 'TimerFire': {
-            // @ts-expect-error - 'TimerFire' event means timerId exists.
-            const installer = timers.get(evt.args.data.timerId);
-            if (!installer || installer.endTime > node.startTime) break;
-            installer.addDependent(node);
-            break;
-          }
-
-          case 'InvalidateLayout':
-          case 'ScheduleStyleRecalculation':
-            addDependencyOnFrame(node, evt.args.data.frame);
-            stackTraceUrls.forEach(url => addDependencyOnUrl(node, url));
-            break;
-
-          case 'EvaluateScript':
-            addDependencyOnFrame(node, evt.args.data.frame);
-            // @ts-expect-error - 'EvaluateScript' event means argsUrl is defined.
-            addDependencyOnUrl(node, argsUrl);
-            stackTraceUrls.forEach(url => addDependencyOnUrl(node, url));
-            break;
-
-          case 'XHRReadyStateChange':
-            // Only create the dependency if the request was completed
-            // 'XHRReadyStateChange' event means readyState is defined.
-            if (evt.args.data.readyState !== 4) break;
-
-            // @ts-expect-error - 'XHRReadyStateChange' event means argsUrl is defined.
-            addDependencyOnUrl(node, argsUrl);
-            stackTraceUrls.forEach(url => addDependencyOnUrl(node, url));
-            break;
-
-          case 'FunctionCall':
-          case 'v8.compile':
-            addDependencyOnFrame(node, evt.args.data.frame);
-            // @ts-expect-error - events mean argsUrl is defined.
-            addDependencyOnUrl(node, argsUrl);
-            break;
-
-          case 'ParseAuthorStyleSheet':
-            addDependencyOnFrame(node, evt.args.data.frame);
-            // @ts-expect-error - 'ParseAuthorStyleSheet' event means styleSheetUrl is defined.
-            addDependencyOnUrl(node, evt.args.data.styleSheetUrl);
-            break;
-
-          case 'ResourceSendRequest':
-            addDependencyOnFrame(node, evt.args.data.frame);
-            // @ts-expect-error - 'ResourceSendRequest' event means requestId is defined.
-            addDependentNetworkRequest(node, evt.args.data.requestId);
-            stackTraceUrls.forEach(url => addDependencyOnUrl(node, url));
-            break;
-        }
-      }
-
-      // Nodes starting before the root node cannot depend on it.
-      if (node.getNumberOfDependencies() === 0 && node.canDependOn(rootNode)) {
-        node.addDependency(rootNode);
-      }
-    }
-
-    // Second pass to prune the graph of short tasks.
-    const minimumEvtDur = SIGNIFICANT_DUR_THRESHOLD_MS * 1000;
-    let foundFirstLayout = false;
-    let foundFirstPaint = false;
-    let foundFirstParse = false;
-
-    for (const node of cpuNodes) {
-      // Don't prune if event is the first ParseHTML/Layout/Paint.
-      // See https://github.com/GoogleChrome/lighthouse/issues/9627#issuecomment-526699524 for more.
-      let isFirst = false;
-      if (!foundFirstLayout && node.childEvents.some(evt => evt.name === 'Layout')) {
-        isFirst = foundFirstLayout = true;
-      }
-      if (!foundFirstPaint && node.childEvents.some(evt => evt.name === 'Paint')) {
-        isFirst = foundFirstPaint = true;
-      }
-      if (!foundFirstParse && node.childEvents.some(evt => evt.name === 'ParseHTML')) {
-        isFirst = foundFirstParse = true;
-      }
-
-      if (isFirst || node.event.dur >= minimumEvtDur) {
-        // Don't prune this node. The task is long / important so it will impact simulation.
-        continue;
-      }
-
-      // Prune the node if it isn't highly connected to minimize graph size. Rewiring the graph
-      // here replaces O(M + N) edges with (M * N) edges, which is fine if either  M or N is at
-      // most 1.
-      if (node.getNumberOfDependencies() === 1 || node.getNumberOfDependents() <= 1) {
-        PageDependencyGraph._pruneNode(node);
-      }
-    }
-  }
-
-  /**
-   * Removes the given node from the graph, but retains all paths between its dependencies and
-   * dependents.
-   * @param {Node} node
-   */
-  static _pruneNode(node) {
-    const dependencies = node.getDependencies();
-    const dependents = node.getDependents();
-    for (const dependency of dependencies) {
-      node.removeDependency(dependency);
-      for (const dependent of dependents) {
-        dependency.addDependent(dependent);
-      }
-    }
-    for (const dependent of dependents) {
-      node.removeDependent(dependent);
-    }
-  }
-
-  /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @param {URLArtifact} URL
-   * @return {Node}
-   */
-  static createGraph(processedTrace, networkRecords, URL) {
-    const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
-    const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
-    const {requestedUrl, mainDocumentUrl} = URL;
-    if (!requestedUrl) throw new Error('requestedUrl is required to get the root request');
-    if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');
-
-    const rootRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
-    if (!rootRequest) throw new Error('rootRequest not found');
-    const rootNode = networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
-    if (!rootNode) throw new Error('rootNode not found');
-
-    const mainDocumentRequest =
-      NetworkAnalyzer.findLastDocumentForUrl(networkRecords, mainDocumentUrl);
-    if (!mainDocumentRequest) throw new Error('mainDocumentRequest not found');
-    const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
-    if (!mainDocumentNode) throw new Error('mainDocumentNode not found');
-
-    PageDependencyGraph.linkNetworkNodes(rootNode, networkNodeOutput);
-    PageDependencyGraph.linkCPUNodes(rootNode, networkNodeOutput, cpuNodes);
-    mainDocumentNode.setIsMainDocument(true);
-
-    if (NetworkNode.hasCycle(rootNode)) {
-      throw new Error('Invalid dependency graph created, cycle detected');
-    }
-
-    return rootNode;
-  }
-
-  /**
-   *
-   * @param {Node} rootNode
-   */
-  static printGraph(rootNode, widthInCharacters = 100) {
-    /** @param {string} str @param {number} target */
-    function padRight(str, target, padChar = ' ') {
-      return str + padChar.repeat(Math.max(target - str.length, 0));
-    }
-
-    /** @type {Array<Node>} */
-    const nodes = [];
-    rootNode.traverse(node => nodes.push(node));
-    nodes.sort((a, b) => a.startTime - b.startTime);
-
-    const min = nodes[0].startTime;
-    const max = nodes.reduce((max, node) => Math.max(max, node.endTime), 0);
-
-    const totalTime = max - min;
-    const timePerCharacter = totalTime / widthInCharacters;
-    nodes.forEach(node => {
-      const offset = Math.round((node.startTime - min) / timePerCharacter);
-      const length = Math.ceil((node.endTime - node.startTime) / timePerCharacter);
-      const bar = padRight('', offset) + padRight('', length, '=');
-
-      // @ts-expect-error -- disambiguate displayName from across possible Node types.
-      const displayName = node.record ? node.record.url : node.type;
-      // eslint-disable-next-line
-      console.log(padRight(bar, widthInCharacters), `| ${displayName.slice(0, 30)}`);
-    });
-  }
-
   /**
    * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -478,7 +30,8 @@ class PageDependencyGraph {
     // Calculates the URL artifact from the processed trace and DT log.
     const URL = data.URL || await DocumentUrls.request(data, context);
 
-    return PageDependencyGraph.createGraph(processedTrace, networkRecords, URL);
+    const lanternRequests = networkRecords.map(NetworkRequest.asLanternNetworkRequest);
+    return LanternPageDependencyGraph.createGraph(processedTrace, lanternRequests, URL);
   }
 }
 

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

@@ -3,7 +3,6 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export const NetworkRequest: import("../../../types/internal/lantern").NetworkRequest<any>;
 /** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 export const NetworkRequestTypes: LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
 //# sourceMappingURL=lantern.d.ts.map

package/core/lib/lantern/lantern.js

@@ -4,8 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const NetworkRequest = /** @type {import('../../../types/internal/lantern').NetworkRequest} */({});
-
 /** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 const NetworkRequestTypes = {
   XHR: 'XHR',
@@ -29,6 +27,5 @@ const NetworkRequestTypes = {
 };
 
 export {
-  NetworkRequest,
   NetworkRequestTypes,
 };

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

@@ -1,12 +1,13 @@
+export type NetworkRequest<T> = import('../../../types/internal/lantern.js').Lantern.NetworkRequest<T>;
 /**
  * @template [T=any]
  * @extends {BaseNode<T>}
  */
 export class NetworkNode<T = any> extends BaseNode<T> {
     /**
-     * @param {Lantern.NetworkRequest<T>} networkRequest
+     * @param {NetworkRequest<T>} networkRequest
      */
-    constructor(networkRequest: import("../../../types/internal/lantern.js").NetworkRequest<any>);
+    constructor(networkRequest: NetworkRequest<T>);
     /** @private */
     private _request;
     get type(): "network";
@@ -15,9 +16,9 @@ export class NetworkNode<T = any> extends BaseNode<T> {
      */
     get record(): Readonly<T>;
     /**
-     * @return {Lantern.NetworkRequest<T>}
+     * @return {NetworkRequest<T>}
      */
-    get request(): import("../../../types/internal/lantern.js").NetworkRequest<any>;
+    get request(): import("../../../types/internal/lantern.js").Lantern.NetworkRequest<T>;
     /**
      * @return {string}
      */