lighthouse 9.1.0 → 9.2.0

package/lighthouse-cli/test/smokehouse/core-tests.js

@@ -0,0 +1,124 @@
+/**
+ * @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';
+
+import a11y from './test-definitions/a11y.js';
+import byteEfficiency from './test-definitions/byte-efficiency.js';
+import byteGzip from './test-definitions/byte-gzip.js';
+import cspAllowAll from './test-definitions/csp-allow-all.js';
+import cspBlockAll from './test-definitions/csp-block-all.js';
+import cspBlockAllM91 from './test-definitions/csp-block-all-m91.js';
+import dbw from './test-definitions/dobetterweb.js';
+import errorsExpiredSsl from './test-definitions/errors-expired-ssl.js';
+import errorsIframeExpiredSsl from './test-definitions/errors-iframe-expired-ssl.js';
+import errorsInfiniteLoop from './test-definitions/errors-infinite-loop.js';
+// import formsAutoComplete from './test-definitions/forms-autocomplete.js';
+import issuesMixedContent from './test-definitions/issues-mixed-content.js';
+import lanternFetch from './test-definitions/lantern-fetch.js';
+import lanternIdleCallbackLong from './test-definitions/lantern-idle-callback-long.js';
+import lanternIdleCallbackShort from './test-definitions/lantern-idle-callback-short.js';
+import lanternOnline from './test-definitions/lantern-online.js';
+import lanternSetTimeout from './test-definitions/lantern-set-timeout.js';
+import lanternXhr from './test-definitions/lantern-xhr.js';
+import legacyJavascript from './test-definitions/legacy-javascript.js';
+import metricsDebugger from './test-definitions/metrics-debugger.js';
+import metricsDelayedFcp from './test-definitions/metrics-delayed-fcp.js';
+import metricsDelayedLcp from './test-definitions/metrics-delayed-lcp.js';
+import metricsTrickyTti from './test-definitions/metrics-tricky-tti.js';
+import metricsTrickyTtiLateFcp from './test-definitions/metrics-tricky-tti-late-fcp.js';
+import offlineOnlineOnly from './test-definitions/offline-online-only.js';
+import offlineReady from './test-definitions/offline-ready.js';
+import offlineSwBroken from './test-definitions/offline-sw-broken.js';
+import offlineSwSlow from './test-definitions/offline-sw-slow.js';
+import oopifRequests from './test-definitions/oopif-requests.js';
+import perfBudgets from './test-definitions/perf-budgets.js';
+import perfDebug from './test-definitions/perf-debug.js';
+import perfDiagnosticsAnimations from './test-definitions/perf-diagnostics-animations.js';
+import perfDiagnosticsThirdParty from './test-definitions/perf-diagnostics-third-party.js';
+import perfDiagnosticsUnsizedImages from './test-definitions/perf-diagnostics-unsized-images.js';
+import perfFonts from './test-definitions/perf-fonts.js';
+import perfFrameMetrics from './test-definitions/perf-frame-metrics.js';
+import perfPreload from './test-definitions/perf-preload.js';
+import perfTraceElements from './test-definitions/perf-trace-elements.js';
+import pubads from './test-definitions/pubads.js';
+import pwaAirhorner from './test-definitions/pwa-airhorner.js';
+import pwaCaltrain from './test-definitions/pwa-caltrain.js';
+import pwaChromestatus from './test-definitions/pwa-chromestatus.js';
+import pwaRocks from './test-definitions/pwa-rocks.js';
+import pwaSvgomg from './test-definitions/pwa-svgomg.js';
+import redirectsClientPaintServer from './test-definitions/redirects-client-paint-server.js';
+import redirectsHistoryPushState from './test-definitions/redirects-history-push-state.js';
+import redirectsMultipleServer from './test-definitions/redirects-multiple-server.js';
+import redirectsSingleClient from './test-definitions/redirects-single-client.js';
+import redirectsSingleServer from './test-definitions/redirects-single-server.js';
+import screenshot from './test-definitions/screenshot.js';
+import seoFailing from './test-definitions/seo-failing.js';
+import seoPassing from './test-definitions/seo-passing.js';
+import seoStatus403 from './test-definitions/seo-status-403.js';
+import seoTapTargets from './test-definitions/seo-tap-targets.js';
+import sourceMaps from './test-definitions/source-maps.js';
+
+/** @type {ReadonlyArray<Smokehouse.TestDfn>} */
+const smokeTests = [
+  a11y,
+  byteEfficiency,
+  byteGzip,
+  cspAllowAll,
+  cspBlockAll,
+  cspBlockAllM91,
+  dbw,
+  errorsExpiredSsl,
+  errorsIframeExpiredSsl,
+  errorsInfiniteLoop,
+  // TODO: restore when --enable-features=AutofillShowTypePredictions is not needed.
+  // formsAutoComplete,
+  issuesMixedContent,
+  lanternOnline,
+  lanternSetTimeout,
+  lanternFetch,
+  lanternXhr,
+  lanternIdleCallbackShort,
+  lanternIdleCallbackLong,
+  legacyJavascript,
+  metricsDebugger,
+  metricsDelayedFcp,
+  metricsDelayedLcp,
+  metricsTrickyTtiLateFcp,
+  metricsTrickyTti,
+  offlineOnlineOnly,
+  offlineReady,
+  offlineSwBroken,
+  offlineSwSlow,
+  oopifRequests,
+  perfBudgets,
+  perfDebug,
+  perfDiagnosticsAnimations,
+  perfDiagnosticsThirdParty,
+  perfDiagnosticsUnsizedImages,
+  perfFonts,
+  perfFrameMetrics,
+  perfPreload,
+  perfTraceElements,
+  pubads,
+  pwaAirhorner,
+  pwaChromestatus,
+  pwaSvgomg,
+  pwaCaltrain,
+  pwaRocks,
+  redirectsClientPaintServer,
+  redirectsHistoryPushState,
+  redirectsMultipleServer,
+  redirectsSingleClient,
+  redirectsSingleServer,
+  screenshot,
+  seoFailing,
+  seoPassing,
+  seoStatus403,
+  seoTapTargets,
+  sourceMaps,
+];
+
+export default smokeTests;

