lighthouse 11.7.0-dev.20240408 → 11.7.1

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

@@ -1,25 +1,91 @@
 /**
  * @license
- * Copyright 2018 Google LLC
+ * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LargestContentfulPaint} from '../../lib/lantern/metrics/largest-contentful-paint.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {LanternMetric} from './lantern-metric.js';
+import {LighthouseError} from '../../lib/lh-error.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
-class LanternLargestContentfulPaint extends LargestContentfulPaint {
+class LanternLargestContentfulPaint extends LanternMetric {
   /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @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 async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+  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}
+   */
+  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,
+    };
   }
 
   /**
@@ -29,7 +95,9 @@ class LanternLargestContentfulPaint extends LargestContentfulPaint {
    */
   static async compute_(data, context) {
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    return this.computeMetricWithGraphs(data, context, {fcpResult});
+    const metricResult = await this.computeMetricWithGraphs(data, context);
+    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
+    return metricResult;
   }
 }
 

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

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

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

@@ -5,21 +5,63 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {MaxPotentialFID} from '../../lib/lantern/metrics/max-potential-fid.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {LanternMetric} from './lantern-metric.js';
+import {BaseNode} from '../../lib/lantern/base-node.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
-class LanternMaxPotentialFID extends MaxPotentialFID {
+class LanternMaxPotentialFID extends LanternMetric {
   /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @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 async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {import('../../lib/lantern/metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  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,
+    };
   }
 
   /**
@@ -29,7 +71,18 @@ class LanternMaxPotentialFID extends MaxPotentialFID {
    */
   static async compute_(data, context) {
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    return this.computeMetricWithGraphs(data, context, {fcpResult});
+    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);
   }
 }
 

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

@@ -1,10 +1,19 @@
-/**
- * @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;
-}>;
+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';
 //# sourceMappingURL=lantern-metric.d.ts.map

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

@@ -4,24 +4,42 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+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';
 
-/**
- * @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`);
-  }
+/** @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));
+    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};
+    return this.compute({simulator, graph, processedNavigation}, extras);
+  }
+
+  /**
+   * @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);
+  }
 }
 
-export {getComputationDataParams};
+export {LanternMetric};

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

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

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

@@ -5,22 +5,89 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {LanternMetric} from './lantern-metric.js';
+import {BaseNode} from '../../lib/lantern/base-node.js';
 import {Speedline} from '../speedline.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
-import {SpeedIndex} from '../../lib/lantern/metrics/speed-index.js';
+import {throttling as defaultThrottling} from '../../config/constants.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
-class LanternSpeedIndex extends SpeedIndex {
+class LanternSpeedIndex extends LanternMetric {
   /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @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 async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {import('../../lib/lantern/metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  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,
+    };
   }
 
   /**
@@ -29,13 +96,50 @@ class LanternSpeedIndex extends SpeedIndex {
    * @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);
-    return this.computeMetricWithGraphs(data, context, {
+    const metricResult = await 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,25 +1,37 @@
 export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+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/lantern/metric.js').Extras} Extras */
-declare class LanternTotalBlockingTime extends TotalBlockingTime {
+/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+declare class LanternTotalBlockingTime extends LanternMetric {
     /**
-     * @param {LH.Artifacts.MetricComputationDataInput} data
-     * @param {LH.Artifacts.ComputedContext} context
-     * @param {Omit<Extras, 'optimistic'>=} extras
-     * @return {Promise<LH.Artifacts.LanternMetric>}
+     * @param {Node} dependencyGraph
+     * @return {Node}
      */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static getOptimisticGraph(dependencyGraph: Node): Node;
     /**
-     * @param {LH.Artifacts.MetricComputationDataInput} data
-     * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<LH.Artifacts.LanternMetric>}
+     * @param {Node} dependencyGraph
+     * @return {Node}
      */
-    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): 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;
+    }[];
 }
-import { TotalBlockingTime } from '../../lib/lantern/metrics/total-blocking-time.js';
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-total-blocking-time.d.ts.map