lighthouse 11.7.1 → 12.0.0

package/core/computed/metrics/lantern-largest-contentful-paint.js

@@ -1,91 +1,26 @@
 /**
  * @license
- * Copyright 2019 Google LLC
+ * Copyright 2018 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {LighthouseError} from '../../lib/lh-error.js';
+import {LargestContentfulPaint} from '../../lib/lantern/metrics/largest-contentful-paint.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternLargestContentfulPaint extends LanternMetric {
+class LanternLargestContentfulPaint extends LargestContentfulPaint {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    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.
-   *
-   * @param {Node} node
-   * @return {boolean}
-   */
-  static isNotLowPriorityImageNode(node) {
-    if (node.type !== 'network') return true;
-    const isImage = node.record.resourceType === 'Image';
-    const isLowPriority = node.record.priority === 'Low' || node.record.priority === 'VeryLow';
-    return !isImage || !isLowPriority;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new LighthouseError(LighthouseError.errors.NO_LCP);
-    }
-
-    return LanternFirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: lcp,
-      treatNodeAsRenderBlocking: LanternLargestContentfulPaint.isNotLowPriorityImageNode,
-    });
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new LighthouseError(LighthouseError.errors.NO_LCP);
-    }
-
-    return LanternFirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: lcp,
-      treatNodeAsRenderBlocking: _ => true,
-      // For pessimistic LCP we'll include *all* layout nodes
-      additionalCpuNodesToTreatAsRenderBlocking: node => node.didPerformLayout(),
-    });
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static getEstimateFromSimulation(simulationResult) {
-    const nodeTimesNotOffscreenImages = Array.from(simulationResult.nodeTimings.entries())
-      .filter(entry => LanternLargestContentfulPaint.isNotLowPriorityImageNode(entry[0]))
-      .map(entry => entry[1].endTime);
-
-    return {
-      timeInMs: Math.max(...nodeTimesNotOffscreenImages),
-      nodeTimings: simulationResult.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
@@ -95,9 +30,7 @@ class LanternLargestContentfulPaint extends LanternMetric {
    */
   static async compute_(data, context) {
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context);
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
+    return this.computeMetricWithGraphs(data, context, {fcpResult});
   }
 }
 

package/core/computed/metrics/lantern-max-potential-fid.d.ts

@@ -1,36 +1,25 @@
 export { LanternMaxPotentialFIDComputed as LanternMaxPotentialFID };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternMaxPotentialFIDComputed: typeof LanternMaxPotentialFID & {
     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/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-declare class LanternMaxPotentialFID extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternMaxPotentialFID extends MaxPotentialFID {
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    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} fcpTimeInMs
-     * @return {Array<{duration: number}>}
-     */
-    static getTimingsAfterFCP(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
-        duration: number;
-    }>;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { MaxPotentialFID } from '../../lib/lantern/metrics/max-potential-fid.js';
 //# sourceMappingURL=lantern-max-potential-fid.d.ts.map

package/core/computed/metrics/lantern-max-potential-fid.js

@@ -5,63 +5,22 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
+import {MaxPotentialFID} from '../../lib/lantern/metrics/max-potential-fid.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternMaxPotentialFID extends LanternMetric {
+class LanternMaxPotentialFID extends MaxPotentialFID {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('../../lib/lantern/metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('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 = LanternMaxPotentialFID.getTimingsAfterFCP(
-      simulation.nodeTimings,
-      fcpTimeInMs
-    );
-
-    return {
-      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
-      nodeTimings: simulation.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
@@ -71,18 +30,7 @@ class LanternMaxPotentialFID extends LanternMetric {
    */
   static async compute_(data, context) {
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    return super.computeMetricWithGraphs(data, context, {fcpResult});
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {Array<{duration: number}>}
-   */
-  static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
-    return Array.from(nodeTimings.entries())
-      .filter(([node, timing]) => node.type === BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
-      .map(([_, timing]) => timing);
+    return this.computeMetricWithGraphs(data, context, {fcpResult});
   }
 }
 

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

@@ -1,19 +1,15 @@
-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
-     * @param {Omit<Extras, 'optimistic'>=} extras
-     * @return {Promise<LH.Artifacts.LanternMetric>}
-     */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
-    /**
-     * @param {LH.Artifacts.MetricComputationDataInput} data
-     * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<LH.Artifacts.LanternMetric>}
-     */
-    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
-}
-import { Metric } from '../../lib/lantern/metric.js';
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+export function getComputationDataParams(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+    simulator: import("../../lib/lantern/simulator/simulator.js").Simulator<any>;
+    graph: import("../page-dependency-graph.js").Node;
+    processedNavigation: import("../../index.js").Artifacts.ProcessedNavigation;
+}>;
+/**
+ * @param {unknown} err
+ * @return {never}
+ */
+export function lanternErrorAdapter(err: unknown): never;
 //# sourceMappingURL=lantern-metric.d.ts.map

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

@@ -4,42 +4,46 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {Metric} from '../../lib/lantern/metric.js';
+import {LanternError} from '../../lib/lantern/lantern-error.js';
+import {LighthouseError} from '../../lib/lh-error.js';
 import {LoadSimulator} from '../load-simulator.js';
 import {PageDependencyGraph} from '../page-dependency-graph.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-
-class LanternMetric extends Metric {
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async computeMetricWithGraphs(data, context, extras) {
-    // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
-    const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
-    if (gatherContext.gatherMode !== 'navigation') {
-      throw new Error(`Lantern metrics can only be computed on navigations`);
-    }
-
-    const graph = await PageDependencyGraph.request(data, context);
-    const processedNavigation = await ProcessedNavigation.request(data.trace, context);
-    const simulator = data.simulator || (await LoadSimulator.request(data, context));
-
-    return this.compute({simulator, graph, processedNavigation}, extras);
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+async function getComputationDataParams(data, context) {
+  if (data.gatherContext.gatherMode !== 'navigation') {
+    throw new Error(`Lantern metrics can only be computed on navigations`);
+  }
+
+  const graph = await PageDependencyGraph.request(data, context);
+  const processedNavigation = await ProcessedNavigation.request(data.trace, context);
+  const simulator = data.simulator || (await LoadSimulator.request(data, context));
+
+  return {simulator, graph, processedNavigation};
+}
+
+/**
+ * @param {unknown} err
+ * @return {never}
+ */
+function lanternErrorAdapter(err) {
+  if (!(err instanceof LanternError)) {
+    throw err;
   }
 
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async compute_(data, context) {
-    return this.computeMetricWithGraphs(data, context);
+  const code = /** @type {keyof LighthouseError.errors} */ (err.message);
+  if (LighthouseError.errors[code]) {
+    throw new LighthouseError(LighthouseError.errors[code]);
   }
+
+  throw err;
 }
 
-export {LanternMetric};
+export {
+  getComputationDataParams,
+  lanternErrorAdapter,
+};

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

@@ -1,44 +1,25 @@
 export { LanternSpeedIndexComputed as LanternSpeedIndex };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 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/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-declare class LanternSpeedIndex extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternSpeedIndex extends SpeedIndex {
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    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
-     * 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#
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} fcpTimeInMs
-     * @return {number}
-     */
-    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { SpeedIndex } from '../../lib/lantern/metrics/speed-index.js';
 //# sourceMappingURL=lantern-speed-index.d.ts.map

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

@@ -5,89 +5,23 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {Speedline} from '../speedline.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
-import {throttling as defaultThrottling} from '../../config/constants.js';
+import {SpeedIndex} from '../../lib/lantern/metrics/speed-index.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternSpeedIndex extends LanternMetric {
+class LanternSpeedIndex extends SpeedIndex {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      // Negative intercept is OK because estimate is Math.max(FCP, Speed Index) and
-      // the optimistic estimate is based on the real observed speed index rather than a real
-      // lantern graph.
-      intercept: -250,
-      optimistic: 1.4,
-      pessimistic: 0.65,
-    };
-  }
-
-  /**
-   * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    // We want to scale our default coefficients based on the speed of the connection.
-    // 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 = defaultThrottling.mobileSlow4G.rttMs - 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,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('../../lib/lantern/metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static getEstimateFromSimulation(simulationResult, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.speedline) throw new Error('missing speedline');
-
-    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
-    const estimate = extras.optimistic
-      ? extras.speedline.speedIndex
-      : LanternSpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
-    return {
-      timeInMs: estimate,
-      nodeTimings: simulationResult.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
@@ -96,50 +30,13 @@ class LanternSpeedIndex extends LanternMetric {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async compute_(data, context) {
+    // TODO(15841): lib/lantern should probably run Speedline
     const speedline = await Speedline.request(data.trace, context);
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context, {
+    return this.computeMetricWithGraphs(data, context, {
       speedline,
       fcpResult,
     });
-    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#
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {number}
-   */
-  static computeLayoutBasedSpeedIndex(nodeTimings, fcpTimeInMs) {
-    /** @type {Array<{time: number, weight: number}>} */
-    const layoutWeights = [];
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== 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;
   }
 }
 

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

@@ -1,37 +1,25 @@
 export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 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/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-declare class LanternTotalBlockingTime extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternTotalBlockingTime extends TotalBlockingTime {
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    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
-     */
-    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
-        start: number;
-        end: number;
-        duration: number;
-    }[];
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { TotalBlockingTime } from '../../lib/lantern/metrics/total-blocking-time.js';
 //# sourceMappingURL=lantern-total-blocking-time.d.ts.map