package/lighthouse-cli/test/smokehouse/frontends/lib.js

@@ -15,14 +15,14 @@
 
 import cloneDeep from 'lodash.clonedeep';
 
-import smokeTests from '../test-definitions/core-tests.js';
-import {runSmokehouse} from '../smokehouse.js';
+import smokeTests from '../core-tests.js';
+import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 
 /**
  * @param {Smokehouse.SmokehouseLibOptions} options
  */
 async function smokehouse(options) {
-  const {urlFilterRegex, skip, modify, ...smokehouseOptions} = options;
+  const {urlFilterRegex, skip, modify, shardArg, ...smokehouseOptions} = options;
 
   const clonedTests = cloneDeep(smokeTests);
   const modifiedTests = [];
@@ -41,7 +41,9 @@ async function smokehouse(options) {
     modifiedTests.push(test);
   }
 
-  return runSmokehouse(modifiedTests, smokehouseOptions);
+  const shardedTests = getShardedDefinitions(modifiedTests, shardArg);
+
+  return runSmokehouse(shardedTests, smokehouseOptions);
 }
 
 export {smokehouse};

package/lighthouse-cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -13,7 +13,6 @@
 
 /* eslint-disable no-console */
 
-import {strict as assert} from 'assert';
 import path from 'path';
 import fs from 'fs';
 import url from 'url';
@@ -23,12 +22,12 @@ import yargs from 'yargs';
 import * as yargsHelpers from 'yargs/helpers';
 import log from 'lighthouse-logger';
 
-import {runSmokehouse} from '../smokehouse.js';
+import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../root.js';
 
 const coreTestDefnsPath =
