lighthouse 9.6.7 → 10.0.0

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

@@ -1,111 +0,0 @@
-/**
- * @license Copyright 2019 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 LanternLargestContentfulPaint extends LanternMetric {
-  /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * Low priority image nodes are usually offscreen and very unlikely to be the
-   * resource that is required for LCP. Our LCP graphs include everything except for these images.
-   *
-   * @param {Node} node
-   * @return {boolean}
-   */
-  static isNotLowPriorityImageNode(node) {
-    if (node.type !== 'network') return true;
-
-    const isImage = node.record.resourceType === 'Image';
-    const isLowPriority = node.record.priority === 'Low' || node.record.priority === 'VeryLow';
-    return !isImage || !isLowPriority;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new LHError(LHError.errors.NO_LCP);
-    }
-
-    return LanternFirstContentfulPaint.getFirstPaintBasedGraph(
-      dependencyGraph,
-      lcp,
-      LanternLargestContentfulPaint.isNotLowPriorityImageNode
-    );
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
-    if (!lcp) {
-      throw new LHError(LHError.errors.NO_LCP);
-    }
-
-    return LanternFirstContentfulPaint.getFirstPaintBasedGraph(
-      dependencyGraph,
-      lcp,
-      _ => true,
-      // For pessimistic LCP we'll include *all* layout nodes
-      node => node.didPerformLayout()
-    );
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult) {
-    const nodeTimesNotOffscreenImages = Array.from(simulationResult.nodeTimings.entries())
-      .filter(entry => LanternLargestContentfulPaint.isNotLowPriorityImageNode(entry[0]))
-      .map(entry => entry[1].endTime);
-
-    return {
-      timeInMs: Math.max(...nodeTimesNotOffscreenImages),
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  /**
-   * @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(
-  LanternLargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/lantern-max-potential-fid.js

@@ -1,93 +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 LanternMetricArtifact = require('./lantern-metric.js');
-const BaseNode = require('../../lib/dependency-graph/base-node.js');
-const LanternFirstContentfulPaint = require('./lantern-first-contentful-paint.js');
-
-/** @typedef {BaseNode.Node} Node */
-
-class LanternMaxPotentialFID extends LanternMetricArtifact {
-  /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('./lantern-metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-
-    // Intentionally use the opposite FCP estimate, a more pessimistic FCP means that more tasks
-    // are excluded from the FID computation, so a higher FCP means lower FID for same work.
-    const fcpTimeInMs = extras.optimistic
-      ? extras.fcpResult.pessimisticEstimate.timeInMs
-      : extras.fcpResult.optimisticEstimate.timeInMs;
-
-    const timings = LanternMaxPotentialFID.getTimingsAfterFCP(
-      simulation.nodeTimings,
-      fcpTimeInMs
-    );
-
-    return {
-      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
-      nodeTimings: simulation.nodeTimings,
-    };
-  }
-
-  /**
-   * @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);
-    return super.computeMetricWithGraphs(data, context, {fcpResult});
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {Array<{duration: number}>}
-   */
-  static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
-    return Array.from(nodeTimings.entries())
-      .filter(([node, timing]) => node.type === BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
-      .map(([_, timing]) => timing);
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternMaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

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

@@ -1,167 +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 BaseNode = require('../../lib/dependency-graph/base-node.js');
-const NetworkRequest = require('../../lib/network-request.js');
-const ProcessedTrace = require('../processed-trace.js');
-const ProcessedNavigation = require('../processed-navigation.js');
-const PageDependencyGraph = require('../page-dependency-graph.js');
-const LoadSimulator = require('../load-simulator.js');
-
-/** @typedef {BaseNode.Node} Node */
-/** @typedef {import('../../lib/dependency-graph/network-node')} NetworkNode */
-/** @typedef {import('../../lib/dependency-graph/simulator/simulator')} Simulator */
-
-/**
- * @typedef Extras
- * @property {boolean} optimistic
- * @property {LH.Artifacts.LanternMetric=} fcpResult
- * @property {LH.Artifacts.LanternMetric=} fmpResult
- * @property {LH.Artifacts.LanternMetric=} interactiveResult
- * @property {{speedIndex: number}=} speedline
- */
-
-class LanternMetricArtifact {
-  /**
-   * @param {Node} dependencyGraph
-   * @param {function(NetworkNode):boolean=} condition
-   * @return {Set<string>}
-   */
-  static getScriptUrls(dependencyGraph, condition) {
-    /** @type {Set<string>} */
-    const scriptUrls = new Set();
-
-    dependencyGraph.traverse(node => {
-      if (node.type === BaseNode.TYPES.CPU) return;
-      if (node.record.resourceType !== NetworkRequest.TYPES.Script) return;
-      if (condition && !condition(node)) return;
-      scriptUrls.add(node.record.url);
-    });
-
-    return scriptUrls;
-  }
-
-  /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    throw new Error('COEFFICIENTS unimplemented!');
-  }
-
-  /**
-   * Returns the coefficients, scaled by the throttling settings if needed by the metric.
-   * Some lantern metrics (speed-index) use components in their estimate that are not
-   * from the simulator. In this case, we need to adjust the coefficients as the target throttling
-   * settings change.
-   *
-   * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    return this.COEFFICIENTS;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Optimistic graph unimplemented!');
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Pessmistic graph unimplemented!');
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult, extras) { // eslint-disable-line no-unused-vars
-    return simulationResult;
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async computeMetricWithGraphs(data, context, extras) {
-    // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
-    const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
-    const {trace, devtoolsLog, settings} = data;
-    if (gatherContext.gatherMode !== 'navigation') {
-      throw new Error(`Lantern metrics can only be computed on navigations`);
-    }
-
-    const metricName = this.name.replace('Lantern', '');
-    const graph = await PageDependencyGraph.request({trace, devtoolsLog}, context);
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-    const simulator = data.simulator ||
-        (await LoadSimulator.request({devtoolsLog, settings}, context));
-
-    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
-    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
-
-    /** @type {{flexibleOrdering?: boolean, label?: string}} */
-    let simulateOptions = {label: `optimistic${metricName}`};
-    const optimisticSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `optimisticFlex${metricName}`, flexibleOrdering: true};
-    const optimisticFlexSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `pessimistic${metricName}`};
-    const pessimisticSimulation = simulator.simulate(pessimisticGraph, simulateOptions);
-
-    const optimisticEstimate = this.getEstimateFromSimulation(
-      optimisticSimulation.timeInMs < optimisticFlexSimulation.timeInMs ?
-        optimisticSimulation : optimisticFlexSimulation, {...extras, optimistic: true}
-    );
-
-    const pessimisticEstimate = this.getEstimateFromSimulation(
-      pessimisticSimulation,
-      {...extras, optimistic: false}
-    );
-
-    const coefficients = this.getScaledCoefficients(simulator.rtt);
-    // Estimates under 1s don't really follow the normal curve fit, minimize the impact of the intercept
-    const interceptMultiplier = coefficients.intercept > 0 ?
-      Math.min(1, optimisticEstimate.timeInMs / 1000) : 1;
-    const timing =
-      coefficients.intercept * interceptMultiplier +
-      coefficients.optimistic * optimisticEstimate.timeInMs +
-      coefficients.pessimistic * pessimisticEstimate.timeInMs;
-
-    return {
-      timing,
-      optimisticEstimate,
-      pessimisticEstimate,
-      optimisticGraph,
-      pessimisticGraph,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async compute_(data, context) {
-    return this.computeMetricWithGraphs(data, context);
-  }
-}
-
-module.exports = LanternMetricArtifact;

package/lighthouse-core/computed/metrics/lantern-speed-index.js

@@ -1,150 +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 Speedline = require('../speedline.js');
-const LanternFirstContentfulPaint = require('./lantern-first-contentful-paint.js');
-const defaultThrottling = require('../../config/constants.js').throttling;
-
-/** @typedef {BaseNode.Node} Node */
-
-class LanternSpeedIndex extends LanternMetric {
-  /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      // Negative intercept is OK because estimate is Math.max(FCP, Speed Index) and
-      // the optimistic estimate is based on the real observed speed index rather than a real
-      // lantern graph.
-      intercept: -250,
-      optimistic: 1.4,
-      pessimistic: 0.65,
-    };
-  }
-
-  /**
-   * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    // We want to scale our default coefficients based on the speed of the connection.
-    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
-    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
-    //      30 ms was based on a typical home WiFi connection's actual RTT.
-    //      Coefficients here follow from the fact that the optimistic estimate should be very close
-    //      to reality at this connection speed and the pessimistic estimate compensates for minor
-    //      connection speed differences.
-    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
-    //      Coefficients here were determined through thorough analysis and linear regression on the
-    //      lantern test data set. See lighthouse-core/scripts/test-lantern.sh for more detail.
-    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
-    const defaultCoefficients = this.COEFFICIENTS;
-    const defaultRttExcess = defaultThrottling.mobileSlow4G.rttMs - 30;
-    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
-
-    return {
-      intercept: defaultCoefficients.intercept * multiplier,
-      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
-      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('./lantern-metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.speedline) throw new Error('missing speedline');
-
-    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
-    const estimate = extras.optimistic
-      ? extras.speedline.speedIndex
-      : LanternSpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
-    return {
-      timeInMs: estimate,
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async compute_(data, context) {
-    const speedline = await Speedline.request(data.trace, context);
-    const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context, {
-      speedline,
-      fcpResult,
-    });
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-
-  /**
-   * Approximate speed index using layout events from the simulated node timings.
-   * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
-   * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
-   *
-   * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
-   *
-   * This approach was determined after evaluating the accuracy/complexity tradeoff of many
-   * different methods. Read more in the evaluation doc.
-   *
-   * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {number}
-   */
-  static computeLayoutBasedSpeedIndex(nodeTimings, fcpTimeInMs) {
-    /** @type {Array<{time: number, weight: number}>} */
-    const layoutWeights = [];
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
-
-      if (node.childEvents.some(x => x.name === 'Layout')) {
-        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
-        layoutWeights.push({time: timing.endTime, weight: timingWeight});
-      }
-    }
-
-    const totalWeightedTime = layoutWeights
-      .map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs))
-      .reduce((a, b) => a + b, 0);
-    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
-
-    if (!totalWeight) return fcpTimeInMs;
-    return totalWeightedTime / totalWeight;
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternSpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/lantern-total-blocking-time.js

