lighthouse 11.7.0 → 12.0.0-dev.20240422

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

@@ -5,78 +5,22 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
-import {NetworkRequest} from '../../lib/network-request.js';
 import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
+import {Interactive} from '../../lib/lantern/metrics/interactive.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} 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 LanternInteractive extends 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) {
-    // 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 === NetworkRequest.TYPES.Image;
-      const isScript = node.record.resourceType === NetworkRequest.TYPES.Script;
-      return (
-        !isImage &&
-        (isScript ||
-          node.record.priority === 'High' ||
-          node.record.priority === 'VeryHigh')
-      );
-    });
-  }
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
+class LanternInteractive extends Interactive {
   /**
-   * @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.fmpResult) throw new Error('missing fmpResult');
-
-    const lastTaskAt = LanternInteractive.getLastLongTaskEndTime(simulationResult.nodeTimings);
-    const minimumTime = extras.optimistic
-      ? extras.fmpResult.optimisticEstimate.timeInMs
-      : extras.fmpResult.pessimisticEstimate.timeInMs;
-    return {
-      timeInMs: Math.max(minimumTime, lastTaskAt),
-      nodeTimings: simulationResult.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
@@ -86,23 +30,7 @@ class LanternInteractive extends LanternMetric {
    */
   static async compute_(data, context) {
     const fmpResult = await LanternFirstMeaningfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context, {fmpResult});
-    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);
+    return this.computeMetricWithGraphs(data, context, {fmpResult});
   }
 }
 

package/core/computed/metrics/lantern-largest-contentful-paint.d.ts

@@ -1,37 +1,25 @@
 export { LanternLargestContentfulPaintComputed as LanternLargestContentfulPaint };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternLargestContentfulPaintComputed: typeof LanternLargestContentfulPaint & {
     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 LanternLargestContentfulPaint extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternLargestContentfulPaint extends LargestContentfulPaint {
     /**
-     * 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}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static isNotLowPriorityImageNode(node: Node): boolean;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getOptimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result): LH.Gatherer.Simulation.Result;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { LargestContentfulPaint } from '../../lib/lantern/metrics/largest-contentful-paint.js';
 //# sourceMappingURL=lantern-largest-contentful-paint.d.ts.map

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