-  path.join(LH_ROOT, 'lighthouse-cli/test/smokehouse/test-definitions/core-tests.js');
+  path.join(LH_ROOT, 'lighthouse-cli/test/smokehouse/core-tests.js');
 
 /**
  * Possible Lighthouse runners. Loaded dynamically so e.g. a CLI run isn't
@@ -80,52 +79,6 @@ function getDefinitionsToRun(allTestDefns, requestedIds, {invertMatch}) {
   return smokes;
 }
 
-/**
- * Parses the cli `shardArg` flag into `shardNumber/shardTotal`. Splits
- * `testDefns` into `shardTotal` shards and returns the `shardNumber`th shard.
- * Shards will differ in size by at most 1.
- * Shard params must be 1 ≤ shardNumber ≤ shardTotal.
- * @param {Array<Smokehouse.TestDfn>} testDefns
- * @param {string=} shardArg
- * @return {Array<Smokehouse.TestDfn>}
- */
-function getShardedDefinitions(testDefns, shardArg) {
-  if (!shardArg) return testDefns;
-
-  // eslint-disable-next-line max-len
-  const errorMessage = `'shard' must be of the form 'n/d' and n and d must be positive integers with 1 ≤ n ≤ d. Got '${shardArg}'`;
-  const match = /^(?<shardNumber>\d+)\/(?<shardTotal>\d+)$/.exec(shardArg);
-  assert(match && match.groups, errorMessage);
-  const shardNumber = Number(match.groups.shardNumber);
-  const shardTotal = Number(match.groups.shardTotal);
-  assert(shardNumber > 0 && Number.isInteger(shardNumber), errorMessage);
-  assert(shardTotal > 0 && Number.isInteger(shardTotal));
-  assert(shardNumber <= shardTotal, errorMessage);
-
-  // Array is sharded with `Math.ceil(length / shardTotal)` shards first
-  // and then the remaining `Math.floor(length / shardTotal) shards.
-  // e.g. `[0, 1, 2, 3]` split into 3 shards is `[[0, 1], [2], [3]]`.
-  const baseSize = Math.floor(testDefns.length / shardTotal);
-  const biggerSize = baseSize + 1;
-  const biggerShardCount = testDefns.length % shardTotal;
-
-  // Since we don't have tests for this file, construct all shards so correct
-  // structure can be asserted.
-  const shards = [];
-  let index = 0;
-  for (let i = 0; i < shardTotal; i++) {
-    const shardSize = i < biggerShardCount ? biggerSize : baseSize;
-    shards.push(testDefns.slice(index, index + shardSize));
-    index += shardSize;
-  }
-  assert.equal(shards.length, shardTotal);
-  assert.deepEqual(shards.flat(), testDefns);
-
-  const shardDefns = shards[shardNumber - 1];
-  console.log(`In this shard (${shardArg}), running: ${shardDefns.map(d => d.id).join(' ')}\n`);
-  return shardDefns;
-}
-
 /**
  * Prune the `networkRequests` from the test expectations when `takeNetworkRequestUrls`
  * is not defined. Custom servers may not have this method available in-process.

package/lighthouse-cli/test/smokehouse/readme.md

@@ -2,7 +2,7 @@
 
 Smokehouse is the Lighthouse end-to-end/smoke test runner. It takes in a set of URLs (usually pointing to custom-built test sites), runs Lighthouse on them, and compares the results against a set of expectations.
 
-By default this is done using the Lighthouse CLI (to exercise the full pipeline) with the tests listed in [`smokehouse/test-definitions/core-tests.js`](./test-definitions/core-tests.js).
+By default this is done using the Lighthouse CLI (to exercise the full pipeline) with the tests listed in [`smokehouse/core-tests.js`](./core-tests.js).
 
 ## Options
 

package/lighthouse-cli/test/smokehouse/smokehouse.js

@@ -32,6 +32,8 @@
  * @property {Run[]} runs
  */
 
+import {strict as assert} from 'assert';
+
 import log from 'lighthouse-logger';
 
 import {runLighthouse as cliLighthouseRunner} from './lighthouse-runners/cli.js';