@@ -1,126 +0,0 @@
-/**
- * @license Copyright 2019 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 LanternFirstContentfulPaint = require('./lantern-first-contentful-paint.js');
-const LanternInteractive = require('./lantern-interactive.js');
-const {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} = require('./tbt-utils.js');
-
-/** @typedef {BaseNode.Node} Node */
-
-class LanternTotalBlockingTime 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) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('./lantern-metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.interactiveResult) throw new Error('missing interactiveResult');
-
-    // Intentionally use the opposite FCP estimate. A pessimistic FCP is higher than equal to an
-    // optimistic FCP, which means potentially more tasks are excluded from the Total Blocking Time
-    // computation. So a more pessimistic FCP gives a more optimistic Total Blocking Time for the
-    // same work.
-    const fcpTimeInMs = extras.optimistic
-      ? extras.fcpResult.pessimisticEstimate.timeInMs
-      : extras.fcpResult.optimisticEstimate.timeInMs;
-
-    // Similarly, we always have pessimistic TTI >= optimistic TTI. Therefore, picking optimistic
-    // TTI means our window of interest is smaller and thus potentially more tasks are excluded from
-    // Total Blocking Time computation, yielding a lower (more optimistic) Total Blocking Time value
-    // for the same work.
-    const interactiveTimeMs = extras.optimistic
-      ? extras.interactiveResult.optimisticEstimate.timeInMs
-      : extras.interactiveResult.pessimisticEstimate.timeInMs;
-
-    const minDurationMs = BLOCKING_TIME_THRESHOLD;
-
-    const events = LanternTotalBlockingTime.getTopLevelEvents(
-      simulation.nodeTimings,
-      minDurationMs
-    );
-
-    return {
-      timeInMs: calculateSumOfBlockingTime(
-        events,
-        fcpTimeInMs,
-        interactiveTimeMs
-      ),
-      nodeTimings: simulation.nodeTimings,
-    };
-  }
-
-  /**
-   * @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 interactiveResult = await LanternInteractive.request(data, context);
-    return this.computeMetricWithGraphs(data, context, {fcpResult, interactiveResult});
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} minDurationMs
-   */
-  static getTopLevelEvents(nodeTimings, minDurationMs) {
-    /** @type {Array<{start: number, end: number, duration: number}>}
-     */
-    const events = [];
-
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
-      // Filtering out events below minimum duration.
-      if (timing.duration < minDurationMs) continue;
-
-      events.push({
-        start: timing.startTime,
-        end: timing.endTime,
-        duration: timing.duration,
-      });
-    }
-
-    return events;
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LanternTotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);