lighthouse 11.7.0 → 12.0.0-dev.20240422

package/core/audits/uses-rel-preload.d.ts

@@ -45,11 +45,7 @@ declare class UsesRelPreloadAudit extends Audit {
      * @param {LH.Audit.Context} context
      * @return {Promise<LH.Audit.Product>}
      */
-    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
-    /**
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(): Promise<LH.Audit.Product>;
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
     const title: string;

package/core/audits/uses-rel-preload.js

@@ -143,9 +143,9 @@ class UsesRelPreloadAudit extends Audit {
       return {wastedMs: 0, results: []};
     }
 
-    // Preload changes the ordering of requests, simulate the original graph with flexible ordering
+    // Preload changes the ordering of requests, simulate the original graph
     // to have a reasonable baseline for comparison.
-    const simulationBeforeChanges = simulator.simulate(graph, {flexibleOrdering: true});
+    const simulationBeforeChanges = simulator.simulate(graph);
     const modifiedGraph = graph.cloneWithRelationships();
 
     /** @type {Array<LH.Gatherer.Simulation.GraphNetworkNode>} */
@@ -174,8 +174,8 @@ class UsesRelPreloadAudit extends Audit {
       node.addDependency(mainDocumentNode);
     }
 
-    // Once we've modified the dependencies, simulate the new graph with flexible ordering.
-    const simulationAfterChanges = simulator.simulate(modifiedGraph, {flexibleOrdering: true});
+    // Once we've modified the dependencies, simulate the new graph.
+    const simulationAfterChanges = simulator.simulate(modifiedGraph);
     const originalNodesByRecord = Array.from(simulationBeforeChanges.nodeTimings.keys())
         // @ts-expect-error we don't care if all nodes without a record collect on `undefined`
         .reduce((map, node) => map.set(node.record, node), new Map());
@@ -209,7 +209,7 @@ class UsesRelPreloadAudit extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit_(artifacts, context) {
+  static async audit(artifacts, context) {
     const trace = artifacts.traces[UsesRelPreloadAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreloadAudit.DEFAULT_PASS];
     const URL = artifacts.URL;
@@ -253,16 +253,6 @@ class UsesRelPreloadAudit extends Audit {
       warnings,
     };
   }
-
-  /**
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit() {
-    // Preload advice is on hold until https://github.com/GoogleChrome/lighthouse/issues/11960
-    // is resolved.
-    return {score: 1, notApplicable: true,
-      details: Audit.makeOpportunityDetails([], [], {overallSavingsMs: 0})};
-  }
 }
 
 export default UsesRelPreloadAudit;

package/core/audits/work-during-interaction.d.ts

@@ -32,7 +32,7 @@ declare class WorkDuringInteraction extends Audit {
             startTs: number;
             endTs: number;
         };
-        processingTime: {
+        processingDuration: {
             startTs: number;
             endTs: number;
         };
@@ -72,7 +72,7 @@ export namespace UIStrings {
     const failureTitle: string;
     const description: string;
     const inputDelay: string;
-    const processingTime: string;
+    const processingDuration: string;
     const presentationDelay: string;
     const displayValue: string;
     const eventTarget: string;

package/core/audits/work-during-interaction.js

@@ -30,7 +30,7 @@ const UIStrings = {
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before responding to user input. Ideally fits within a ~40 character limit. */
   inputDelay: 'Input delay',
   /** Label for a column in a data table; entries will be information on the time taken by code processing user input that delays a response to the user. Ideally fits within a ~40 character limit. */
-  processingTime: 'Processing time',
+  processingDuration: 'Processing duration',
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before presenting a response to user input on screen. Ideally fits within a ~40 character limit. */
   presentationDelay: 'Presentation delay',
   /**
@@ -115,7 +115,7 @@ class WorkDuringInteraction extends Audit {
     const endTs = startTs + interactionData.duration * 1000;
     return {
       inputDelay: {startTs, endTs: processingStartTs},
-      processingTime: {startTs: processingStartTs, endTs: processingEndTs},
+      processingDuration: {startTs: processingStartTs, endTs: processingEndTs},
       presentationDelay: {startTs: processingEndTs, endTs},
     };
   }

package/core/computed/js-bundles.d.ts

@@ -1,6 +1,6 @@
 export { JSBundlesComputed as JSBundles };
 declare const JSBundlesComputed: typeof JSBundles & {
-    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../index.js").Artifacts.Bundle[]>;
 };

package/core/computed/metrics/cumulative-layout-shift.js

@@ -163,10 +163,10 @@ class CumulativeLayoutShift {
       await processor.parse(/** @type {import('@paulirish/trace_engine').Types.TraceEvents.TraceEventData[]} */ (
         events
       ));
-      if (!processor.data) {
+      if (!processor.traceParsedData) {
         throw new Error('null trace engine result');
       }
-      return processor.data.LayoutShifts.sessionMaxScore;
+      return processor.traceParsedData.LayoutShifts.sessionMaxScore;
     };
     const cumulativeLayoutShift = await run(allFrameShiftEvents.map(e => e.event));
     const cumulativeLayoutShiftMainFrame = await run(mainFrameShiftEvents.map(e => e.event));

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

@@ -1,94 +1,25 @@
 export { LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
-export type CPUNode = import('../../lib/lantern/cpu-node.js').CPUNode<LH.Artifacts.NetworkRequest>;
-export type NetworkNode = import('../../lib/lantern/network-node.js').NetworkNode<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternFirstContentfulPaintComputed: typeof LanternFirstContentfulPaint & {
     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 */
-/** @typedef {import('../../lib/lantern/cpu-node.js').CPUNode<LH.Artifacts.NetworkRequest>} CPUNode */
-/** @typedef {import('../../lib/lantern/network-node.js').NetworkNode<LH.Artifacts.NetworkRequest>} NetworkNode */
-declare class LanternFirstContentfulPaint extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternFirstContentfulPaint extends FirstContentfulPaint {
     /**
-     * @typedef FirstPaintBasedGraphOpts
-     * @property {number} cutoffTimestamp The timestamp used to filter out tasks that occured after
-     *    our paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
-     * @property {function(NetworkNode):boolean} treatNodeAsRenderBlocking The function that determines
-     *    which resources should be considered *possibly* render-blocking.
-     * @property {(function(CPUNode):boolean)=} additionalCpuNodesToTreatAsRenderBlocking The function that
-     *    determines which CPU nodes should also be included in our blocking node IDs set,
-     *    beyond what getRenderBlockingNodeData() already includes.
+     * @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>;
     /**
-     * This function computes the set of URLs that *appeared* to be render-blocking based on our filter,
-     * *but definitely were not* render-blocking based on the timing of their EvaluateScript task.
-     * It also computes the set of corresponding CPU node ids that were needed for the paint at the
-     * given timestamp.
-     *
-     * @param {Node} graph
-     * @param {FirstPaintBasedGraphOpts} opts
-     * @return {{definitelyNotRenderBlockingScriptUrls: Set<string>, renderBlockingCpuNodeIds: Set<string>}}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getRenderBlockingNodeData(graph: Node, { cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking }: {
-        /**
-         * The timestamp used to filter out tasks that occured after
-         * our paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
-         */
-        cutoffTimestamp: number;
-        /**
-         * The function that determines
-         * which resources should be considered *possibly* render-blocking.
-         */
-        treatNodeAsRenderBlocking: (arg0: NetworkNode) => boolean;
-        /**
-         * The function that
-         * determines which CPU nodes should also be included in our blocking node IDs set,
-         * beyond what getRenderBlockingNodeData() already includes.
-         */
-        additionalCpuNodesToTreatAsRenderBlocking?: ((arg0: CPUNode) => boolean) | undefined;
-    }): {
-        definitelyNotRenderBlockingScriptUrls: Set<string>;
-        renderBlockingCpuNodeIds: Set<string>;
-    };
-    /**
-     * This function computes the graph required for the first paint of interest.
-     *
-     * @param {Node} dependencyGraph
-     * @param {FirstPaintBasedGraphOpts} opts
-     * @return {Node}
-     */
-    static getFirstPaintBasedGraph(dependencyGraph: Node, { cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking }: {
-        /**
-         * The timestamp used to filter out tasks that occured after
-         * our paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
-         */
-        cutoffTimestamp: number;
-        /**
-         * The function that determines
-         * which resources should be considered *possibly* render-blocking.
-         */
-        treatNodeAsRenderBlocking: (arg0: NetworkNode) => boolean;
-        /**
-         * The function that
-         * determines which CPU nodes should also be included in our blocking node IDs set,
-         * beyond what getRenderBlockingNodeData() already includes.
-         */
-        additionalCpuNodesToTreatAsRenderBlocking?: ((arg0: CPUNode) => boolean) | undefined;
-    }): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @return {Node}
-     */
-    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;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { FirstContentfulPaint } from '../../lib/lantern/metrics/first-contentful-paint.js';
 //# sourceMappingURL=lantern-first-contentful-paint.d.ts.map

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

@@ -5,192 +5,30 @@
  */
 
 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 {FirstContentfulPaint} from '../../lib/lantern/metrics/first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-/** @typedef {import('../../lib/lantern/cpu-node.js').CPUNode<LH.Artifacts.NetworkRequest>} CPUNode */
-/** @typedef {import('../../lib/lantern/network-node.js').NetworkNode<LH.Artifacts.NetworkRequest>} NetworkNode */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternFirstContentfulPaint extends LanternMetric {
+class LanternFirstContentfulPaint extends FirstContentfulPaint {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
-   * @typedef FirstPaintBasedGraphOpts
-   * @property {number} cutoffTimestamp The timestamp used to filter out tasks that occured after
-   *    our paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
-   * @property {function(NetworkNode):boolean} treatNodeAsRenderBlocking The function that determines
-   *    which resources should be considered *possibly* render-blocking.
-   * @property {(function(CPUNode):boolean)=} additionalCpuNodesToTreatAsRenderBlocking The function that
-   *    determines which CPU nodes should also be included in our blocking node IDs set,
-   *    beyond what getRenderBlockingNodeData() already includes.
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-
-  /**
-   * This function computes the set of URLs that *appeared* to be render-blocking based on our filter,
-   * *but definitely were not* render-blocking based on the timing of their EvaluateScript task.
-   * It also computes the set of corresponding CPU node ids that were needed for the paint at the
-   * given timestamp.
-   *
-   * @param {Node} graph
-   * @param {FirstPaintBasedGraphOpts} opts
-   * @return {{definitelyNotRenderBlockingScriptUrls: Set<string>, renderBlockingCpuNodeIds: Set<string>}}
-   */
-  static getRenderBlockingNodeData(
-      graph,
-      {cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking}
-  ) {
-    /** @type {Map<string, CPUNode>} A map of blocking script URLs to the earliest EvaluateScript task node that executed them. */
-    const scriptUrlToNodeMap = new Map();
-
-    /** @type {Array<CPUNode>} */
-    const cpuNodes = [];
-    graph.traverse(node => {
-      if (node.type === BaseNode.TYPES.CPU) {
-        // A task is *possibly* render blocking if it *started* before cutoffTimestamp.
-        // We use startTime here because the paint event can be *inside* the task that was render blocking.
-        if (node.startTime <= cutoffTimestamp) cpuNodes.push(node);
-
-        // Build our script URL map to find the earliest EvaluateScript task node.
-        const scriptUrls = node.getEvaluateScriptURLs();
-        for (const url of scriptUrls) {
-          // Use the earliest CPU node we find.
-          const existing = scriptUrlToNodeMap.get(url) || node;
-          scriptUrlToNodeMap.set(url, node.startTime < existing.startTime ? node : existing);
-        }
-      }
-    });
-
-    cpuNodes.sort((a, b) => a.startTime - b.startTime);
-
-    // A script is *possibly* render blocking if it finished loading before cutoffTimestamp.
-    const possiblyRenderBlockingScriptUrls = LanternMetric.getScriptUrls(graph, node => {
-      // The optimistic LCP treatNodeAsRenderBlocking fn wants to exclude some images in the graph,
-      // but here it only receives scripts to evaluate. It's a no-op in this case, but it will
-      // matter below in the getFirstPaintBasedGraph clone operation.
-      return node.endTime <= cutoffTimestamp && treatNodeAsRenderBlocking(node);
-    });
-
-    // A script is *definitely not* render blocking if its EvaluateScript task started after cutoffTimestamp.
-    /** @type {Set<string>} */
-    const definitelyNotRenderBlockingScriptUrls = new Set();
-    /** @type {Set<string>} */
-    const renderBlockingCpuNodeIds = new Set();
-    for (const url of possiblyRenderBlockingScriptUrls) {
-      // Lookup the CPU node that had the earliest EvaluateScript for this URL.
-      const cpuNodeForUrl = scriptUrlToNodeMap.get(url);
-
-      // If we can't find it at all, we can't conclude anything, so just skip it.
-      if (!cpuNodeForUrl) continue;
-
-      // If we found it and it was in our `cpuNodes` set that means it finished before cutoffTimestamp, so it really is render-blocking.
-      if (cpuNodes.includes(cpuNodeForUrl)) {
-        renderBlockingCpuNodeIds.add(cpuNodeForUrl.id);
-        continue;
-      }
-
-      // We couldn't find the evaluate script in the set of CPU nodes that ran before our paint, so
-      // it must not have been necessary for the paint.
-      definitelyNotRenderBlockingScriptUrls.add(url);
-    }
-
-    // The first layout, first paint, and first ParseHTML are almost always necessary for first paint,
-    // so we always include those CPU nodes.
-    const firstLayout = cpuNodes.find(node => node.didPerformLayout());
-    if (firstLayout) renderBlockingCpuNodeIds.add(firstLayout.id);
-    const firstPaint = cpuNodes.find(node => node.childEvents.some(e => e.name === 'Paint'));
-    if (firstPaint) renderBlockingCpuNodeIds.add(firstPaint.id);
-    const firstParse = cpuNodes.find(node => node.childEvents.some(e => e.name === 'ParseHTML'));
-    if (firstParse) renderBlockingCpuNodeIds.add(firstParse.id);
-
-    // If a CPU filter was passed in, we also want to include those extra nodes.
-    if (additionalCpuNodesToTreatAsRenderBlocking) {
-      cpuNodes
-        .filter(additionalCpuNodesToTreatAsRenderBlocking)
-        .forEach(node => renderBlockingCpuNodeIds.add(node.id));
-    }
-
-    return {
-      definitelyNotRenderBlockingScriptUrls,
-      renderBlockingCpuNodeIds,
-    };
-  }
-
-  /**
-   * This function computes the graph required for the first paint of interest.
-   *
-   * @param {Node} dependencyGraph
-   * @param {FirstPaintBasedGraphOpts} opts
-   * @return {Node}
-   */
-  static getFirstPaintBasedGraph(
-      dependencyGraph,
-      {cutoffTimestamp, treatNodeAsRenderBlocking, additionalCpuNodesToTreatAsRenderBlocking}
-  ) {
-    const rbData = this.getRenderBlockingNodeData(dependencyGraph, {
-      cutoffTimestamp,
-      treatNodeAsRenderBlocking,
-      additionalCpuNodesToTreatAsRenderBlocking,
-    });
-    const {definitelyNotRenderBlockingScriptUrls, renderBlockingCpuNodeIds} = rbData;
-
-    return dependencyGraph.cloneWithRelationships(node => {
-      if (node.type === BaseNode.TYPES.NETWORK) {
-        // Exclude all nodes that ended after cutoffTimestamp (except for the main document which we always consider necessary)
-        // endTime is negative if request does not finish, make sure startTime isn't after cutoffTimestamp in this case.
-        const endedAfterPaint = node.endTime > cutoffTimestamp || node.startTime > cutoffTimestamp;
-        if (endedAfterPaint && !node.isMainDocument()) return false;
-
-        const url = node.record.url;
-        // If the URL definitely wasn't render-blocking then we filter it out.
-        if (definitelyNotRenderBlockingScriptUrls.has(url)) {
-          return false;
-        }
-
-        // Lastly, build up the FCP graph of all nodes we consider render blocking
-        return treatNodeAsRenderBlocking(node);
-      } else {
-        // If it's a CPU node, just check if it was blocking.
-        return renderBlockingCpuNodeIds.has(node.id);
-      }
-    });
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    return this.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: processedNavigation.timestamps.firstContentfulPaint,
-      // In the optimistic graph we exclude resources that appeared to be render blocking but were
-      // initiated by a script. While they typically have a very high importance and tend to have a
-      // significant impact on the page's content, these resources don't technically block rendering.
-      treatNodeAsRenderBlocking: node =>
-        node.hasRenderBlockingPriority() && node.initiatorType !== 'script',
-    });
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    return this.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: processedNavigation.timestamps.firstContentfulPaint,
-      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority(),
-    });
+  static async compute_(data, context) {
+    return this.computeMetricWithGraphs(data, context);
   }
 }
 

package/core/computed/metrics/lantern-first-meaningful-paint.d.ts

@@ -1,24 +1,25 @@
 export { LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternFirstMeaningfulPaintComputed: typeof LanternFirstMeaningfulPaint & {
     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 LanternFirstMeaningfulPaint extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternFirstMeaningfulPaint extends FirstMeaningfulPaint {
     /**
-     * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @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, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    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 getPessimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { FirstMeaningfulPaint } from '../../lib/lantern/metrics/first-meaningful-paint.js';
 //# sourceMappingURL=lantern-first-meaningful-paint.d.ts.map

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

@@ -5,60 +5,22 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {LighthouseError} from '../../lib/lh-error.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
+import {FirstMeaningfulPaint} from '../../lib/lantern/metrics/first-meaningful-paint.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 LanternFirstMeaningfulPaint extends LanternMetric {
+class LanternFirstMeaningfulPaint extends FirstMeaningfulPaint {
   /**
-   * @return {LH.Gatherer.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 LanternFirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: fmp,
-      // See LanternFirstContentfulPaint'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}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
-    if (!fmp) {
-      throw new LighthouseError(LighthouseError.errors.NO_FMP);
-    }
-
-    return LanternFirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: fmp,
-      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority(),
-      // For pessimistic FMP we'll include *all* layout nodes
-      additionalCpuNodesToTreatAsRenderBlocking: node => node.didPerformLayout(),
-    });
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -1,33 +1,25 @@
 export { LanternInteractiveComputed as LanternInteractive };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternInteractiveComputed: typeof LanternInteractive & {
     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>;
 };
-import { NetworkRequest } from '../../lib/network-request.js';
-declare class LanternInteractive extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternInteractive extends Interactive {
     /**
-     * @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;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @return {number}
-     */
-    static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { Interactive } from '../../lib/lantern/metrics/interactive.js';
 //# sourceMappingURL=lantern-interactive.d.ts.map