devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/models/trace/lantern/metrics/FirstContentfulPaint.ts

@@ -1,187 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Graph from '../graph/graph.js';
-import type * as Types from '../types/types.js';
-
-import {Metric, type MetricCoefficients} from './Metric.js';
-
-interface FirstPaintBasedGraphOpts<T> {
-  /**
-   * The timestamp used to filter out tasks that occurred after our paint of interest.
-   * Typically this is First Contentful Paint or First Meaningful Paint.
-   */
-  cutoffTimestamp: number;
-  /**
-   * The function that determines which resources should be considered *possibly*
-   * render-blocking.
-   */
-  treatNodeAsRenderBlocking: (node: Graph.NetworkNode<T>) => boolean;
-  /**
-   * The function that determines which CPU nodes should also be included in our
-   * blocking node IDs set, beyond what getRenderBlockingNodeData() already includes.
-   */
-  additionalCpuNodesToTreatAsRenderBlocking?: (node: Graph.CPUNode) => boolean;
-}
-
-class FirstContentfulPaint extends Metric {
-  static override get coefficients(): MetricCoefficients {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * Computes the set of URLs that *appeared* to be render-blocking based on our filter,
-   * *but definitely were not* render-blocking based on the timing of their EvaluateScript task.
-   * It also computes the set of corresponding CPU node ids that were needed for the paint at the
-   * given timestamp.
-   */
-  static getRenderBlockingNodeData<T = unknown>(
-      graph: Graph.Node,
-      {cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking}:
-          FirstPaintBasedGraphOpts<T>,
-      ): {definitelyNotRenderBlockingScriptUrls: Set<string>, renderBlockingCpuNodeIds: Set<string>} {
-    /** A map of blocking script URLs to the earliest EvaluateScript task node that executed them. */
-    const scriptUrlToNodeMap = new Map<string, Graph.CPUNode>();
-
-    const cpuNodes: Graph.CPUNode[] = [];
-    graph.traverse(node => {
-      if (node.type === Graph.BaseNode.types.CPU) {
-        // A task is *possibly* render blocking if it *started* before cutoffTimestamp.
-        // We use startTime here because the paint event can be *inside* the task that was render blocking.
-        if (node.startTime <= cutoffTimestamp) {
-          cpuNodes.push(node);
-        }
-
-        // Build our script URL map to find the earliest EvaluateScript task node.
-        const scriptUrls = node.getEvaluateScriptURLs();
-        for (const url of scriptUrls) {
-          // Use the earliest CPU node we find.
-          const existing = scriptUrlToNodeMap.get(url) || node;
-          scriptUrlToNodeMap.set(url, node.startTime < existing.startTime ? node : existing);
-        }
-      }
-    });
-
-    cpuNodes.sort((a, b) => a.startTime - b.startTime);
-
-    // A script is *possibly* render blocking if it finished loading before cutoffTimestamp.
-    const possiblyRenderBlockingScriptUrls = Metric.getScriptUrls(graph, node => {
-      // The optimistic LCP treatNodeAsRenderBlocking fn wants to exclude some images in the graph,
-      // but here it only receives scripts to evaluate. It's a no-op in this case, but it will
-      // matter below in the getFirstPaintBasedGraph clone operation.
-      return node.endTime <= cutoffTimestamp && treatNodeAsRenderBlocking(node);
-    });
-
-    // A script is *definitely not* render blocking if its EvaluateScript task started after cutoffTimestamp.
-    const definitelyNotRenderBlockingScriptUrls = new Set<string>();
-    const renderBlockingCpuNodeIds = new Set<string>();
-    for (const url of possiblyRenderBlockingScriptUrls) {
-      // Lookup the CPU node that had the earliest EvaluateScript for this URL.
-      const cpuNodeForUrl = scriptUrlToNodeMap.get(url);
-
-      // If we can't find it at all, we can't conclude anything, so just skip it.
-      if (!cpuNodeForUrl) {
-        continue;
-      }
-
-      // If we found it and it was in our `cpuNodes` set that means it finished before cutoffTimestamp, so it really is render-blocking.
-      if (cpuNodes.includes(cpuNodeForUrl)) {
-        renderBlockingCpuNodeIds.add(cpuNodeForUrl.id);
-        continue;
-      }
-
-      // We couldn't find the evaluate script in the set of CPU nodes that ran before our paint, so
-      // it must not have been necessary for the paint.
-      definitelyNotRenderBlockingScriptUrls.add(url);
-    }
-
-    // The first layout, first paint, and first ParseHTML are almost always necessary for first paint,
-    // so we always include those CPU nodes.
-    const firstLayout = cpuNodes.find(node => node.didPerformLayout());
-    if (firstLayout) {
-      renderBlockingCpuNodeIds.add(firstLayout.id);
-    }
-    const firstPaint = cpuNodes.find(node => node.childEvents.some(e => e.name === 'Paint'));
-    if (firstPaint) {
-      renderBlockingCpuNodeIds.add(firstPaint.id);
-    }
-    const firstParse = cpuNodes.find(node => node.childEvents.some(e => e.name === 'ParseHTML'));
-    if (firstParse) {
-      renderBlockingCpuNodeIds.add(firstParse.id);
-    }
-
-    // If a CPU filter was passed in, we also want to include those extra nodes.
-    if (additionalCpuNodesToTreatAsRenderBlocking) {
-      cpuNodes.filter(additionalCpuNodesToTreatAsRenderBlocking).forEach(node => renderBlockingCpuNodeIds.add(node.id));
-    }
-
-    return {
-      definitelyNotRenderBlockingScriptUrls,
-      renderBlockingCpuNodeIds,
-    };
-  }
-
-  /**
-   * Computes the graph required for the first paint of interest.
-   */
-  static getFirstPaintBasedGraph<T>(
-      dependencyGraph: Graph.Node,
-      {cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking}:
-          FirstPaintBasedGraphOpts<T>,
-      ): Graph.Node<T> {
-    const rbData = this.getRenderBlockingNodeData(dependencyGraph, {
-      cutoffTimestamp,
-      treatNodeAsRenderBlocking,
-      additionalCpuNodesToTreatAsRenderBlocking,
-    });
-    const {definitelyNotRenderBlockingScriptUrls, renderBlockingCpuNodeIds} = rbData;
-
-    return dependencyGraph.cloneWithRelationships(node => {
-      if (node.type === Graph.BaseNode.types.NETWORK) {
-        // Exclude all nodes that ended after cutoffTimestamp (except for the main document which we always consider necessary)
-        // endTime is negative if request does not finish, make sure startTime isn't after cutoffTimestamp in this case.
-        const endedAfterPaint = node.endTime > cutoffTimestamp || node.startTime > cutoffTimestamp;
-        if (endedAfterPaint && !node.isMainDocument()) {
-          return false;
-        }
-
-        const url = node.request.url;
-        // If the URL definitely wasn't render-blocking then we filter it out.
-        if (definitelyNotRenderBlockingScriptUrls.has(url)) {
-          return false;
-        }
-
-        // Lastly, build up the FCP graph of all nodes we consider render blocking
-        return treatNodeAsRenderBlocking(node);
-      }
-      // If it's a CPU node, just check if it was blocking.
-      return renderBlockingCpuNodeIds.has(node.id);
-    });
-  }
-
-  static override getOptimisticGraph<T>(
-      dependencyGraph: Graph.Node<T>, processedNavigation: Types.Simulation.ProcessedNavigation): Graph.Node<T> {
-    return this.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: processedNavigation.timestamps.firstContentfulPaint,
-      // In the optimistic graph we exclude resources that appeared to be render blocking but were
-      // initiated by a script. While they typically have a very high importance and tend to have a
-      // significant impact on the page's content, these resources don't technically block rendering.
-      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority() && node.initiatorType !== 'script',
-    });
-  }
-
-  static override getPessimisticGraph<T>(
-      dependencyGraph: Graph.Node<T>, processedNavigation: Types.Simulation.ProcessedNavigation): Graph.Node<T> {
-    return this.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: processedNavigation.timestamps.firstContentfulPaint,
-      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority(),
-    });
-  }
-}
-
-export {FirstContentfulPaint};