@@ -227,6 +229,54 @@ function getAssertionLog(count) {
   return `${count} assertion${plural}`;
 }
 
+/**
+ * Parses the cli `shardArg` flag into `shardNumber/shardTotal`. Splits
+ * `testDefns` into `shardTotal` shards and returns the `shardNumber`th shard.
+ * Shards will differ in size by at most 1.
+ * Shard params must be 1 ≤ shardNumber ≤ shardTotal.
+ * @param {Array<Smokehouse.TestDfn>} testDefns
+ * @param {string=} shardArg
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+function getShardedDefinitions(testDefns, shardArg) {
+  if (!shardArg) return testDefns;
+
+  // eslint-disable-next-line max-len
+  const errorMessage = `'shard' must be of the form 'n/d' and n and d must be positive integers with 1 ≤ n ≤ d. Got '${shardArg}'`;
+  const match = /^(?<shardNumber>\d+)\/(?<shardTotal>\d+)$/.exec(shardArg);
+  assert(match && match.groups, errorMessage);
+  const shardNumber = Number(match.groups.shardNumber);
+  const shardTotal = Number(match.groups.shardTotal);
+  assert(shardNumber > 0 && Number.isInteger(shardNumber), errorMessage);
+  assert(shardTotal > 0 && Number.isInteger(shardTotal));
+  assert(shardNumber <= shardTotal, errorMessage);
+
+  // Array is sharded with `Math.ceil(length / shardTotal)` shards first
+  // and then the remaining `Math.floor(length / shardTotal) shards.
+  // e.g. `[0, 1, 2, 3]` split into 3 shards is `[[0, 1], [2], [3]]`.
+  const baseSize = Math.floor(testDefns.length / shardTotal);
+  const biggerSize = baseSize + 1;
+  const biggerShardCount = testDefns.length % shardTotal;
+
+  // Since we don't have tests for this file, construct all shards so correct
+  // structure can be asserted.
+  const shards = [];
+  let index = 0;
+  for (let i = 0; i < shardTotal; i++) {
+    const shardSize = i < biggerShardCount ? biggerSize : baseSize;
+    shards.push(testDefns.slice(index, index + shardSize));
+    index += shardSize;
+  }
+  assert.equal(shards.length, shardTotal);
+  assert.deepEqual(shards.flat(), testDefns);
+
+  const shardDefns = shards[shardNumber - 1];
+  console.log(`In this shard (${shardArg}), running: ${shardDefns.map(d => d.id).join(' ')}\n`);
+  return shardDefns;
+}
+
+
 export {
   runSmokehouse,
+  getShardedDefinitions,
 };

package/lighthouse-core/audits/apple-touch-icon.js

@@ -56,8 +56,8 @@ class AppleTouchIcon extends Audit {
     const passed = appleTouchIcons.length !== 0;
 
     const warnings = [];
-    if (appleTouchIcons.filter(el => el.rel === 'apple-touch-icon-precomposed').length !== 0
-      && appleTouchIcons.filter(el => el.rel === 'apple-touch-icon').length === 0) {
+    if (appleTouchIcons.filter(el => el.rel === 'apple-touch-icon-precomposed').length !== 0 &&
+      appleTouchIcons.filter(el => el.rel === 'apple-touch-icon').length === 0) {
       warnings.push(str_(UIStrings.precomposedWarning));
     }
 

package/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -200,19 +200,6 @@ class UnusedBytes extends Audit {
     return Math.round(Math.max(savings, 0) / 10) * 10;
   }
 
-  /**
-   * @param {number} wastedBytes
-   * @param {Simulator} simulator
-   */
-  static computeWastedMsWithThroughput(wastedBytes, simulator) {
-    const bitsPerSecond = simulator.getOptions().throughput;
-    // https://github.com/GoogleChrome/lighthouse/pull/13323#issuecomment-962031709
-    if (bitsPerSecond === 0) return 0;
-    const wastedBits = wastedBytes * 8;
-    const wastedMs = wastedBits / bitsPerSecond * 1000;
-    return wastedMs;
-  }
-
   /**
    * @param {ByteEfficiencyProduct} result
    * @param {Node|null} graph
@@ -232,7 +219,7 @@ class UnusedBytes extends Audit {
         providedWastedBytesByUrl: result.wastedBytesByUrl,
       });
     } else {
-      wastedMs = this.computeWastedMsWithThroughput(wastedBytes, simulator);
+      wastedMs = simulator.computeWastedMsFromWastedBytes(wastedBytes);
     }
 
     let displayValue = result.displayValue || '';

package/lighthouse-core/audits/byte-efficiency/legacy-javascript.js

@@ -178,8 +178,6 @@ class LegacyJavascript extends ByteEfficiencyAudit {
       ['Array.isArray', 'es6.array.is-array'],
       ['Array.prototype.map', 'es6.array.map'],
       ['Array.of', 'es6.array.of'],
-      ['Array.prototype.reduce', 'es6.array.reduce'],
-      ['Array.prototype.reduceRight', 'es6.array.reduce-right'],
       ['Array.prototype.some', 'es6.array.some'],
       ['Date.now', 'es6.date.now'],
       ['Date.prototype.toISOString', 'es6.date.to-iso-string'],
@@ -188,11 +186,9 @@ class LegacyJavascript extends ByteEfficiencyAudit {
       ['Function.prototype.name', 'es6.function.name'],
       ['Number.isInteger', 'es6.number.is-integer'],
       ['Number.isSafeInteger', 'es6.number.is-safe-integer'],
-      ['Number.parseInt', 'es6.number.parse-int'],
       ['Object.defineProperties', 'es6.object.define-properties'],
       ['Object.defineProperty', 'es6.object.define-property'],
       ['Object.freeze', 'es6.object.freeze'],
-      ['Object.getOwnPropertyNames', 'es6.object.get-own-property-names'],
       ['Object.getPrototypeOf', 'es6.object.get-prototype-of'],
       ['Object.isExtensible', 'es6.object.is-extensible'],
       ['Object.isFrozen', 'es6.object.is-frozen'],

package/lighthouse-core/audits/no-unload-listeners.js

@@ -15,7 +15,7 @@ const UIStrings = {
   /** Descriptive title of a Lighthouse audit that checks if a web page has 'unload' event listeners and finds that it is using them. */
   failureTitle: 'Registers an `unload` listener',
   /** Description of a Lighthouse audit that tells the user why pages should not use the 'unload' event. This is displayed after a user expands the section to see more. 'Learn More' becomes link text to additional documentation. */
