lighthouse 11.6.0 → 11.7.0

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

@@ -1,65 +1,6 @@
-export type Node = import('../../lib/dependency-graph/base-node.js').Node;
-export type NetworkNode = import('../../lib/dependency-graph/network-node').NetworkNode;
-export type Simulator = import('../../lib/dependency-graph/simulator/simulator').Simulator;
-export type Extras = {
-    optimistic: boolean;
-    fcpResult?: LH.Artifacts.LanternMetric | undefined;
-    fmpResult?: LH.Artifacts.LanternMetric | undefined;
-    interactiveResult?: LH.Artifacts.LanternMetric | undefined;
-    speedline?: {
-        speedIndex: number;
-    } | undefined;
-};
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
-/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
-/** @typedef {import('../../lib/dependency-graph/simulator/simulator').Simulator} Simulator */
-/**
- * @typedef Extras
- * @property {boolean} optimistic
- * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} fmpResult
- * @property {LH.Artifacts.LanternMetric=} interactiveResult
- * @property {{speedIndex: number}=} speedline
- */
-export class LanternMetric {
-    /**
-     * @param {Node} dependencyGraph
-     * @param {function(NetworkNode):boolean=} treatNodeAsRenderBlocking
-     * @return {Set<string>}
-     */
-    static getScriptUrls(dependencyGraph: Node, treatNodeAsRenderBlocking?: ((arg0: NetworkNode) => boolean) | undefined): Set<string>;
-    /**
-     * @return {LH.Gatherer.Simulation.MetricCoefficients}
-     */
-    static get COEFFICIENTS(): import("../../../types/gatherer.js").default.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
-     * from the simulator. In this case, we need to adjust the coefficients as the target throttling
-     * settings change.
-     *
-     * @param {number} rttMs
-     * @return {LH.Gatherer.Simulation.MetricCoefficients}
-     */
-    static getScaledCoefficients(rttMs: number): LH.Gatherer.Simulation.MetricCoefficients;
-    /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @param {Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: Extras): LH.Gatherer.Simulation.Result;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+export class LanternMetric extends Metric {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -74,5 +15,5 @@ export class LanternMetric {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { ProcessedNavigation } from '../processed-navigation.js';
+import { Metric } from '../../lib/lantern/metric.js';
 //# sourceMappingURL=lantern-metric.d.ts.map

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

@@ -4,93 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {BaseNode} from '../../lib/dependency-graph/base-node.js';
-import {NetworkRequest} from '../../lib/network-request.js';
-import {ProcessedNavigation} from '../processed-navigation.js';
-import {PageDependencyGraph} from '../page-dependency-graph.js';
+import {Metric} from '../../lib/lantern/metric.js';
 import {LoadSimulator} from '../load-simulator.js';
+import {PageDependencyGraph} from '../page-dependency-graph.js';
+import {ProcessedNavigation} from '../processed-navigation.js';
 
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
-/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
-/** @typedef {import('../../lib/dependency-graph/simulator/simulator').Simulator} Simulator */
-
-/**
- * @typedef Extras
- * @property {boolean} optimistic
- * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} fmpResult
- * @property {LH.Artifacts.LanternMetric=} interactiveResult
- * @property {{speedIndex: number}=} speedline
- */
-
-class LanternMetric {
-  /**
-   * @param {Node} dependencyGraph
-   * @param {function(NetworkNode):boolean=} treatNodeAsRenderBlocking
-   * @return {Set<string>}
-   */
-  static getScriptUrls(dependencyGraph, treatNodeAsRenderBlocking) {
-    /** @type {Set<string>} */
-    const scriptUrls = new Set();
-
-    dependencyGraph.traverse(node => {
-      if (node.type !== BaseNode.TYPES.NETWORK) return;
-      if (node.record.resourceType !== NetworkRequest.TYPES.Script) return;
-      if (treatNodeAsRenderBlocking?.(node)) {
-        scriptUrls.add(node.record.url);
-      }
-    });
-
-    return scriptUrls;
-  }
-
-  /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    throw new Error('COEFFICIENTS unimplemented!');
-  }
-
-  /**
-   * 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
-   * from the simulator. In this case, we need to adjust the coefficients as the target throttling
-   * settings change.
-   *
-   * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    return this.COEFFICIENTS;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Optimistic graph unimplemented!');
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Pessmistic graph unimplemented!');
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult, extras) { // eslint-disable-line no-unused-vars
-    return simulationResult;
-  }
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
+class LanternMetric extends Metric {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -104,50 +25,11 @@ class LanternMetric {
       throw new Error(`Lantern metrics can only be computed on navigations`);
     }
 
-    const metricName = this.name.replace('Lantern', '');
     const graph = await PageDependencyGraph.request(data, context);
     const processedNavigation = await ProcessedNavigation.request(data.trace, context);
     const simulator = data.simulator || (await LoadSimulator.request(data, context));
 
-    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
-    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
-
-    /** @type {{flexibleOrdering?: boolean, label?: string}} */
-    let simulateOptions = {label: `optimistic${metricName}`};
-    const optimisticSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `optimisticFlex${metricName}`, flexibleOrdering: true};
-    const optimisticFlexSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `pessimistic${metricName}`};
-    const pessimisticSimulation = simulator.simulate(pessimisticGraph, simulateOptions);
-
-    const optimisticEstimate = this.getEstimateFromSimulation(
-      optimisticSimulation.timeInMs < optimisticFlexSimulation.timeInMs ?
-        optimisticSimulation : optimisticFlexSimulation, {...extras, optimistic: true}
-    );
-
-    const pessimisticEstimate = this.getEstimateFromSimulation(
-      pessimisticSimulation,
-      {...extras, optimistic: false}
-    );
-
-    const coefficients = this.getScaledCoefficients(simulator.rtt);
-    // Estimates under 1s don't really follow the normal curve fit, minimize the impact of the intercept
-    const interceptMultiplier = coefficients.intercept > 0 ?
-      Math.min(1, optimisticEstimate.timeInMs / 1000) : 1;
-    const timing =
-      coefficients.intercept * interceptMultiplier +
-      coefficients.optimistic * optimisticEstimate.timeInMs +
-      coefficients.pessimistic * pessimisticEstimate.timeInMs;
-
-    return {
-      timing,
-      optimisticEstimate,
-      pessimisticEstimate,
-      optimisticGraph,
-      pessimisticGraph,
-    };
+    return this.compute({simulator, graph, processedNavigation}, extras);
   }
 
   /**

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

@@ -1,11 +1,11 @@
 export { LanternSpeedIndexComputed as LanternSpeedIndex };
-export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
 declare const LanternSpeedIndexComputed: typeof LanternSpeedIndex & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 declare class LanternSpeedIndex extends LanternMetric {
     /**
      * @param {Node} dependencyGraph
@@ -17,6 +17,12 @@ declare class LanternSpeedIndex extends LanternMetric {
      * @return {Node}
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @param {import('../../lib/lantern/metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../../lib/lantern/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

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

@@ -6,12 +6,12 @@
 
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/dependency-graph/base-node.js';
+import {BaseNode} from '../../lib/lantern/base-node.js';
 import {Speedline} from '../speedline.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 import {throttling as defaultThrottling} from '../../config/constants.js';
 
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
 class LanternSpeedIndex extends LanternMetric {
   /**
@@ -73,7 +73,7 @@ class LanternSpeedIndex extends LanternMetric {
 
   /**
    * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('./lantern-metric.js').Extras} extras
+   * @param {import('../../lib/lantern/metric.js').Extras} extras
    * @return {LH.Gatherer.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {

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

@@ -1,11 +1,11 @@
 export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
-export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
 declare const LanternTotalBlockingTimeComputed: typeof LanternTotalBlockingTime & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 declare class LanternTotalBlockingTime extends LanternMetric {
     /**
      * @param {Node} dependencyGraph
@@ -17,6 +17,12 @@ declare class LanternTotalBlockingTime extends LanternMetric {
      * @return {Node}
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulation
+     * @param {import('../../lib/lantern/metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../../lib/lantern/metric.js').Extras): LH.Gatherer.Simulation.Result;
     /**
      * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} minDurationMs

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

@@ -6,12 +6,12 @@
 
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/dependency-graph/base-node.js';
+import {BaseNode} from '../../lib/lantern/base-node.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 import {LanternInteractive} from './lantern-interactive.js';
 import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from './tbt-utils.js';
 
-/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
 class LanternTotalBlockingTime extends LanternMetric {
   /**
@@ -43,7 +43,7 @@ class LanternTotalBlockingTime extends LanternMetric {
 
   /**
    * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('./lantern-metric.js').Extras} extras
+   * @param {import('../../lib/lantern/metric.js').Extras} extras
    * @return {LH.Gatherer.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {

package/core/computed/metrics/responsiveness.d.ts

@@ -38,21 +38,13 @@ export type EventTimingEvent = LH.Trace.AsyncEvent & {
         data: EventTimingData;
     };
 };
-/**
- * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
- * TODO: Remove once 103.0.5052.0 is sufficiently released.
- */
-export type FallbackTimingEvent = {
-    name: 'FallbackTiming';
-    duration: number;
-};
 declare const ResponsivenessComputed: typeof Responsiveness & {
     request: (dependencies: {
         trace: LH.Trace;
         settings: LH.Audit.Context['settings'];
     }, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<EventTimingEvent | FallbackTimingEvent | null>;
+    }>) => Promise<EventTimingEvent | null>;
 };
 declare class Responsiveness {
     /**
@@ -70,18 +62,18 @@ declare class Responsiveness {
      * one interaction had this duration by returning the first found.
      * @param {ResponsivenessEvent} responsivenessEvent
      * @param {LH.Trace} trace
-     * @return {EventTimingEvent|FallbackTimingEvent}
+     * @return {EventTimingEvent}
      */
-    static findInteractionEvent(responsivenessEvent: ResponsivenessEvent, { traceEvents }: LH.Trace): EventTimingEvent | FallbackTimingEvent;
+    static findInteractionEvent(responsivenessEvent: ResponsivenessEvent, { traceEvents }: LH.Trace): EventTimingEvent;
     /**
      * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
+     * @return {Promise<EventTimingEvent|null>}
      */
     static compute_(data: {
         trace: LH.Trace;
         settings: LH.Audit.Context['settings'];
-    }, context: LH.Artifacts.ComputedContext): Promise<EventTimingEvent | FallbackTimingEvent | null>;
+    }, context: LH.Artifacts.ComputedContext): Promise<EventTimingEvent | null>;
 }
 import { ProcessedTrace } from '../processed-trace.js';
 //# sourceMappingURL=responsiveness.d.ts.map

package/core/computed/metrics/responsiveness.js

@@ -24,14 +24,10 @@
  * @property {number} interactionId
  */
 /** @typedef {LH.Trace.AsyncEvent & {name: 'EventTiming', args: {data: EventTimingData}}} EventTimingEvent */
-/**
- * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
- * TODO: Remove once 103.0.5052.0 is sufficiently released.
- * @typedef {{name: 'FallbackTiming', duration: number}} FallbackTimingEvent
- */
 
 import {ProcessedTrace} from '../processed-trace.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
+import {LighthouseError} from '../../lib/lh-error.js';
 
 const KEYBOARD_EVENTS = new Set(['keydown', 'keypress', 'keyup']);
 const CLICK_TAP_DRAG_EVENTS = new Set([
@@ -79,7 +75,7 @@ class Responsiveness {
    * one interaction had this duration by returning the first found.
    * @param {ResponsivenessEvent} responsivenessEvent
    * @param {LH.Trace} trace
-   * @return {EventTimingEvent|FallbackTimingEvent}
+   * @return {EventTimingEvent}
    */
   static findInteractionEvent(responsivenessEvent, {traceEvents}) {
     const candidates = traceEvents.filter(/** @return {evt is EventTimingEvent} */ evt => {
@@ -87,15 +83,15 @@ class Responsiveness {
       return evt.name === 'EventTiming' && evt.ph !== 'e';
     });
 
-    // If trace is from < m103, the timestamps cannot be trusted, so we craft a fallback
-    // <m103 traces (bad) had a   args.frame
+    // If trace is from < m103, the timestamps cannot be trusted
+    // <m103 traces (bad) had a   args.frame (we used to provide a fallback trace event, but not
+    //                                        any more)
     // m103+ traces (good) have a args.data.frame (https://crrev.com/c/3632661)
-    // TODO(compat): remove FallbackTiming handling when we don't care about <m103
     if (candidates.length && candidates.every(candidate => !candidate.args.data?.frame)) {
-      return {
-        name: 'FallbackTiming',
-        duration: responsivenessEvent.args.data.maxDuration,
-      };
+      throw new LighthouseError(
+        LighthouseError.errors.UNSUPPORTED_OLD_CHROME,
+        {featureName: 'detailed EventTiming trace events'}
+      );
     }
 
     const {maxDuration, interactionType} = responsivenessEvent.args.data;
@@ -136,7 +132,7 @@ class Responsiveness {
   /**
    * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
+   * @return {Promise<EventTimingEvent|null>}
    */
   static async compute_(data, context) {
     const {settings, trace} = data;

package/core/computed/network-analysis.js

@@ -5,7 +5,7 @@
  */
 
 import {makeComputedArtifact} from './computed-artifact.js';
-import {NetworkAnalyzer} from '../lib/dependency-graph/simulator/network-analyzer.js';
+import {NetworkAnalyzer} from '../lib/lantern/simulator/network-analyzer.js';
 import {NetworkRecords} from './network-records.js';
 
 class NetworkAnalysis {

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

@@ -1,12 +1,5 @@
 export { PageDependencyGraphComputed as PageDependencyGraph };
-export type Node = import('../lib/dependency-graph/base-node.js').Node;
-export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
-export type NetworkNodeOutput = {
-    nodes: Array<NetworkNode>;
-    idToNodeMap: Map<string, NetworkNode>;
-    urlToNodeMap: Map<string, Array<NetworkNode>>;
-    frameIdToNodeMap: Map<string, NetworkNode | null>;
-};
+export type Node = import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
 declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     request: (dependencies: {
         trace: LH.Trace;
@@ -14,54 +7,11 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
         URL: LH.Artifacts['URL'];
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../lib/dependency-graph/base-node.js").Node>;
+    }>) => Promise<Node>;
 };
-import { NetworkNode } from '../lib/dependency-graph/network-node.js';
+import { NetworkRequest } from '../lib/network-request.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
@@ -73,7 +23,4 @@ declare class PageDependencyGraph {
         URL: LH.Artifacts['URL'];
     }, context: LH.Artifacts.ComputedContext): Promise<Node>;
 }
-import { NetworkRequest } from '../lib/network-request.js';
-import { ProcessedTrace } from './processed-trace.js';
-import { CPUNode } from '../lib/dependency-graph/cpu-node.js';
 //# sourceMappingURL=page-dependency-graph.d.ts.map