package/lib/front_end/models/trace/lantern/metrics/Interactive.ts

@@ -1,88 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import * as Graph from '../graph/graph.js';
-import type * as Simulation from '../simulation/simulation.js';
-
-import {
-  type Extras,
-  Metric,
-  type MetricCoefficients,
-  type MetricComputationDataInput,
-  type MetricResult,
-} from './Metric.js';
-
-// Any CPU task of 20 ms or more will end up being a critical long task on mobile
-const CRITICAL_LONG_TASK_THRESHOLD = 20;
-
-class Interactive extends Metric {
-  static override get coefficients(): MetricCoefficients {
-    return {
-      intercept: 0,
-      optimistic: 0.45,
-      pessimistic: 0.55,
-    };
-  }
-
-  static override getOptimisticGraph<T>(dependencyGraph: Graph.Node<T>): Graph.Node<T> {
-    // Adjust the critical long task threshold for microseconds
-    const minimumCpuTaskDuration = CRITICAL_LONG_TASK_THRESHOLD * 1000;
-
-    return dependencyGraph.cloneWithRelationships(node => {
-      // Include everything that might be a long task
-      if (node.type === Graph.BaseNode.types.CPU) {
-        return node.duration > minimumCpuTaskDuration;
-      }
-
-      // Include all scripts and high priority requests, exclude all images
-      const isImage = node.request.resourceType === 'Image';
-      const isScript = node.request.resourceType === 'Script';
-      return (!isImage && (isScript || node.request.priority === 'High' || node.request.priority === 'VeryHigh'));
-    });
-  }
-
-  static override getPessimisticGraph<T>(dependencyGraph: Graph.Node<T>): Graph.Node<T> {
-    return dependencyGraph;
-  }
-
-  static override getEstimateFromSimulation(simulationResult: Simulation.Result, extras: Extras): Simulation.Result {
-    if (!extras.lcpResult) {
-      throw new Core.LanternError('missing lcpResult');
-    }
-
-    const lastTaskAt = Interactive.getLastLongTaskEndTime(simulationResult.nodeTimings);
-    const minimumTime = extras.optimistic ? extras.lcpResult.optimisticEstimate.timeInMs :
-                                            extras.lcpResult.pessimisticEstimate.timeInMs;
-    return {
-      timeInMs: Math.max(minimumTime, lastTaskAt),
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  static override compute(data: MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'>): MetricResult {
-    const lcpResult = extras?.lcpResult;
-    if (!lcpResult) {
-      throw new Core.LanternError('LCP is required to calculate the Interactive metric');
-    }
-
-    const metricResult = super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, lcpResult.timing);
-    return metricResult;
-  }
-
-  static getLastLongTaskEndTime(nodeTimings: Simulation.Result['nodeTimings'], duration = 50): number {
-    return Array.from(nodeTimings.entries())
-        .filter(([node, timing]) => {
-          if (node.type !== Graph.BaseNode.types.CPU) {
-            return false;
-          }
-          return timing.duration > duration;
-        })
-        .map(([_, timing]) => timing.endTime)
-        .reduce((max, x) => Math.max(max || 0, x || 0), 0);
-  }
-}
-
-export {Interactive};

package/lib/front_end/models/trace/lantern/metrics/LargestContentfulPaint.ts

@@ -1,92 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import type * as Graph from '../graph/graph.js';
-import type * as Simulation from '../simulation/simulation.js';
-import type * as Types from '../types/types.js';
-
-import {FirstContentfulPaint} from './FirstContentfulPaint.js';
-import {
-  type Extras,
-  Metric,
-  type MetricCoefficients,
-  type MetricComputationDataInput,
-  type MetricResult,
-} from './Metric.js';
-
-class LargestContentfulPaint extends Metric {
-  static override get coefficients(): MetricCoefficients {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * Low priority image nodes are usually offscreen and very unlikely to be the
-   * resource that is required for LCP. Our LCP graphs include everything except for these images.
-   */
-  static isNotLowPriorityImageNode(node: Graph.Node): boolean {
-    if (node.type !== 'network') {
-      return true;
-    }
-    const isImage = node.request.resourceType === 'Image';
-    const isLowPriority = node.request.priority === 'Low' || node.request.priority === 'VeryLow';
-    return !isImage || !isLowPriority;
-  }
-
-  static override getOptimisticGraph(
-      dependencyGraph: Graph.Node, processedNavigation: Types.Simulation.ProcessedNavigation): Graph.Node {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new Core.LanternError('NO_LCP');
-    }
-
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: lcp,
-      treatNodeAsRenderBlocking: LargestContentfulPaint.isNotLowPriorityImageNode,
-    });
-  }
-
-  static override getPessimisticGraph(
-      dependencyGraph: Graph.Node, processedNavigation: Types.Simulation.ProcessedNavigation): Graph.Node {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new Core.LanternError('NO_LCP');
-    }
-
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: lcp,
-      treatNodeAsRenderBlocking: _ => true,
-      // For pessimistic LCP we'll include *all* layout nodes
-      additionalCpuNodesToTreatAsRenderBlocking: node => node.didPerformLayout(),
-    });
-  }
-
-  static override getEstimateFromSimulation(simulationResult: Simulation.Result): Simulation.Result {
-    const nodeTimesNotOffscreenImages = Array.from(simulationResult.nodeTimings.entries())
-                                            .filter(entry => LargestContentfulPaint.isNotLowPriorityImageNode(entry[0]))
-                                            .map(entry => entry[1].endTime);
-
-    return {
-      timeInMs: Math.max(...nodeTimesNotOffscreenImages),
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  static override compute(data: MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'>): MetricResult {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Core.LanternError('FCP is required to calculate the LCP metric');
-    }
-
-    const metricResult = super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-}
-
-export {LargestContentfulPaint};

package/lib/front_end/models/trace/lantern/metrics/MaxPotentialFID.ts

@@ -1,72 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import * as Graph from '../graph/graph.js';
-import type * as Simulation from '../simulation/simulation.js';
-
-import {
-  type Extras,
-  Metric,
-  type MetricCoefficients,
-  type MetricComputationDataInput,
-  type MetricResult,
-} from './Metric.js';
-
-class MaxPotentialFID extends Metric {
-  static override get coefficients(): MetricCoefficients {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  static override getOptimisticGraph(dependencyGraph: Graph.Node): Graph.Node {
-    return dependencyGraph;
-  }
-
-  static override getPessimisticGraph(dependencyGraph: Graph.Node): Graph.Node {
-    return dependencyGraph;
-  }
-
-  static override getEstimateFromSimulation(simulation: Simulation.Result, extras: Extras): Simulation.Result {
-    if (!extras.fcpResult) {
-      throw new Core.LanternError('missing fcpResult');
-    }
-
-    // Intentionally use the opposite FCP estimate, a more pessimistic FCP means that more tasks
-    // are excluded from the FID computation, so a higher FCP means lower FID for same work.
-    const fcpTimeInMs = extras.optimistic ? extras.fcpResult.pessimisticEstimate.timeInMs :
-                                            extras.fcpResult.optimisticEstimate.timeInMs;
-
-    const timings = MaxPotentialFID.getTimingsAfterFCP(
-        simulation.nodeTimings,
-        fcpTimeInMs,
-    );
-
-    return {
-      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
-      nodeTimings: simulation.nodeTimings,
-    };
-  }
-
-  static override compute(data: MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'>): MetricResult {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Core.LanternError('FCP is required to calculate the Max Potential FID metric');
-    }
-
-    return super.compute(data, extras);
-  }
-
-  static getTimingsAfterFCP(nodeTimings: Simulation.Result['nodeTimings'], fcpTimeInMs: number):
-      Array<{duration: number}> {
-    return Array.from(nodeTimings.entries())
-        .filter(([node, timing]) => node.type === Graph.BaseNode.types.CPU && timing.endTime > fcpTimeInMs)
-        .map(([_, timing]) => timing);
-  }
-}
-
-export {MaxPotentialFID};

package/lib/front_end/models/trace/lantern/metrics/Metric.ts

@@ -1,126 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import * as Graph from '../graph/graph.js';
-import type * as Simulation from '../simulation/simulation.js';
-import type * as Types from '../types/types.js';
-
-export interface MetricComputationDataInput {
-  simulator: Simulation.Simulator;
-  graph: Graph.Node<unknown>;
-  processedNavigation: Types.Simulation.ProcessedNavigation;
-}
-
-export interface MetricCoefficients {
-  intercept: number;
-  optimistic: number;
-  pessimistic: number;
-}
-
-export interface MetricResult<T = Types.AnyNetworkObject> {
-  timing: number;
-  timestamp?: never;
-  optimisticEstimate: Simulation.Result<T>;
-  pessimisticEstimate: Simulation.Result<T>;
-  optimisticGraph: Graph.Node<T>;
-  pessimisticGraph: Graph.Node;
-}
-
-export interface Extras {
-  optimistic: boolean;
-  fcpResult?: MetricResult;
-  lcpResult?: MetricResult;
-  interactiveResult?: MetricResult;
-  observedSpeedIndex?: number;
-}
-
-class Metric {
-  static getScriptUrls(dependencyGraph: Graph.Node, treatNodeAsRenderBlocking?: (node: Graph.NetworkNode) => boolean):
-      Set<string> {
-    const scriptUrls = new Set<string>();
-
-    dependencyGraph.traverse(node => {
-      if (node.type !== Graph.BaseNode.types.NETWORK) {
-        return;
-      }
-      if (node.request.resourceType !== 'Script') {
-        return;
-      }
-      if (treatNodeAsRenderBlocking?.(node)) {
-        scriptUrls.add(node.request.url);
-      }
-    });
-
-    return scriptUrls;
-  }
-
-  static get coefficients(): MetricCoefficients {
-    throw new Core.LanternError('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.
-   */
-  static getScaledCoefficients(_rttMs: number): MetricCoefficients {
-    return this.coefficients;
-  }
-
-  static getOptimisticGraph(_dependencyGraph: Graph.Node, _processedNavigation: Types.Simulation.ProcessedNavigation):
-      Graph.Node {
-    throw new Core.LanternError('Optimistic graph unimplemented!');
-  }
-
-  static getPessimisticGraph(_dependencyGraph: Graph.Node, _processedNavigation: Types.Simulation.ProcessedNavigation):
-      Graph.Node {
-    throw new Core.LanternError('Pessmistic graph unimplemented!');
-  }
-
-  static getEstimateFromSimulation(simulationResult: Simulation.Result, _extras: Extras): Simulation.Result {
-    return simulationResult;
-  }
-
-  static compute(data: MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'>): MetricResult {
-    const {simulator, graph, processedNavigation} = data;
-
-    const metricName = this.name.replace('Lantern', '');
-    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
-    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
-
-    let simulateOptions = {label: `optimistic${metricName}`};
-    const optimisticSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `pessimistic${metricName}`};
-    const pessimisticSimulation = simulator.simulate(pessimisticGraph, simulateOptions);
-
-    const optimisticEstimate = this.getEstimateFromSimulation(
-        optimisticSimulation,
-        {...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,
-    };
-  }
-}
-
-export {Metric};

package/lib/front_end/models/trace/lantern/metrics/SpeedIndex.ts

@@ -1,126 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import * as Graph from '../graph/graph.js';
-import type * as Simulation from '../simulation/simulation.js';
-
-import {
-  type Extras,
-  Metric,
-  type MetricCoefficients,
-  type MetricComputationDataInput,
-  type MetricResult,
-} from './Metric.js';
-
-const mobileSlow4GRtt = 150;
-
-class SpeedIndex extends Metric {
-  static override get coefficients(): MetricCoefficients {
-    return {
-      // Note that the optimistic estimate is based on the real observed speed index rather than a
-      // real lantern graph (and the final estimate will be Math.max(FCP, Speed Index)).
-      intercept: 0,
-      optimistic: 1.4,
-      pessimistic: 0.4,
-    };
-  }
-
-  static override getScaledCoefficients(rttMs: number): MetricCoefficients {
-    // We want to scale our default coefficients based on the speed of the connection.
-    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
-    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
-    //      30 ms was based on a typical home WiFi connection's actual RTT.
-    //      Coefficients here follow from the fact that the optimistic estimate should be very close
-    //      to reality at this connection speed and the pessimistic estimate compensates for minor
-    //      connection speed differences.
-    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
-    //      Coefficients here were determined through thorough analysis and linear regression on the
-    //      lantern test data set. See core/scripts/test-lantern.sh for more detail.
-    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
-    const defaultCoefficients = this.coefficients;
-    const defaultRttExcess = mobileSlow4GRtt - 30;
-    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
-
-    return {
-      intercept: defaultCoefficients.intercept * multiplier,
-      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
-      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
-    };
-  }
-
-  static override getOptimisticGraph(dependencyGraph: Graph.Node): Graph.Node {
-    return dependencyGraph;
-  }
-
-  static override getPessimisticGraph(dependencyGraph: Graph.Node): Graph.Node {
-    return dependencyGraph;
-  }
-
-  static override getEstimateFromSimulation(simulationResult: Simulation.Result, extras: Extras): Simulation.Result {
-    if (!extras.fcpResult) {
-      throw new Core.LanternError('missing fcpResult');
-    }
-    if (extras.observedSpeedIndex === undefined) {
-      throw new Core.LanternError('missing observedSpeedIndex');
-    }
-
-    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
-    const estimate = extras.optimistic ?
-        extras.observedSpeedIndex :
-        SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
-    return {
-      timeInMs: estimate,
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  static override compute(data: MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'>): MetricResult {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Core.LanternError('FCP is required to calculate the SpeedIndex metric');
-    }
-
-    const metricResult = super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-
-  /**
-   * 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
-   * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
-   *
-   * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
-   *
-   * This approach was determined after evaluating the accuracy/complexity tradeoff of many
-   * different methods. Read more in the evaluation doc.
-   *
-   * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-   */
-  static computeLayoutBasedSpeedIndex(nodeTimings: Simulation.Result['nodeTimings'], fcpTimeInMs: number): number {
-    const layoutWeights: Array<{time: number, weight: number}> = [];
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== Graph.BaseNode.types.CPU) {
-        continue;
-      }
-
-      if (node.childEvents.some(x => x.name === 'Layout')) {
-        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
-        layoutWeights.push({time: timing.endTime, weight: timingWeight});
-      }
-    }
-
-    const totalWeightedTime =
-        layoutWeights.map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs)).reduce((a, b) => a + b, 0);
-    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
-
-    if (!totalWeight) {
-      return fcpTimeInMs;
-    }
-    return totalWeightedTime / totalWeight;
-  }
-}
-
-export {SpeedIndex};