-  description: 'The `unload` event does not fire reliably and listening for it can prevent browser optimizations like the Back-Forward Cache. Consider using the `pagehide` or `visibilitychange` events instead. [Learn more](https://developers.google.com/web/updates/2018/07/page-lifecycle-api#the-unload-event)',
+  description: 'The `unload` event does not fire reliably and listening for it can prevent browser optimizations like the Back-Forward Cache. Use `pagehide` or `visibilitychange` events instead. [Learn more](https://web.dev/bfcache/#never-use-the-unload-event)',
 };
 
 const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);

package/lighthouse-core/computed/computed-artifact.js

@@ -11,20 +11,26 @@ const log = require('lighthouse-logger');
 /**
  * Decorate computableArtifact with a caching `request()` method which will
  * automatically call `computableArtifact.compute_()` under the hood.
- * @template {{name: string, compute_(artifacts: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
+ * @template {{name: string, compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
+ * @template {Array<keyof FirstParamType<C['compute_']>>} K
  * @param {C} computableArtifact
+ * @param {(K & ([keyof FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
  */
-function makeComputedArtifact(computableArtifact) {
+function makeComputedArtifact(computableArtifact, keys) {
   // tsc (3.1) has more difficulty with template inter-references in jsdoc, so
   // give types to params and return value the long way, essentially recreating
   // polymorphic-this behavior for C.
   /**
    * Return an automatically cached result from the computed artifact.
-   * @param {FirstParamType<C['compute_']>} artifacts
+   * @param {FirstParamType<C['compute_']>} dependencies
    * @param {LH.Artifacts.ComputedContext} context
    * @return {ReturnType<C['compute_']>}
    */
-  const request = (artifacts, context) => {
+  const request = (dependencies, context) => {
+    const pickedDependencies = keys ?
+      Object.fromEntries(keys.map(key => [key, dependencies[key]])) :
+      dependencies;
+
     // NOTE: break immutability solely for this caching-controller function.
     const computedCache = /** @type {Map<string, ArbitraryEqualityMap>} */ (context.computedCache);
     const computedName = computableArtifact.name;
@@ -32,7 +38,8 @@ function makeComputedArtifact(computableArtifact) {
     const cache = computedCache.get(computedName) || new ArbitraryEqualityMap();
     computedCache.set(computedName, cache);
 
-    const computed = /** @type {ReturnType<C['compute_']>|undefined} */ (cache.get(artifacts));
+    /** @type {ReturnType<C['compute_']>|undefined} */
+    const computed = cache.get(pickedDependencies);
     if (computed) {
       return computed;
     }
@@ -41,8 +48,8 @@ function makeComputedArtifact(computableArtifact) {
     log.time(status, 'verbose');
 
     const artifactPromise = /** @type {ReturnType<C['compute_']>} */
-        (computableArtifact.compute_(artifacts, context));
-    cache.set(artifacts, artifactPromise);
+        (computableArtifact.compute_(pickedDependencies, context));
+    cache.set(pickedDependencies, artifactPromise);
 
     artifactPromise.then(() => log.timeEnd(status)).catch(() => log.timeEnd(status));
 

package/lighthouse-core/computed/critical-request-chains.js

@@ -41,8 +41,8 @@ class CriticalRequestChains {
     }
 
     // Iframes are considered High Priority but they are not render blocking
-    const isIframe = request.resourceType === NetworkRequest.TYPES.Document
-      && request.frameId !== mainResource.frameId;
+    const isIframe = request.resourceType === NetworkRequest.TYPES.Document &&
+      request.frameId !== mainResource.frameId;
     // XHRs are fetched at High priority, but we exclude them, as they are unlikely to be critical
     // Images are also non-critical.
     // Treat any missed images, primarily favicons, as non-critical resources
@@ -143,4 +143,4 @@ class CriticalRequestChains {
   }
 }
 
-module.exports = makeComputedArtifact(CriticalRequestChains);
+module.exports = makeComputedArtifact(CriticalRequestChains, ['URL', 'devtoolsLog', 'trace']);

package/lighthouse-core/computed/image-records.js

@@ -59,5 +59,5 @@ class ImageRecords {
   }
 }
 
-module.exports = makeComputedArtifact(ImageRecords);
+module.exports = makeComputedArtifact(ImageRecords, ['ImageElements', 'networkRecords']);
 

package/lighthouse-core/computed/js-bundles.js

@@ -116,4 +116,4 @@ class JSBundles {
   }
 }
 
-module.exports = makeComputedArtifact(JSBundles);
+module.exports = makeComputedArtifact(JSBundles, ['ScriptElements', 'SourceMaps']);

package/lighthouse-core/computed/load-simulator.js

@@ -24,6 +24,7 @@ class LoadSimulator {
     const options = {
       additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
       serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,
+      observedThroughput: networkAnalysis.throughput,
     };
 
     // If we have precomputed lantern data, overwrite our observed estimates and use precomputed instead
@@ -88,4 +89,4 @@ class LoadSimulator {
   }
 }
 
-module.exports = makeComputedArtifact(LoadSimulator);
+module.exports = makeComputedArtifact(LoadSimulator, ['devtoolsLog', 'settings']);

package/lighthouse-core/computed/main-resource.js

@@ -31,4 +31,4 @@ class MainResource {
   }
 }
 
-module.exports = makeComputedArtifact(MainResource);
+module.exports = makeComputedArtifact(MainResource, ['URL', 'devtoolsLog']);

package/lighthouse-core/computed/main-thread-tasks.js

@@ -21,4 +21,4 @@ class MainThreadTasks {
   }
 }
 
-module.exports = makeComputedArtifact(MainThreadTasks);
+module.exports = makeComputedArtifact(MainThreadTasks, null);

package/lighthouse-core/computed/manifest-values.js

@@ -132,4 +132,4 @@ class ManifestValues {
   }
 }
 
-module.exports = makeComputedArtifact(ManifestValues);
+module.exports = makeComputedArtifact(ManifestValues, ['InstallabilityErrors', 'WebAppManifest']);

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

@@ -126,4 +126,4 @@ class CumulativeLayoutShift {
   }
 }
 
-module.exports = makeComputedArtifact(CumulativeLayoutShift);
+module.exports = makeComputedArtifact(CumulativeLayoutShift, null);

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

@@ -31,4 +31,7 @@ class FirstContentfulPaintAllFrames extends NavigationMetric {
   }
 }
 
-module.exports = makeComputedArtifact(FirstContentfulPaintAllFrames);
+module.exports = makeComputedArtifact(
+  FirstContentfulPaintAllFrames,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -34,4 +34,7 @@ class FirstContentfulPaint extends NavigationMetric {
   }
 }
 
-module.exports = makeComputedArtifact(FirstContentfulPaint);
+module.exports = makeComputedArtifact(
+  FirstContentfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -38,4 +38,7 @@ class FirstMeaningfulPaint extends NavigationMetric {
   }
 }
 
-module.exports = makeComputedArtifact(FirstMeaningfulPaint);
+module.exports = makeComputedArtifact(
+  FirstMeaningfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -181,7 +181,10 @@ class Interactive extends NavigationMetric {
   }
 }
 
