lighthouse 9.6.7 → 10.0.0-dev.20230209

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

@@ -0,0 +1,15 @@
+export { FirstMeaningfulPaintComputed as FirstMeaningfulPaint };
+declare const FirstMeaningfulPaintComputed: typeof FirstMeaningfulPaint & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class FirstMeaningfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=first-meaningful-paint.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {NavigationMetric} from './navigation-metric.js';
+import {LighthouseError} from '../../lib/lh-error.js';
+import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
+
+class FirstMeaningfulPaint extends NavigationMetric {
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static computeSimulatedMetric(data, context) {
+    const metricData = NavigationMetric.getMetricComputationInput(data);
+    return LanternFirstMeaningfulPaint.request(metricData, context);
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeObservedMetric(data) {
+    const {processedNavigation} = data;
+    if (processedNavigation.timings.firstMeaningfulPaint === undefined) {
+      throw new LighthouseError(LighthouseError.errors.NO_FMP);
+    }
+
+    return {
+      timing: processedNavigation.timings.firstMeaningfulPaint,
+      timestamp: processedNavigation.timestamps.firstMeaningfulPaint,
+    };
+  }
+}
+
+const FirstMeaningfulPaintComputed = makeComputedArtifact(
+  FirstMeaningfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {FirstMeaningfulPaintComputed as FirstMeaningfulPaint};

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

@@ -0,0 +1,61 @@
+export { InteractiveComputed as Interactive };
+export type TimePeriod = {
+    start: number;
+    end: number;
+};
+declare const InteractiveComputed: typeof Interactive & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+/**
+ * @fileoverview Computes "Time To Interactive", the time at which the page has loaded critical
+ * resources and is mostly idle.
+ * @see https://docs.google.com/document/d/1yE4YWsusi5wVXrnwhR61j-QyjK9tzENIzfxrCjA1NAk/edit#heading=h.yozfsuqcgpc4
+ */
+declare class Interactive extends NavigationMetric {
+    /**
+     * Finds all time periods where the number of inflight requests is less than or equal to the
+     * number of allowed concurrent requests (2).
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {{timestamps: {traceEnd: number}}} processedNavigation
+     * @return {Array<TimePeriod>}
+     */
+    static _findNetworkQuietPeriods(networkRecords: Array<LH.Artifacts.NetworkRequest>, processedNavigation: {
+        timestamps: {
+            traceEnd: number;
+        };
+    }): Array<TimePeriod>;
+    /**
+     * Finds all time periods where there are no long tasks.
+     * @param {Array<TimePeriod>} longTasks
+     * @param {{timestamps: {timeOrigin: number, traceEnd: number}}} processedNavigation
+     * @return {Array<TimePeriod>}
+     */
+    static _findCPUQuietPeriods(longTasks: Array<TimePeriod>, processedNavigation: {
+        timestamps: {
+            timeOrigin: number;
+            traceEnd: number;
+        };
+    }): Array<TimePeriod>;
+    /**
+     * Finds the first time period where a network quiet period and a CPU quiet period overlap.
+     * @param {Array<TimePeriod>} longTasks
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @return {{cpuQuietPeriod: TimePeriod, networkQuietPeriod: TimePeriod, cpuQuietPeriods: Array<TimePeriod>, networkQuietPeriods: Array<TimePeriod>}}
+     */
+    static findOverlappingQuietPeriods(longTasks: Array<TimePeriod>, networkRecords: Array<LH.Artifacts.NetworkRequest>, processedNavigation: LH.Artifacts.ProcessedNavigation): {
+        cpuQuietPeriod: TimePeriod;
+        networkQuietPeriod: TimePeriod;
+        cpuQuietPeriods: Array<TimePeriod>;
+        networkQuietPeriods: Array<TimePeriod>;
+    };
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=interactive.d.ts.map

package/core/computed/metrics/interactive.js

@@ -0,0 +1,192 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {NavigationMetric} from './navigation-metric.js';
+import {LanternInteractive} from './lantern-interactive.js';
+import {NetworkMonitor} from '../../gather/driver/network-monitor.js';
+import {TraceProcessor} from '../../lib/tracehouse/trace-processor.js';
+import {LighthouseError} from '../../lib/lh-error.js';
+
+const REQUIRED_QUIET_WINDOW = 5000;
+const ALLOWED_CONCURRENT_REQUESTS = 2;
+
+/**
+ * @fileoverview Computes "Time To Interactive", the time at which the page has loaded critical
+ * resources and is mostly idle.
+ * @see https://docs.google.com/document/d/1yE4YWsusi5wVXrnwhR61j-QyjK9tzENIzfxrCjA1NAk/edit#heading=h.yozfsuqcgpc4
+ */
+class Interactive extends NavigationMetric {
+  /**
+   * Finds all time periods where the number of inflight requests is less than or equal to the
+   * number of allowed concurrent requests (2).
+   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {{timestamps: {traceEnd: number}}} processedNavigation
+   * @return {Array<TimePeriod>}
+   */
+  static _findNetworkQuietPeriods(networkRecords, processedNavigation) {
+    const traceEndTsInMs = processedNavigation.timestamps.traceEnd / 1000;
+    // Ignore records that failed, never finished, or were POST/PUT/etc.
+    const filteredNetworkRecords = networkRecords.filter(record => {
+      return record.finished && record.requestMethod === 'GET' && !record.failed &&
+          // Consider network records that had 4xx/5xx status code as "failed"
+          record.statusCode < 400;
+    });
+    return NetworkMonitor.findNetworkQuietPeriods(filteredNetworkRecords,
+      ALLOWED_CONCURRENT_REQUESTS, traceEndTsInMs);
+  }
+
+  /**
+   * Finds all time periods where there are no long tasks.
+   * @param {Array<TimePeriod>} longTasks
+   * @param {{timestamps: {timeOrigin: number, traceEnd: number}}} processedNavigation
+   * @return {Array<TimePeriod>}
+   */
+  static _findCPUQuietPeriods(longTasks, processedNavigation) {
+    const timeOriginTsInMs = processedNavigation.timestamps.timeOrigin / 1000;
+    const traceEndTsInMs = processedNavigation.timestamps.traceEnd / 1000;
+    if (longTasks.length === 0) {
+      return [{start: 0, end: traceEndTsInMs}];
+    }
+
+    /** @type {Array<TimePeriod>} */
+    const quietPeriods = [];
+    longTasks.forEach((task, index) => {
+      if (index === 0) {
+        quietPeriods.push({
+          start: 0,
+          end: task.start + timeOriginTsInMs,
+        });
+      }
+
+      if (index === longTasks.length - 1) {
+        quietPeriods.push({
+          start: task.end + timeOriginTsInMs,
+          end: traceEndTsInMs,
+        });
+      } else {
+        quietPeriods.push({
+          start: task.end + timeOriginTsInMs,
+          end: longTasks[index + 1].start + timeOriginTsInMs,
+        });
+      }
+    });
+
+    return quietPeriods;
+  }
+
+  /**
+   * Finds the first time period where a network quiet period and a CPU quiet period overlap.
+   * @param {Array<TimePeriod>} longTasks
+   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {{cpuQuietPeriod: TimePeriod, networkQuietPeriod: TimePeriod, cpuQuietPeriods: Array<TimePeriod>, networkQuietPeriods: Array<TimePeriod>}}
+   */
+  static findOverlappingQuietPeriods(longTasks, networkRecords, processedNavigation) {
+    const FcpTsInMs = processedNavigation.timestamps.firstContentfulPaint / 1000;
+
+    /** @type {function(TimePeriod):boolean} */
+    const isLongEnoughQuietPeriod = period =>
+        period.end > FcpTsInMs + REQUIRED_QUIET_WINDOW &&
+        period.end - period.start >= REQUIRED_QUIET_WINDOW;
+    const networkQuietPeriods = this._findNetworkQuietPeriods(networkRecords, processedNavigation)
+        .filter(isLongEnoughQuietPeriod);
+    const cpuQuietPeriods = this._findCPUQuietPeriods(longTasks, processedNavigation)
+        .filter(isLongEnoughQuietPeriod);
+
+    const cpuQueue = cpuQuietPeriods.slice();
+    const networkQueue = networkQuietPeriods.slice();
+
+    // We will check for a CPU quiet period contained within a Network quiet period or vice-versa
+    let cpuCandidate = cpuQueue.shift();
+    let networkCandidate = networkQueue.shift();
+    while (cpuCandidate && networkCandidate) {
+      if (cpuCandidate.start >= networkCandidate.start) {
+        // CPU starts later than network, window must be contained by network or we check the next
+        if (networkCandidate.end >= cpuCandidate.start + REQUIRED_QUIET_WINDOW) {
+          return {
+            cpuQuietPeriod: cpuCandidate,
+            networkQuietPeriod: networkCandidate,
+            cpuQuietPeriods,
+            networkQuietPeriods,
+          };
+        } else {
+          networkCandidate = networkQueue.shift();
+        }
+      } else {
+        // Network starts later than CPU, window must be contained by CPU or we check the next
+        if (cpuCandidate.end >= networkCandidate.start + REQUIRED_QUIET_WINDOW) {
+          return {
+            cpuQuietPeriod: cpuCandidate,
+            networkQuietPeriod: networkCandidate,
+            cpuQuietPeriods,
+            networkQuietPeriods,
+          };
+        } else {
+          cpuCandidate = cpuQueue.shift();
+        }
+      }
+    }
+
+    throw new LighthouseError(
+      cpuCandidate
+        ? LighthouseError.errors.NO_TTI_NETWORK_IDLE_PERIOD
+        : LighthouseError.errors.NO_TTI_CPU_IDLE_PERIOD
+    );
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static computeSimulatedMetric(data, context) {
+    const metricData = NavigationMetric.getMetricComputationInput(data);
+    return LanternInteractive.request(metricData, context);
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static computeObservedMetric(data) {
+    const {processedTrace, processedNavigation, networkRecords} = data;
+
+    if (!processedNavigation.timestamps.domContentLoaded) {
+      throw new LighthouseError(LighthouseError.errors.NO_DCL);
+    }
+
+    const longTasks = TraceProcessor.getMainThreadTopLevelEvents(processedTrace)
+        .filter(event => event.duration >= 50);
+    const quietPeriodInfo = Interactive.findOverlappingQuietPeriods(
+      longTasks,
+      networkRecords,
+      processedNavigation
+    );
+
+    const cpuQuietPeriod = quietPeriodInfo.cpuQuietPeriod;
+
+    const timestamp = Math.max(
+      cpuQuietPeriod.start,
+      processedNavigation.timestamps.firstContentfulPaint / 1000,
+      processedNavigation.timestamps.domContentLoaded / 1000
+    ) * 1000;
+    const timing = (timestamp - processedNavigation.timestamps.timeOrigin) / 1000;
+    return Promise.resolve({timing, timestamp});
+  }
+}
+
+const InteractiveComputed = makeComputedArtifact(
+  Interactive,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {InteractiveComputed as Interactive};
+
+/**
+ * @typedef TimePeriod
+ * @property {number} start
+ * @property {number} end
+ */

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

@@ -0,0 +1,48 @@
+export { LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type CPUNode = import('../../lib/dependency-graph/cpu-node').CPUNode;
+export type NetworkNode = import('../../lib/dependency-graph/network-node').NetworkNode;
+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/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/dependency-graph/cpu-node').CPUNode} CPUNode */
+/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
+declare class LanternFirstContentfulPaint extends 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 {number} filterTimestamp The timestamp used to filter out tasks that occured after our
+     *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+     * @param {function(NetworkNode):boolean} blockingScriptFilter The function that determines which scripts
+     *    should be considered *possibly* render-blocking.
+     * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+     *    should also be included in our blocking node IDs set.
+     * @return {{definitelyNotRenderBlockingScriptUrls: Set<string>, blockingCpuNodeIds: Set<string>}}
+     */
+    static getBlockingNodeData(graph: Node, filterTimestamp: number, blockingScriptFilter: (arg0: NetworkNode) => boolean, extraBlockingCpuNodesToIncludeFilter?: ((arg0: CPUNode) => boolean) | undefined): {
+        definitelyNotRenderBlockingScriptUrls: Set<string>;
+        blockingCpuNodeIds: Set<string>;
+    };
+    /**
+     * This function computes the graph required for the first paint of interest.
+     *
+     * @param {Node} dependencyGraph
+     * @param {number} paintTs The timestamp used to filter out tasks that occured after our
+     *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+     * @param {function(NetworkNode):boolean} blockingResourcesFilter The function that determines which resources
+     *    should be considered *possibly* render-blocking.
+     * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+     *    should also be included in our blocking node IDs set.
+     * @return {Node}
+     */
+    static getFirstPaintBasedGraph(dependencyGraph: Node, paintTs: number, blockingResourcesFilter: (arg0: NetworkNode) => boolean, extraBlockingCpuNodesToIncludeFilter?: ((arg0: CPUNode) => boolean) | undefined): Node;
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-first-contentful-paint.d.ts.map

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

@@ -0,0 +1,204 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {LanternMetric} from './lantern-metric.js';
+import {BaseNode} from '../../lib/dependency-graph/base-node.js';
+
+/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/dependency-graph/cpu-node').CPUNode} CPUNode */
+/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
+
+class LanternFirstContentfulPaint extends LanternMetric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      intercept: 0,
+      optimistic: 0.5,
+      pessimistic: 0.5,
+    };
+  }
+
+  /**
+   * 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 {number} filterTimestamp The timestamp used to filter out tasks that occured after our
+   *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+   * @param {function(NetworkNode):boolean} blockingScriptFilter The function that determines which scripts
+   *    should be considered *possibly* render-blocking.
+   * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+   *    should also be included in our blocking node IDs set.
+   * @return {{definitelyNotRenderBlockingScriptUrls: Set<string>, blockingCpuNodeIds: Set<string>}}
+   */
+  static getBlockingNodeData(
+      graph,
+      filterTimestamp,
+      blockingScriptFilter,
+      extraBlockingCpuNodesToIncludeFilter
+  ) {
+    /** @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 filterTimestamp.
+        // We use startTime here because the paint event can be *inside* the task that was render blocking.
+        if (node.startTime <= filterTimestamp) 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 filterTimestamp.
+    const possiblyRenderBlockingScriptUrls = LanternMetric.getScriptUrls(graph, node => {
+      return node.endTime <= filterTimestamp && blockingScriptFilter(node);
+    });
+
+    // A script is *definitely not* render blocking if its EvaluateScript task started after filterTimestamp.
+    /** @type {Set<string>} */
+    const definitelyNotRenderBlockingScriptUrls = new Set();
+    /** @type {Set<string>} */
+    const blockingCpuNodeIds = 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 filterTimestamp, so it really is render-blocking.
+      if (cpuNodes.includes(cpuNodeForUrl)) {
+        blockingCpuNodeIds.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) blockingCpuNodeIds.add(firstLayout.id);
+    const firstPaint = cpuNodes.find(node => node.childEvents.some(e => e.name === 'Paint'));
+    if (firstPaint) blockingCpuNodeIds.add(firstPaint.id);
+    const firstParse = cpuNodes.find(node => node.childEvents.some(e => e.name === 'ParseHTML'));
+    if (firstParse) blockingCpuNodeIds.add(firstParse.id);
+
+    // If a CPU filter was passed in, we also want to include those extra nodes.
+    if (extraBlockingCpuNodesToIncludeFilter) {
+      cpuNodes
+        .filter(extraBlockingCpuNodesToIncludeFilter)
+        .forEach(node => blockingCpuNodeIds.add(node.id));
+    }
+
+    return {
+      definitelyNotRenderBlockingScriptUrls,
+      blockingCpuNodeIds,
+    };
+  }
+
+  /**
+   * This function computes the graph required for the first paint of interest.
+   *
+   * @param {Node} dependencyGraph
+   * @param {number} paintTs The timestamp used to filter out tasks that occured after our
+   *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+   * @param {function(NetworkNode):boolean} blockingResourcesFilter The function that determines which resources
+   *    should be considered *possibly* render-blocking.
+   * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+   *    should also be included in our blocking node IDs set.
+   * @return {Node}
+   */
+  static getFirstPaintBasedGraph(
+      dependencyGraph,
+      paintTs,
+      blockingResourcesFilter,
+      extraBlockingCpuNodesToIncludeFilter
+  ) {
+    const {
+      definitelyNotRenderBlockingScriptUrls,
+      blockingCpuNodeIds,
+    } = this.getBlockingNodeData(
+      dependencyGraph,
+      paintTs,
+      blockingResourcesFilter,
+      extraBlockingCpuNodesToIncludeFilter
+    );
+
+    return dependencyGraph.cloneWithRelationships(node => {
+      if (node.type === BaseNode.TYPES.NETWORK) {
+        // Exclude all nodes that ended after paintTs (except for the main document which we always consider necessary)
+        // endTime is negative if request does not finish, make sure startTime isn't after paintTs in this case.
+        const endedAfterPaint = node.endTime > paintTs || node.startTime > paintTs;
+        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;
+        }
+
+        return blockingResourcesFilter(node);
+      } else {
+        // If it's a CPU node, just check if it was blocking.
+        return blockingCpuNodeIds.has(node.id);
+      }
+    });
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph, processedNavigation) {
+    return this.getFirstPaintBasedGraph(
+      dependencyGraph,
+      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.
+      node => node.hasRenderBlockingPriority() && node.initiatorType !== 'script'
+    );
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph, processedNavigation) {
+    return this.getFirstPaintBasedGraph(
+      dependencyGraph,
+      processedNavigation.timestamps.firstContentfulPaint,
+      node => node.hasRenderBlockingPriority()
+    );
+  }
+}
+
+const LanternFirstContentfulPaintComputed = makeComputedArtifact(
+  LanternFirstContentfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint};

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

@@ -0,0 +1,12 @@
+export { LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+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/dependency-graph/base-node.js').Node} Node */
+declare class LanternFirstMeaningfulPaint extends LanternMetric {
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-first-meaningful-paint.d.ts.map

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

@@ -0,0 +1,83 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {LanternMetric} from './lantern-metric.js';
+import {LighthouseError} from '../../lib/lh-error.js';
+import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
+
+/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+
+class LanternFirstMeaningfulPaint extends LanternMetric {
+  /**
+   * @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,
+      fmp,
+      // See LanternFirstContentfulPaint's getOptimisticGraph implementation for a longer description
+      // of why we exclude script initiated resources here.
+      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 LanternFirstContentfulPaint.getFirstPaintBasedGraph(
+      dependencyGraph,
+      fmp,
+      node => node.hasRenderBlockingPriority(),
+      // For pessimistic FMP we'll include *all* layout nodes
+      node => node.didPerformLayout()
+    );
+  }
+
+  /**
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.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;
+  }
+}
+
+const LanternFirstMeaningfulPaintComputed = makeComputedArtifact(
+  LanternFirstMeaningfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint};