lighthouse 11.7.0-dev.20240326 → 11.7.0-dev.20240328

package/core/lib/lantern/metrics/first-meaningful-paint.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+// TODO(15841): don't use LighthouseError
+import {LighthouseError} from '../../lh-error.js';
+import {FirstContentfulPaint} from './first-contentful-paint.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class FirstMeaningfulPaint extends Metric {
+  /**
+   * @return {Lantern.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      intercept: 0,
+      optimistic: 0.5,
+      pessimistic: 0.5,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph, processedNavigation) {
+    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
+    if (!fmp) {
+      throw new LighthouseError(LighthouseError.errors.NO_FMP);
+    }
+    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+      cutoffTimestamp: fmp,
+      // See FirstContentfulPaint's getOptimisticGraph implementation for a longer description
+      // of why we exclude script initiated resources here.
+      treatNodeAsRenderBlocking: node =>
+        node.hasRenderBlockingPriority() && node.initiatorType !== 'script',
+    });
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph, processedNavigation) {
+    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
+    if (!fmp) {
+      throw new LighthouseError(LighthouseError.errors.NO_FMP);
+    }
+
+    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+      cutoffTimestamp: fmp,
+      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority(),
+      // For pessimistic FMP we'll include *all* layout nodes
+      additionalCpuNodesToTreatAsRenderBlocking: node => node.didPerformLayout(),
+    });
+  }
+}
+
+export {FirstMeaningfulPaint};

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

@@ -0,0 +1,26 @@
+export type Node = import('../base-node.js').Node;
+export class Interactive extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
+    /**
+     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @return {number}
+     */
+    static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
+}
+import { Metric } from '../metric.js';
+//# sourceMappingURL=interactive.d.ts.map

package/core/lib/lantern/metrics/interactive.js

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+import {NetworkRequestTypes} from '../lantern.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+// 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 {
+  /**
+   * @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) {
+    // 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 === BaseNode.TYPES.CPU) {
+        return node.event.dur > minimumCpuTaskDuration;
+      }
+
+      // Include all scripts and high priority requests, exclude all images
+      const isImage = node.record.resourceType === NetworkRequestTypes.Image;
+      const isScript = node.record.resourceType === NetworkRequestTypes.Script;
+      return (
+        !isImage &&
+        (isScript ||
+          node.record.priority === 'High' ||
+          node.record.priority === 'VeryHigh')
+      );
+    });
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {import('../metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulationResult, extras) {
+    if (!extras.fmpResult) throw new Error('missing fmpResult');
+
+    const lastTaskAt = Interactive.getLastLongTaskEndTime(simulationResult.nodeTimings);
+    const minimumTime = extras.optimistic
+      ? extras.fmpResult.optimisticEstimate.timeInMs
+      : extras.fmpResult.pessimisticEstimate.timeInMs;
+    return {
+      timeInMs: Math.max(minimumTime, lastTaskAt),
+      nodeTimings: simulationResult.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const fmpResult = extras?.fmpResult;
+    if (!fmpResult) {
+      throw new Error('FMP is required to calculate the Interactive metric');
+    }
+
+    const metricResult = await super.compute(data, extras);
+    metricResult.timing = Math.max(metricResult.timing, fmpResult.timing);
+    return metricResult;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @return {number}
+   */
+  static getLastLongTaskEndTime(nodeTimings, duration = 50) {
+    return Array.from(nodeTimings.entries())
+      .filter(([node, timing]) => {
+        if (node.type !== 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/core/lib/lantern/metrics/largest-contentful-paint.d.ts

@@ -0,0 +1,19 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class LargestContentfulPaint extends Metric {
+    /**
+     * 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: Node): boolean;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result): LH.Gatherer.Simulation.Result;
+}
+import { Metric } from '../metric.js';
+//# sourceMappingURL=largest-contentful-paint.d.ts.map

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

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {LighthouseError} from '../../../lib/lh-error.js';
+import {FirstContentfulPaint} from './first-contentful-paint.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class LargestContentfulPaint extends Metric {
+  /**
+   * @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 FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+      cutoffTimestamp: lcp,
+      treatNodeAsRenderBlocking: LargestContentfulPaint.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 FirstContentfulPaint.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 => LargestContentfulPaint.isNotLowPriorityImageNode(entry[0]))
+      .map(entry => entry[1].endTime);
+
+    return {
+      timeInMs: Math.max(...nodeTimesNotOffscreenImages),
+      nodeTimings: simulationResult.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the LCP metric');
+    }
+
+    const metricResult = await super.compute(data, extras);
+    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
+    return metricResult;
+  }
+}
+
+export {LargestContentfulPaint};

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

@@ -0,0 +1,30 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class MaxPotentialFID extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulation
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../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 { Metric } from '../metric.js';
+//# sourceMappingURL=max-potential-fid.d.ts.map

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

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class MaxPotentialFID extends Metric {
+  /**
+   * @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('../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 = MaxPotentialFID.getTimingsAfterFCP(
+      simulation.nodeTimings,
+      fcpTimeInMs
+    );
+
+    return {
+      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
+      nodeTimings: simulation.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the Max Potential FID metric');
+    }
+
+    return super.compute(data, extras);
+  }
+
+  /**
+   * @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);
+  }
+}
+
+export {MaxPotentialFID};

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

@@ -0,0 +1,38 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class SpeedIndex extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../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 { Metric } from '../metric.js';
+//# sourceMappingURL=speed-index.d.ts.map

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

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+// TODO(15841): move this default config value into lib/lantern
+import {throttling as defaultThrottling} from '../../../config/constants.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class SpeedIndex extends Metric {
+  /**
+   * @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('../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
+      : SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
+    return {
+      timeInMs: estimate,
+      nodeTimings: simulationResult.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the SpeedIndex metric');
+    }
+
+    const metricResult = await 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#
+   * @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;
+  }
+}
+
+export {SpeedIndex};

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

@@ -0,0 +1,31 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class TotalBlockingTime extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulation
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../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 { Metric } from '../metric.js';
+//# sourceMappingURL=total-blocking-time.d.ts.map