-module.exports = makeComputedArtifact(Interactive);
+module.exports = makeComputedArtifact(
+  Interactive,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);
 
 /**
  * @typedef TimePeriod

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

@@ -150,7 +150,9 @@ class LanternFirstContentfulPaint extends LanternMetric {
     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)
-        if (node.endTime > paintTs && !node.isMainDocument()) return false;
+        // 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.
@@ -196,4 +198,7 @@ class LanternFirstContentfulPaint extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternFirstContentfulPaint);
+module.exports = makeComputedArtifact(
+  LanternFirstContentfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -77,4 +77,7 @@ class LanternFirstMeaningfulPaint extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternFirstMeaningfulPaint);
+module.exports = makeComputedArtifact(
+  LanternFirstMeaningfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -107,4 +107,7 @@ class LanternInteractive extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternInteractive);
+module.exports = makeComputedArtifact(
+  LanternInteractive,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -105,4 +105,7 @@ class LanternLargestContentfulPaint extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternLargestContentfulPaint);
+module.exports = makeComputedArtifact(
+  LanternLargestContentfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -87,4 +87,7 @@ class LanternMaxPotentialFID extends LanternMetricArtifact {
   }
 }
 
-module.exports = makeComputedArtifact(LanternMaxPotentialFID);
+module.exports = makeComputedArtifact(
+  LanternMaxPotentialFID,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -144,4 +144,7 @@ class LanternSpeedIndex extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternSpeedIndex);
+module.exports = makeComputedArtifact(
+  LanternSpeedIndex,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -120,4 +120,7 @@ class LanternTotalBlockingTime extends LanternMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LanternTotalBlockingTime);
+module.exports = makeComputedArtifact(
+  LanternTotalBlockingTime,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);

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

@@ -39,4 +39,7 @@ class LargestContentfulPaintAllFrames extends NavigationMetric {
   }
 }
 
-module.exports = makeComputedArtifact(LargestContentfulPaintAllFrames);
+module.exports = makeComputedArtifact(
+  LargestContentfulPaintAllFrames,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+);