lighthouse 9.6.8 → 10.0.0-dev.20230209

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

@@ -1,193 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
-const LanternInteractive = require('./lantern-interactive.js');
-
-const NetworkMonitor = require('../../gather/driver/network-monitor.js');
-const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
-const LHError = require('../../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 LHError(
-      cpuCandidate
-        ? LHError.errors.NO_TTI_NETWORK_IDLE_PERIOD
-        : LHError.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 LHError(LHError.errors.NO_DCL);
-    }
-
-    const longTasks = TracingProcessor.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});
-  }
-}
-
-module.exports = makeComputedArtifact(
-  Interactive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);
-
-/**
- * @typedef TimePeriod
- * @property {number} start
- * @property {number} end
- */

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

@@ -1,204 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const LanternMetric = require('./lantern-metric.js');
-const BaseNode = require('../../lib/dependency-graph/base-node.js');
-
-/** @typedef {BaseNode.Node} Node */
-/** @typedef {import('../../lib/dependency-graph/cpu-node')} CPUNode */
-/** @typedef {import('../../lib/dependency-graph/network-node')} 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()
-    );
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternFirstContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

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

@@ -1,83 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const LanternMetric = require('./lantern-metric.js');
-const LHError = require('../../lib/lh-error.js');
-const LanternFirstContentfulPaint = require('./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 LHError(LHError.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 LHError(LHError.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;
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternFirstMeaningfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

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

@@ -1,113 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const LanternMetric = require('./lantern-metric.js');
-const BaseNode = require('../../lib/dependency-graph/base-node.js');
-const NetworkRequest = require('../../lib/network-request.js');
-const LanternFirstMeaningfulPaint = require('./lantern-first-meaningful-paint.js');
-
-/** @typedef {BaseNode.Node} Node */
-
-// Any CPU task of 20 ms or more will end up being a critical long task on mobile
-const CRITICAL_LONG_TASK_THRESHOLD = 20;
-
-class 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')
-      );
-    });
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('./lantern-metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  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,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.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);
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternInteractive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);