lighthouse 12.0.0-dev.20240605 → 12.0.0-dev.20240607

package/core/audits/metrics/first-meaningful-paint.d.ts

@@ -1,25 +1,9 @@
 export default FirstMeaningfulPaint;
 declare class FirstMeaningfulPaint extends Audit {
     /**
-     * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
-     */
-    static get defaultOptions(): {
-        mobile: {
-            scoring: LH.Audit.ScoreOptions;
-        };
-        desktop: {
-            scoring: LH.Audit.ScoreOptions;
-        };
-    };
-    /**
-     * Audits the page to give a score for First Meaningful Paint.
-     * @see https://github.com/GoogleChrome/lighthouse/issues/26
-     * @see https://docs.google.com/document/d/1BR94tJdZLsin5poeet0XoTW60M0SjvOJQttKT-JK8HI/view
-     * @param {LH.Artifacts} artifacts The artifacts from the gather phase.
-     * @param {LH.Audit.Context} context
      * @return {Promise<LH.Audit.Product>}
      */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    static audit(): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
     const description: string;

package/core/audits/metrics/first-meaningful-paint.js

@@ -4,9 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+// TODO(COMPAT): This is just a shell. Remove in future breaking release.
+
 import {Audit} from '../audit.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {FirstMeaningfulPaint as ComputedFmp} from '../../computed/metrics/first-meaningful-paint.js';
 
 const UIStrings = {
   /** Description of the First Meaningful Paint (FMP) metric, which marks the time at which a majority of the content has been painted by the browser. This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
@@ -32,55 +33,12 @@ class FirstMeaningfulPaint extends Audit {
   }
 
   /**
-   * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
-   */
-  static get defaultOptions() {
-    return {
-      mobile: {
-        // 25th and 5th percentiles HTTPArchive -> median and PODR, then p10 derived from them.
-        // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2018_04_01_mobile?pli=1
-        // see https://www.desmos.com/calculator/i4znkdccut
-        scoring: {
-          p10: 2336,
-          median: 4000,
-        },
-      },
-      desktop: {
-        // SELECT QUANTILES(renderStart, 21) FROM [httparchive:summary_pages.2018_12_15_desktop] LIMIT 1000
-        scoring: {
-          p10: 934,
-          median: 1600,
-        },
-      },
-    };
-  }
-
-  /**
-   * Audits the page to give a score for First Meaningful Paint.
-   * @see https://github.com/GoogleChrome/lighthouse/issues/26
-   * @see https://docs.google.com/document/d/1BR94tJdZLsin5poeet0XoTW60M0SjvOJQttKT-JK8HI/view
-   * @param {LH.Artifacts} artifacts The artifacts from the gather phase.
-   * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit(artifacts, context) {
-    const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {trace, devtoolsLog, gatherContext,
-      settings: context.settings, URL: artifacts.URL};
-    const metricResult = await ComputedFmp.request(metricComputationData, context);
-    const options = context.options[context.settings.formFactor];
-
-
+  static async audit() {
     return {
-      score: Audit.computeLogNormalScore(
-        options.scoring,
-        metricResult.timing
-      ),
-      numericValue: metricResult.timing,
-      numericUnit: 'millisecond',
-      displayValue: str_(i18n.UIStrings.seconds, {timeInMs: metricResult.timing}),
+      score: null,
+      notApplicable: true,
     };
   }
 }

package/core/audits/metrics/interactive.d.ts

@@ -1,7 +1,7 @@
 export default InteractiveMetric;
 /**
  * @fileoverview This audit identifies the time the page is "consistently interactive".
- * Looks for the first period of at least 5 seconds after FMP where both CPU and network were quiet,
+ * Looks for the first period of at least 5 seconds after FCP where both CPU and network were quiet,
  * and returns the timestamp of the beginning of the CPU quiet period.
  * @see https://docs.google.com/document/d/1GGiI9-7KeY3TPqS3YT271upUVimo-XiL5mwWorDUD4c/edit#
  */

package/core/audits/metrics/interactive.js

@@ -18,7 +18,7 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
 /**
  * @fileoverview This audit identifies the time the page is "consistently interactive".
- * Looks for the first period of at least 5 seconds after FMP where both CPU and network were quiet,
+ * Looks for the first period of at least 5 seconds after FCP where both CPU and network were quiet,
  * and returns the timestamp of the beginning of the CPU quiet period.
  * @see https://docs.google.com/document/d/1GGiI9-7KeY3TPqS3YT271upUVimo-XiL5mwWorDUD4c/edit#
  */

package/core/audits/predictive-perf.js

@@ -7,7 +7,6 @@
 import {Audit} from './audit.js';
 import * as i18n from '../lib/i18n/i18n.js';
 import {LanternFirstContentfulPaint} from '../computed/metrics/lantern-first-contentful-paint.js';
-import {LanternFirstMeaningfulPaint} from '../computed/metrics/lantern-first-meaningful-paint.js';
 import {LanternInteractive} from '../computed/metrics/lantern-interactive.js';
 import {LanternSpeedIndex} from '../computed/metrics/lantern-speed-index.js';
 import {LanternLargestContentfulPaint} from '../computed/metrics/lantern-largest-contentful-paint.js';
@@ -52,7 +51,6 @@ class PredictivePerf extends Audit {
     const settings = JSON.parse(JSON.stringify(defaultSettings)); // Use default settings.
     const computationData = {trace, devtoolsLog, gatherContext, settings, URL};
     const fcp = await LanternFirstContentfulPaint.request(computationData, context);
-    const fmp = await LanternFirstMeaningfulPaint.request(computationData, context);
     const tti = await LanternInteractive.request(computationData, context);
     const si = await LanternSpeedIndex.request(computationData, context);
     const lcp = await LanternLargestContentfulPaint.request(computationData, context);
@@ -64,10 +62,6 @@ class PredictivePerf extends Audit {
       optimisticFCP: fcp.optimisticEstimate.timeInMs,
       pessimisticFCP: fcp.pessimisticEstimate.timeInMs,
 
-      roughEstimateOfFMP: fmp.timing,
-      optimisticFMP: fmp.optimisticEstimate.timeInMs,
-      pessimisticFMP: fmp.pessimisticEstimate.timeInMs,
-
       roughEstimateOfTTI: tti.timing,
       optimisticTTI: tti.optimisticEstimate.timeInMs,
       pessimisticTTI: tti.pessimisticEstimate.timeInMs,

package/core/audits/redirects.js

@@ -90,6 +90,7 @@ class Redirects extends Audit {
 
     const processedTrace = await ProcessedTrace.request(trace, context);
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+    const documentRequests = Redirects.getDocumentRequestChain(networkRecords, processedTrace);
 
     const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
     const metricResult = await LanternInteractive.request(metricComputationData, context);
@@ -102,8 +103,6 @@ class Redirects extends Audit {
       }
     }
 
-    const documentRequests = Redirects.getDocumentRequestChain(networkRecords, processedTrace);
-
     let totalWastedMs = 0;
     const tableRows = [];
 

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

@@ -5,7 +5,7 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
+import {LanternLargestContentfulPaint} from './lantern-largest-contentful-paint.js';
 import {Interactive} from '../../lib/lantern/metrics/interactive.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
@@ -29,8 +29,8 @@ class LanternInteractive extends Interactive {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async compute_(data, context) {
-    const fmpResult = await LanternFirstMeaningfulPaint.request(data, context);
-    return this.computeMetricWithGraphs(data, context, {fmpResult});
+    const lcpResult = await LanternLargestContentfulPaint.request(data, context);
+    return this.computeMetricWithGraphs(data, context, {lcpResult});
   }
 }
 

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

@@ -5,7 +5,7 @@
 export function getComputationDataParamsFromTrace(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;
+    processedNavigation: import("../../lib/lantern/types/lantern.js").Simulation.ProcessedNavigation;
 }>;
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
@@ -23,7 +23,7 @@ export function getComputationDataParamsFromDevtoolsLog(data: LH.Artifacts.Metri
 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;
+    processedNavigation: import("../../lib/lantern/types/lantern.js").Simulation.ProcessedNavigation;
 }>;
 /**
  * @param {unknown} err

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

@@ -9,6 +9,8 @@ import {LighthouseError} from '../../lib/lh-error.js';
 import {LoadSimulator} from '../load-simulator.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
 import {PageDependencyGraph} from '../page-dependency-graph.js';
+import {TraceEngineResult} from '../trace-engine-result.js';
+import {createProcessedNavigation} from '../../lib/lantern/lantern.js';
 
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
@@ -36,7 +38,8 @@ async function getComputationDataParamsFromTrace(data, context) {
   }
 
   const graph = await PageDependencyGraph.request({...data, fromTrace: true}, context);
-  const processedNavigation = await ProcessedNavigation.request(data.trace, context);
+  const traceEngineResult = await TraceEngineResult.request(data, context);
+  const processedNavigation = createProcessedNavigation(traceEngineResult);
   const simulator = data.simulator || (await LoadSimulator.request(data, context));
 
   return {simulator, graph, processedNavigation};

package/core/computed/metrics/timing-summary.js

@@ -9,7 +9,6 @@ import {ProcessedNavigation} from '../processed-navigation.js';
 import {Speedline} from '../speedline.js';
 import {FirstContentfulPaint} from './first-contentful-paint.js';
 import {FirstContentfulPaintAllFrames} from './first-contentful-paint-all-frames.js';
-import {FirstMeaningfulPaint} from './first-meaningful-paint.js';
 import {LargestContentfulPaint} from './largest-contentful-paint.js';
 import {LargestContentfulPaintAllFrames} from './largest-contentful-paint-all-frames.js';
 import {Interactive} from './interactive.js';
@@ -51,7 +50,6 @@ class TimingSummary {
     const speedline = await Speedline.request(trace, context);
     const firstContentfulPaint = await requestOrUndefined(FirstContentfulPaint, metricComputationData);
     const firstContentfulPaintAllFrames = await requestOrUndefined(FirstContentfulPaintAllFrames, metricComputationData);
-    const firstMeaningfulPaint = await requestOrUndefined(FirstMeaningfulPaint, metricComputationData);
     const largestContentfulPaint = await requestOrUndefined(LargestContentfulPaint, metricComputationData);
     const largestContentfulPaintAllFrames = await requestOrUndefined(LargestContentfulPaintAllFrames, metricComputationData);
     const interactive = await requestOrUndefined(Interactive, metricComputationData);
@@ -74,8 +72,6 @@ class TimingSummary {
       firstContentfulPaintTs: firstContentfulPaint?.timestamp,
       firstContentfulPaintAllFrames: firstContentfulPaintAllFrames?.timing,
       firstContentfulPaintAllFramesTs: firstContentfulPaintAllFrames?.timestamp,
-      firstMeaningfulPaint: firstMeaningfulPaint?.timing,
-      firstMeaningfulPaintTs: firstMeaningfulPaint?.timestamp,
       largestContentfulPaint: largestContentfulPaint?.timing,
       largestContentfulPaintTs: largestContentfulPaint?.timestamp,
       largestContentfulPaintAllFrames: largestContentfulPaintAllFrames?.timing,
@@ -107,8 +103,6 @@ class TimingSummary {
       observedFirstContentfulPaintTs: processedNavigation?.timestamps.firstContentfulPaint,
       observedFirstContentfulPaintAllFrames: processedNavigation?.timings.firstContentfulPaintAllFrames,
       observedFirstContentfulPaintAllFramesTs: processedNavigation?.timestamps.firstContentfulPaintAllFrames,
-      observedFirstMeaningfulPaint: processedNavigation?.timings.firstMeaningfulPaint,
-      observedFirstMeaningfulPaintTs: processedNavigation?.timestamps.firstMeaningfulPaint,
       observedLargestContentfulPaint: processedNavigation?.timings.largestContentfulPaint,
       observedLargestContentfulPaintTs: processedNavigation?.timestamps.largestContentfulPaint,
       observedLargestContentfulPaintAllFrames: processedNavigation?.timings.largestContentfulPaintAllFrames,

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

@@ -1,8 +1,13 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
+export type MetricName = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName;
+export type MetricScore = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore;
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName} MetricName */
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore} MetricScore */
 /** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 export const NetworkRequestTypes: LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
+/**
+ * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+ * @return {Lantern.Simulation.ProcessedNavigation}
+ */
+export function createProcessedNavigation(traceEngineResult: LH.Artifacts.TraceEngineResult): Lantern.Simulation.ProcessedNavigation;
+import * as Lantern from './types/lantern.js';
 //# sourceMappingURL=lantern.d.ts.map

package/core/lib/lantern/lantern.js

@@ -4,6 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from './types/lantern.js';
+
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName} MetricName */
+/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore} MetricScore */
+
 /** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 const NetworkRequestTypes = {
   XHR: 'XHR',
@@ -26,6 +31,48 @@ const NetworkRequestTypes = {
   Prefetch: 'Prefetch',
 };
 
+/**
+ * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+ * @return {Lantern.Simulation.ProcessedNavigation}
+ */
+function createProcessedNavigation(traceEngineResult) {
+  const Meta = traceEngineResult.data.Meta;
+  const frameId = Meta.mainFrameId;
+  const scoresByNav = traceEngineResult.data.PageLoadMetrics.metricScoresByFrameId.get(frameId);
+  if (!scoresByNav) {
+    throw new Error('missing metric scores for main frame');
+  }
+
+  const lastNavigationId = Meta.mainFrameNavigations.at(-1)?.args.data?.navigationId;
+  const scores = lastNavigationId && scoresByNav.get(lastNavigationId);
+  if (!scores) {
+    throw new Error('missing metric scores for specified navigation');
+  }
+
+  /** @param {MetricName} metric */
+  const getTimestampOrUndefined = metric => {
+    const metricScore = scores.get(metric);
+    if (!metricScore?.event) return;
+    return metricScore.event.ts;
+  };
+  /** @param {MetricName} metric */
+  const getTimestamp = metric => {
+    const metricScore = scores.get(metric);
+    if (!metricScore?.event) throw new Error(`missing metric: ${metric}`);
+    return metricScore.event.ts;
+  };
+  // TODO: should use `MetricName.LCP`, but it is a const enum.
+  const FCP = /** @type {MetricName} */('FCP');
+  const LCP = /** @type {MetricName} */('LCP');
+  return {
+    timestamps: {
+      firstContentfulPaint: getTimestamp(FCP),
+      largestContentfulPaint: getTimestampOrUndefined(LCP),
+    },
+  };
+}
+
 export {
   NetworkRequestTypes,
+  createProcessedNavigation,
 };

package/core/lib/lantern/metric.d.ts

@@ -4,7 +4,7 @@ export type Simulator = import('./simulator/simulator.js').Simulator;
 export type Extras = {
     optimistic: boolean;
     fcpResult?: LH.Artifacts.LanternMetric | undefined;
-    fmpResult?: LH.Artifacts.LanternMetric | undefined;
+    lcpResult?: LH.Artifacts.LanternMetric | undefined;
     interactiveResult?: LH.Artifacts.LanternMetric | undefined;
     speedline?: {
         speedIndex: number;
@@ -17,7 +17,7 @@ export type Extras = {
  * @typedef Extras
  * @property {boolean} optimistic
  * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} fmpResult
+ * @property {LH.Artifacts.LanternMetric=} lcpResult
  * @property {LH.Artifacts.LanternMetric=} interactiveResult
  * @property {{speedIndex: number}=} speedline
  */
@@ -44,16 +44,16 @@ export class Metric {
     static getScaledCoefficients(rttMs: number): Lantern.Simulation.MetricCoefficients;
     /**
      * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
      * @return {Node}
      */
-    static getOptimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    static getOptimisticGraph(dependencyGraph: Node, processedNavigation: Lantern.Simulation.ProcessedNavigation): Node;
     /**
      * @param {Node} dependencyGraph
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
      * @return {Node}
      */
-    static getPessimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    static getPessimisticGraph(dependencyGraph: Node, processedNavigation: Lantern.Simulation.ProcessedNavigation): Node;
     /**
      * @param {Lantern.Simulation.Result} simulationResult
      * @param {Extras} extras

package/core/lib/lantern/metric.js

@@ -16,7 +16,7 @@ import {RESOURCE_TYPES} from '../../lib/network-request.js';
  * @typedef Extras
  * @property {boolean} optimistic
  * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} fmpResult
+ * @property {LH.Artifacts.LanternMetric=} lcpResult
  * @property {LH.Artifacts.LanternMetric=} interactiveResult
  * @property {{speedIndex: number}=} speedline
  */
@@ -64,7 +64,7 @@ class Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
@@ -73,7 +73,7 @@ class Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars

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

@@ -170,7 +170,7 @@ class FirstContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getOptimisticGraph(dependencyGraph, processedNavigation) {
@@ -186,7 +186,7 @@ class FirstContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getPessimisticGraph(dependencyGraph, processedNavigation) {

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

@@ -66,12 +66,12 @@ class Interactive extends Metric {
    * @return {LH.Gatherer.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
-    if (!extras.fmpResult) throw new Error('missing fmpResult');
+    if (!extras.lcpResult) throw new Error('missing lcpResult');
 
     const lastTaskAt = Interactive.getLastLongTaskEndTime(simulationResult.nodeTimings);
     const minimumTime = extras.optimistic
-      ? extras.fmpResult.optimisticEstimate.timeInMs
-      : extras.fmpResult.pessimisticEstimate.timeInMs;
+      ? extras.lcpResult.optimisticEstimate.timeInMs
+      : extras.lcpResult.pessimisticEstimate.timeInMs;
     return {
       timeInMs: Math.max(minimumTime, lastTaskAt),
       nodeTimings: simulationResult.nodeTimings,
@@ -84,13 +84,13 @@ class Interactive extends Metric {
    * @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 lcpResult = extras?.lcpResult;
+    if (!lcpResult) {
+      throw new Error('LCP is required to calculate the Interactive metric');
     }
 
     const metricResult = await super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, fmpResult.timing);
+    metricResult.timing = Math.max(metricResult.timing, lcpResult.timing);
     return metricResult;
   }
 

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

@@ -39,7 +39,7 @@ class LargestContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getOptimisticGraph(dependencyGraph, processedNavigation) {
@@ -56,7 +56,7 @@ class LargestContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getPessimisticGraph(dependencyGraph, processedNavigation) {

package/core/lib/lantern/types/lantern.d.ts

@@ -169,9 +169,16 @@ export namespace Simulation {
         nodeTimings: Map<GraphNode<T>, NodeTiming>;
     }
 
+    interface ProcessedNavigation {
+        timestamps: {
+            firstContentfulPaint: number;
+            largestContentfulPaint?: number;
+        };
+    }
+
     interface MetricComputationDataInput {
         simulator: Simulator<any>;
         graph: GraphNode<any>;
-        processedNavigation: LH.Artifacts.ProcessedNavigation;
+        processedNavigation: ProcessedNavigation;
     }
 }

package/core/lib/tracehouse/trace-processor.d.ts

@@ -281,11 +281,9 @@ export class TraceProcessor {
         timeOriginEvt: import("../..").TraceEvent;
         firstPaintEvt: import("../..").TraceEvent | undefined;
         firstContentfulPaintEvt: import("../..").TraceEvent;
-        firstMeaningfulPaintEvt: import("../..").TraceEvent | undefined;
         largestContentfulPaintEvt: LCPEvent | undefined;
         loadEvt: import("../..").TraceEvent | undefined;
         domContentLoadedEvt: import("../..").TraceEvent | undefined;
-        fmpFellBack: boolean;
         lcpInvalidated: boolean;
     };
 }

package/core/lib/tracehouse/trace-processor.js

@@ -9,7 +9,7 @@
  * various tools. This artifact will take a trace and then:
  *
  * 1. Find the TracingStartedInPage and navigationStart events of our intended tab & frame.
- * 2. Find the firstContentfulPaint and marked firstMeaningfulPaint events
+ * 2. Find the firstContentfulPaint and marked largestContentfulPaint events
  * 3. Isolate only the trace events from the tab's process (including all threads like compositor)
  *      * Sort those trace events in chronological order (as order isn't guaranteed)
  * 4. Return all those items in one handy bundle.
@@ -835,7 +835,6 @@ class TraceProcessor {
         firstPaint: frameTimings.timings.firstPaint,
         firstContentfulPaint: frameTimings.timings.firstContentfulPaint,
         firstContentfulPaintAllFrames: getTiming(fcpAllFramesEvt.ts),
-        firstMeaningfulPaint: frameTimings.timings.firstMeaningfulPaint,
         largestContentfulPaint: frameTimings.timings.largestContentfulPaint,
         largestContentfulPaintAllFrames: maybeGetTiming(lcpAllFramesEvt?.ts),
         load: frameTimings.timings.load,
@@ -847,7 +846,6 @@ class TraceProcessor {
         firstPaint: frameTimings.timestamps.firstPaint,
         firstContentfulPaint: frameTimings.timestamps.firstContentfulPaint,
         firstContentfulPaintAllFrames: fcpAllFramesEvt.ts,
-        firstMeaningfulPaint: frameTimings.timestamps.firstMeaningfulPaint,
         largestContentfulPaint: frameTimings.timestamps.largestContentfulPaint,
         largestContentfulPaintAllFrames: lcpAllFramesEvt?.ts,
         load: frameTimings.timestamps.load,
@@ -857,12 +855,10 @@ class TraceProcessor {
       firstPaintEvt: frameTimings.firstPaintEvt,
       firstContentfulPaintEvt: frameTimings.firstContentfulPaintEvt,
       firstContentfulPaintAllFramesEvt: fcpAllFramesEvt,
-      firstMeaningfulPaintEvt: frameTimings.firstMeaningfulPaintEvt,
       largestContentfulPaintEvt: frameTimings.largestContentfulPaintEvt,
       largestContentfulPaintAllFramesEvt: lcpAllFramesEvt,
       loadEvt: frameTimings.loadEvt,
       domContentLoadedEvt: frameTimings.domContentLoadedEvt,
-      fmpFellBack: frameTimings.fmpFellBack,
       lcpInvalidated: frameTimings.lcpInvalidated,
     };
   }
@@ -970,28 +966,6 @@ class TraceProcessor {
       throw this.createNoFirstContentfulPaintError();
     }
 
-    // fMP will follow at/after the FP
-    let firstMeaningfulPaint = frameEvents.find(
-      e => e.name === 'firstMeaningfulPaint' && e.ts > timeOriginEvt.ts
-    );
-    let fmpFellBack = false;
-
-    // If there was no firstMeaningfulPaint event found in the trace, the network idle detection
-    // may have not been triggered before Lighthouse finished tracing.
-    // In this case, we'll use the last firstMeaningfulPaintCandidate we can find.
-    // However, if no candidates were found (a bogus trace, likely), we fail.
-    if (!firstMeaningfulPaint) {
-      const fmpCand = 'firstMeaningfulPaintCandidate';
-      fmpFellBack = true;
-      log.verbose('TraceProcessor',
-        `No firstMeaningfulPaint found, falling back to last ${fmpCand}`);
-      const lastCandidate = frameEvents.filter(e => e.name === fmpCand).pop();
-      if (!lastCandidate) {
-        log.verbose('TraceProcessor', 'No `firstMeaningfulPaintCandidate` events found in trace');
-      }
-      firstMeaningfulPaint = lastCandidate;
-    }
-
     // This function accepts events spanning multiple frames, but this usage will only provide events from the main frame.
     const lcpResult = this.computeValidLCPAllFrames(frameEvents, timeOriginEvt);
 
@@ -1007,7 +981,6 @@ class TraceProcessor {
       timeOrigin: timeOriginEvt.ts,
       firstPaint: getTimestamp(firstPaint),
       firstContentfulPaint: firstContentfulPaint.ts,
-      firstMeaningfulPaint: getTimestamp(firstMeaningfulPaint),
       largestContentfulPaint: getTimestamp(lcpResult.lcp),
       load: getTimestamp(load),
       domContentLoaded: getTimestamp(domContentLoaded),
@@ -1022,7 +995,6 @@ class TraceProcessor {
       timeOrigin: 0,
       firstPaint: maybeGetTiming(timestamps.firstPaint),
       firstContentfulPaint: getTiming(timestamps.firstContentfulPaint),
-      firstMeaningfulPaint: maybeGetTiming(timestamps.firstMeaningfulPaint),
       largestContentfulPaint: maybeGetTiming(timestamps.largestContentfulPaint),
       load: maybeGetTiming(timestamps.load),
       domContentLoaded: maybeGetTiming(timestamps.domContentLoaded),
@@ -1034,11 +1006,9 @@ class TraceProcessor {
       timeOriginEvt: timeOriginEvt,
       firstPaintEvt: firstPaint,
       firstContentfulPaintEvt: firstContentfulPaint,
-      firstMeaningfulPaintEvt: firstMeaningfulPaint,
       largestContentfulPaintEvt: lcpResult.lcp,
       loadEvt: load,
       domContentLoadedEvt: domContentLoaded,
-      fmpFellBack,
       lcpInvalidated: lcpResult.invalidated,
     };
   }

package/core/lib/traces/metric-trace-events.js

@@ -45,11 +45,6 @@ class MetricTraceEvents {
         id: 'ttfcp',
         tsKey: 'observedFirstContentfulPaintTs',
       },
-      {
-        name: 'First Meaningful Paint',
-        id: 'ttfmp',
-        tsKey: 'observedFirstMeaningfulPaintTs',
-      },
       {
         name: 'Speed Index',
         id: 'si',