lighthouse 8.3.0-dev.20210907 → 8.3.0

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

@@ -159,32 +159,23 @@ function makeComparison(name, actualResult, expectedResult) {
  * @param {Smokehouse.ExpectedRunnerResult} expected
  */
 function pruneExpectations(localConsole, lhr, expected) {
-  const isFraggleRock = lhr.configSettings.channel === 'fraggle-rock-cli';
-
-  /**
-   * Lazily compute the Chrome version because some reports are explicitly asserting error conditions.
-   * @returns {number}
-   */
-  function getChromeVersion() {
-    const userAgent = lhr.environment.hostUserAgent;
-    const userAgentMatch = /Chrome\/(\d+)/.exec(userAgent); // Chrome/85.0.4174.0
-    if (!userAgentMatch) throw new Error('Could not get chrome version.');
-    return Number(userAgentMatch[1]);
-  }
-
+  const userAgent = lhr.environment.hostUserAgent;
+  const userAgentMatch = /Chrome\/(\d+)/.exec(userAgent); // Chrome/85.0.4174.0
+  if (!userAgentMatch) throw new Error('Could not get chrome version.');
+  const actualChromeVersion = Number(userAgentMatch[1]);
   /**
    * @param {*} obj
    */
   function failsChromeVersionCheck(obj) {
-    if (obj._minChromiumMilestone && getChromeVersion() < obj._minChromiumMilestone) return true;
-    if (obj._maxChromiumMilestone && getChromeVersion() > obj._maxChromiumMilestone) return true;
+    if (obj._minChromiumMilestone && actualChromeVersion < obj._minChromiumMilestone) return true;
+    if (obj._maxChromiumMilestone && actualChromeVersion > obj._maxChromiumMilestone) return true;
     return false;
   }
 
   /**
    * @param {*} obj
    */
-  function pruneRecursively(obj) {
+  function pruneNewerChromeExpectations(obj) {
     for (const key of Object.keys(obj)) {
       const value = obj[key];
       if (!value || typeof value !== 'object') {
@@ -195,36 +186,20 @@ function pruneExpectations(localConsole, lhr, expected) {
         localConsole.log([
           `[${key}] failed chrome version check, pruning expectation:`,
           JSON.stringify(value, null, 2),
-          `Actual Chromium version: ${getChromeVersion()}`,
-        ].join(' '));
-        delete obj[key];
-      } else if (value._legacyOnly && isFraggleRock) {
-        localConsole.log([
-          `[${key}] marked legacy only but run is Fraggle Rock, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-        ].join(' '));
-        delete obj[key];
-      } else if (value._fraggleRockOnly && !isFraggleRock) {
-        localConsole.log([
-          `[${key}] marked Fraggle Rock only but run is legacy, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-          `Actual channel: ${lhr.configSettings.channel}`,
+          `Actual Chromium version: ${actualChromeVersion}`,
         ].join(' '));
         delete obj[key];
       } else {
-        pruneRecursively(value);
+        pruneNewerChromeExpectations(value);
       }
     }
-
-    delete obj._legacyOnly;
-    delete obj._fraggleRockOnly;
     delete obj._minChromiumMilestone;
     delete obj._maxChromiumMilestone;
   }
 
   const cloned = cloneDeep(expected);
 
-  pruneRecursively(cloned);
+  pruneNewerChromeExpectations(cloned);
   return cloned;
 }
 
@@ -290,7 +265,12 @@ function collateResults(localConsole, actual, expected) {
   }
 
   return [
-    makeComparison('final url', actual.lhr.finalUrl, expected.lhr.finalUrl),
+    {
+      name: 'final url',
+      actual: actual.lhr.finalUrl,
+      expected: expected.lhr.finalUrl,
+      equal: actual.lhr.finalUrl === expected.lhr.finalUrl,
+    },
     runtimeErrorAssertion,
     runWarningsAssertion,
     ...requestCountAssertion,

package/lighthouse-core/audits/large-javascript-libraries.js

@@ -0,0 +1,166 @@
+/**
+ * @license Copyright 2020 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.
+ */
+
+/**
+ * @fileoverview This audit checks a page for any large JS libraries with smaller alternatives.
+ * These libraries can be replaced with functionally equivalent, smaller ones.
+ * @see https://docs.google.com/document/d/1TgKO3cWqMpcS4dn0xbjDG5fyuqgVvYYoXg--knaxJnM
+ */
+
+'use strict';
+/** @typedef {{repository: string, lastScraped: number|'Error', versions: Record<string, {gzip: number}>}} BundlePhobiaLibrary */
+
+/** @typedef {{gzip: number, name: string, repository: string}} MinifiedBundlePhobiaLibrary */
+
+/** @type {Record<string, BundlePhobiaLibrary>} */
+const libStats = require('../lib/large-javascript-libraries/bundlephobia-database.json');
+
+/** @type {Record<string, string[]>} */
+const librarySuggestions = require('../lib/large-javascript-libraries/library-suggestions.js')
+  .suggestions;
+
+const Audit = require('./audit.js');
+const i18n = require('../lib/i18n/i18n.js');
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on large Javascript libraries that are used on the page that have better alternatives. This descriptive title is shown when to users when no known unnecessarily large libraries are detected on the page.*/
+  title: 'Avoids large JavaScript libraries with smaller alternatives',
+  /** Title of a Lighthouse audit that provides detail on large Javascript libraries that are used on the page that have better alternatives. This descriptive title is shown when to users when some known unnecessarily large libraries are detected on the page.*/
+  failureTitle: 'Replace unnecessarily large JavaScript libraries',
+  /** Description of a Lighthouse audit that tells the user why they should care about the large Javascript libraries that have better alternatives. This is displayed after a user expands the section to see more. No character length limits. */
+  description: 'Large JavaScript libraries can lead to poor performance. ' +
+    'Prefer smaller, functionally equivalent libraries to reduce your bundle size.' +
+    ' [Learn more](https://developers.google.com/web/fundamentals/performance/webpack/decrease-frontend-size#optimize_dependencies).',
+  /** Label for a column in a data table. Entries will be names of large JavaScript libraries that could be replaced. */
+  columnLibraryName: 'Library',
+  /** [ICU Syntax] Label for the Large JavaScrip Libraries audit identifying how many large libraries were found. */
+  displayValue: `{libraryCount, plural,
+    =1 {1 large library found}
+    other {# large libraries found}
+    }`,
+};
+
+const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
+
+class LargeJavascriptLibraries extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'large-javascript-libraries',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Stacks'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    /** @type {Array<{original: MinifiedBundlePhobiaLibrary, suggestions: MinifiedBundlePhobiaLibrary[]}>} */
+    const libraryPairings = [];
+    const detectedLibs = artifacts.Stacks;
+
+    const seenLibraries = new Set();
+
+    for (const detectedLib of detectedLibs) {
+      if (!detectedLib.npm || !libStats[detectedLib.npm]) continue;
+
+      const suggestions = librarySuggestions[detectedLib.npm];
+      if (!suggestions) continue;
+
+      if (seenLibraries.has(detectedLib.npm)) continue;
+      seenLibraries.add(detectedLib.npm);
+
+      let version = 'latest';
+      if (detectedLib.version && libStats[detectedLib.npm].versions[detectedLib.version]) {
+        version = detectedLib.version;
+      }
+
+      const originalLib = libStats[detectedLib.npm].versions[version];
+
+      /** @type {Array<{name: string, repository: string, gzip: number}>} */
+      const smallerSuggestions = [];
+      for (const suggestion of suggestions) {
+        if (libStats[suggestion].versions['latest'].gzip >= originalLib.gzip) continue;
+
+        smallerSuggestions.push({
+          name: suggestion,
+          repository: libStats[suggestion].repository,
+          gzip: libStats[suggestion].versions['latest'].gzip,
+        });
+      }
+
+      smallerSuggestions.sort((a, b) => a.gzip - b.gzip);
+      if (!smallerSuggestions.length) continue;
+
+      libraryPairings.push({
+        original: {
+          gzip: originalLib.gzip,
+          name: detectedLib.npm,
+          repository: libStats[detectedLib.npm].repository,
+        },
+        suggestions: smallerSuggestions,
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['items']} */
+    const tableDetails = libraryPairings.map(libraryPairing => {
+      const original = libraryPairing.original;
+      const suggestions = libraryPairing.suggestions;
+      const suggestionItems = suggestions.map(suggestion => {
+        return {
+          suggestion: {
+            type: /** @type {'link'} */ ('link'),
+            text: suggestion.name,
+            url: suggestion.repository,
+          },
+          transferSize: suggestion.gzip,
+          wastedBytes: original.gzip - suggestion.gzip,
+        };
+      });
+
+      return {
+        name: {
+          type: /** @type {'link'} */ ('link'),
+          text: original.name,
+          url: original.repository,
+        },
+        transferSize: original.gzip,
+        subItems: {
+          type: /** @type {'subitems'} */ ('subitems'),
+          items: suggestionItems,
+        },
+      };
+    });
+
+    /** @type {LH.Audit.Details.TableColumnHeading[]} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'name', itemType: 'text', subItemsHeading: {key: 'suggestion'}, text: str_(UIStrings.columnLibraryName)},
+      {key: 'transferSize', itemType: 'bytes', subItemsHeading: {key: 'transferSize'}, text: str_(i18n.UIStrings.columnTransferSize)},
+      {key: null, itemType: 'bytes', subItemsHeading: {key: 'wastedBytes'}, text: str_(i18n.UIStrings.columnWastedBytes)},
+      /* eslint-enable max-len */
+    ];
+
+    const displayValue = str_(UIStrings.displayValue, {libraryCount: tableDetails.length});
+
+    const details = Audit.makeTableDetails(headings, tableDetails, {});
+
+    return {
+      score: libraryPairings.length > 0 ? 0 : 1,
+      displayValue,
+      details,
+    };
+  }
+}
+
+module.exports = LargeJavascriptLibraries;
+module.exports.UIStrings = UIStrings;

package/lighthouse-core/audits/seo/http-status-code.js

@@ -35,7 +35,6 @@ class HTTPStatusCode extends Audit {
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
       requiredArtifacts: ['devtoolsLogs', 'URL', 'GatherContext'],
-      supportedModes: ['navigation'],
     };
   }
 
@@ -48,7 +47,12 @@ class HTTPStatusCode extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainResource = NetworkAnalyzer.findMainDocument(networkRecords, URL.finalUrl);
+    const mainResource = NetworkAnalyzer.findOptionalMainDocument(networkRecords, URL.finalUrl);
+
+    if (!mainResource) {
+      if (artifacts.GatherContext.gatherMode === 'timespan') return {notApplicable: true, score: 1};
+      throw new Error(`Unable to locate main resource`);
+    }
 
     const statusCode = mainResource.statusCode;
 

package/lighthouse-core/audits/viewport.js

@@ -16,8 +16,7 @@ const UIStrings = {
   failureTitle: 'Does not have a `<meta name="viewport">` tag with `width` ' +
     'or `initial-scale`',
   /** Description of a Lighthouse audit that tells the user why they should have a viewport meta tag in their html. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
-  description: 'A `<meta name="viewport">` not only optimizes your app for mobile screen sizes, ' +
-    'but also prevents [a 300 millisecond delay to user input](https://developers.google.com/web/updates/2013/12/300ms-tap-delay-gone-away). ' +
+  description: 'Add a `<meta name="viewport">` tag to optimize your app for mobile screens. ' +
     '[Learn more](https://web.dev/viewport/).',
   /** Explanatory message stating that no viewport meta tag exists on the page. */
   explanationNoTag: 'No `<meta name="viewport">` tag found',

package/lighthouse-core/config/config-helpers.js

@@ -9,24 +9,23 @@ const path = require('path');
 const isDeepEqual = require('lodash.isequal');
 const constants = require('./constants.js');
 const Budget = require('./budget.js');
+const Audit = require('../audits/audit.js');
 const Runner = require('../runner.js');
 const i18n = require('../lib/i18n/i18n.js');
-const validation = require('../fraggle-rock/config/validation.js');
 
 /** @typedef {typeof import('../gather/gatherers/gatherer.js')} GathererConstructor */
-/** @typedef {typeof import('../audits/audit.js')} Audit */
 /** @typedef {InstanceType<GathererConstructor>} Gatherer */
 
 /**
  * If any items with identical `path` properties are found in the input array,
  * merge their `options` properties into the first instance and then discard any
  * other instances.
- * @template {{path?: string, options: Record<string, unknown>}} T
- * @param {T[]} items
- * @return T[]
+ * Until support of jsdoc templates with constraints, type in config.d.ts.
+ * See https://github.com/Microsoft/TypeScript/issues/24283
+ * @type {LH.Config.MergeOptionsOfItems}
  */
 const mergeOptionsOfItems = function(items) {
-  /** @type {T[]} */
+  /** @type {Array<{id: string, path?: string, options?: Object<string, any>}>} */
   const mergedItems = [];
 
   for (const item of items) {
@@ -129,6 +128,73 @@ function mergeConfigFragmentArrayByKey(baseArray, extensionArray, keyFn) {
   return mergedArray;
 }
 
+/**
+ * Validate the settings after they've been built
+ * @param {LH.Config.Settings} settings
+ */
+function assertValidSettings(settings) {
+  if (!settings.formFactor) {
+    throw new Error(`\`settings.formFactor\` must be defined as 'mobile' or 'desktop'. See https://github.com/GoogleChrome/lighthouse/blob/master/docs/emulation.md`);
+  }
+
+  if (!settings.screenEmulation.disabled) {
+    // formFactor doesn't control emulation. So we don't want a mismatch:
+    //   Bad mismatch A: user wants mobile emulation but scoring is configured for desktop
+    //   Bad mismtach B: user wants everything desktop and set formFactor, but accidentally not screenEmulation
+    if (settings.screenEmulation.mobile !== (settings.formFactor === 'mobile')) {
+      throw new Error(`Screen emulation mobile setting (${settings.screenEmulation.mobile}) does not match formFactor setting (${settings.formFactor}). See https://github.com/GoogleChrome/lighthouse/blob/master/docs/emulation.md`);
+    }
+  }
+}
+
+/**
+ * Throws an error if the provided object does not implement the required properties of an audit
+ * definition.
+ * @param {LH.Config.AuditDefn} auditDefinition
+ */
+function assertValidAudit(auditDefinition) {
+  const {implementation, path: auditPath} = auditDefinition;
+  const auditName = auditPath ||
+    (implementation && implementation.meta && implementation.meta.id) ||
+    'Unknown audit';
+
+  if (typeof implementation.audit !== 'function' || implementation.audit === Audit.audit) {
+    throw new Error(`${auditName} has no audit() method.`);
+  }
+
+  if (typeof implementation.meta.id !== 'string') {
+    throw new Error(`${auditName} has no meta.id property, or the property is not a string.`);
+  }
+
+  if (!i18n.isStringOrIcuMessage(implementation.meta.title)) {
+    throw new Error(`${auditName} has no meta.title property, or the property is not a string.`);
+  }
+
+  // If it'll have a ✔ or ✖ displayed alongside the result, it should have failureTitle
+  if (
+    !i18n.isStringOrIcuMessage(implementation.meta.failureTitle) &&
+    implementation.meta.scoreDisplayMode === Audit.SCORING_MODES.BINARY
+  ) {
+    throw new Error(`${auditName} has no failureTitle and should.`);
+  }
+
+  if (!i18n.isStringOrIcuMessage(implementation.meta.description)) {
+    throw new Error(
+      `${auditName} has no meta.description property, or the property is not a string.`
+    );
+  } else if (implementation.meta.description === '') {
+    throw new Error(
+      `${auditName} has an empty meta.description string. Please add a description for the UI.`
+    );
+  }
+
+  if (!Array.isArray(implementation.meta.requiredArtifacts)) {
+    throw new Error(
+      `${auditName} has no meta.requiredArtifacts property, or the property is not an array.`
+    );
+  }
+}
+
 /**
  * Expands a gatherer from user-specified to an internal gatherer definition format.
  *
@@ -167,7 +233,7 @@ function expandGathererShorthand(gatherer) {
 /**
  * Expands the audits from user-specified JSON to an internal audit definition format.
  * @param {LH.Config.AuditJson} audit
- * @return {{id?: string, path: string, options?: {}} | {id?: string, implementation: Audit, path?: string, options?: {}}}
+ * @return {{id?: string, path: string, options?: {}} | {id?: string, implementation: typeof Audit, path?: string, options?: {}}}
  */
 function expandAuditShorthand(audit) {
   if (typeof audit === 'string') {
@@ -293,7 +359,7 @@ function resolveSettings(settingsJson = {}, overrides = undefined) {
     settingsWithFlags.emulatedUserAgent = constants.userAgents[settingsWithFlags.formFactor];
   }
 
-  validation.assertValidSettings(settingsWithFlags);
+  assertValidSettings(settingsWithFlags);
   return settingsWithFlags;
 }
 
@@ -362,7 +428,7 @@ function resolveAuditsToDefns(audits, configDir) {
   });
 
   const mergedAuditDefns = mergeOptionsOfItems(auditDefns);
-  mergedAuditDefns.forEach(audit => validation.assertValidAudit(audit));
+  mergedAuditDefns.forEach(audit => assertValidAudit(audit));
   return mergedAuditDefns;
 }
 

package/lighthouse-core/config/config.js

@@ -9,7 +9,6 @@ const defaultConfigPath = './default-config.js';
 const defaultConfig = require('./default-config.js');
 const constants = require('./constants.js');
 const i18n = require('./../lib/i18n/i18n.js');
-const validation = require('./../fraggle-rock/config/validation.js');
 
 const log = require('lighthouse-logger');
 const path = require('path');
@@ -105,6 +104,49 @@ function assertValidPasses(passes, audits) {
   });
 }
 
+/**
+ * @param {Config['categories']} categories
+ * @param {Config['audits']} audits
+ * @param {Config['groups']} groups
+ */
+function assertValidCategories(categories, audits, groups) {
+  if (!categories) {
+    return;
+  }
+
+  /** @type {Map<string, LH.Config.AuditDefn>} */
+  const auditsKeyedById = new Map((audits || []).map(audit => {
+    return [audit.implementation.meta.id, audit];
+  }));
+
+  Object.keys(categories).forEach(categoryId => {
+    categories[categoryId].auditRefs.forEach((auditRef, index) => {
+      if (!auditRef.id) {
+        throw new Error(`missing an audit id at ${categoryId}[${index}]`);
+      }
+
+      const audit = auditsKeyedById.get(auditRef.id);
+      if (!audit) {
+        throw new Error(`could not find ${auditRef.id} audit for category ${categoryId}`);
+      }
+
+      const auditImpl = audit.implementation;
+      const isManual = auditImpl.meta.scoreDisplayMode === 'manual';
+      if (categoryId === 'accessibility' && !auditRef.group && !isManual) {
+        throw new Error(`${auditRef.id} accessibility audit does not have a group`);
+      }
+
+      if (auditRef.weight > 0 && isManual) {
+        throw new Error(`${auditRef.id} is manual but has a positive weight`);
+      }
+
+      if (auditRef.group && (!groups || !groups[auditRef.group])) {
+        throw new Error(`${auditRef.id} references unknown group ${auditRef.group}`);
+      }
+    });
+  });
+}
+
 /**
  * @param {Gatherer} gathererInstance
  * @param {string=} gathererName
@@ -229,7 +271,7 @@ class Config {
     Config.filterConfigIfNeeded(this);
 
     assertValidPasses(this.passes, this.audits);
-    validation.assertValidCategories(this.categories, this.audits, this.groups);
+    assertValidCategories(this.categories, this.audits, this.groups);
 
     log.timeEnd(status);
   }
@@ -466,10 +508,12 @@ class Config {
 
     // The `full-page-screenshot` audit belongs to no category, but we still want to include
     // it (unless explictly excluded) because there are audits in every category that can use it.
-    const explicitlyExcludesFullPageScreenshot =
-      settings.skipAudits && settings.skipAudits.includes('full-page-screenshot');
-    if (!explicitlyExcludesFullPageScreenshot && (settings.onlyCategories || settings.skipAudits)) {
-      includedAudits.add('full-page-screenshot');
+    if (settings.onlyCategories) {
+      const explicitlyExcludesFullPageScreenshot =
+        settings.skipAudits && settings.skipAudits.includes('full-page-screenshot');
+      if (!explicitlyExcludesFullPageScreenshot) {
+        includedAudits.add('full-page-screenshot');
+      }
     }
 
     return {categories, requestedAuditNames: includedAudits};

package/lighthouse-core/config/constants.js

@@ -106,7 +106,6 @@ const defaultSettings = {
   auditMode: false,
   gatherMode: false,
   disableStorageReset: false,
-  debugNavigation: false,
   channel: 'node',
 
   // the following settings have no defaults but we still want ensure that `key in settings`

package/lighthouse-core/config/default-config.js

@@ -229,7 +229,6 @@ const defaultConfig = {
     'third-party-summary',
     'third-party-facades',
     'largest-contentful-paint-element',
-    'lcp-lazy-loaded',
     'layout-shift-elements',
     'long-tasks',
     'no-unload-listeners',
@@ -467,14 +466,12 @@ const defaultConfig = {
         {id: 'third-party-summary', weight: 0, group: 'diagnostics'},
         {id: 'third-party-facades', weight: 0, group: 'diagnostics'},
         {id: 'largest-contentful-paint-element', weight: 0, group: 'diagnostics'},
-        {id: 'lcp-lazy-loaded', weight: 0, group: 'diagnostics'},
         {id: 'layout-shift-elements', weight: 0, group: 'diagnostics'},
         {id: 'uses-passive-event-listeners', weight: 0, group: 'diagnostics'},
         {id: 'no-document-write', weight: 0, group: 'diagnostics'},
         {id: 'long-tasks', weight: 0, group: 'diagnostics'},
         {id: 'non-composited-animations', weight: 0, group: 'diagnostics'},
         {id: 'unsized-images', weight: 0, group: 'diagnostics'},
-        {id: 'viewport', weight: 0, group: 'diagnostics'},
         // Audits past this point don't belong to a group and will not be shown automatically
         {id: 'network-requests', weight: 0},
         {id: 'network-rtt', weight: 0},

package/lighthouse-core/config/experimental-config.js

@@ -15,8 +15,16 @@ const config = {
   extends: 'lighthouse:default',
   audits: [
     'autocomplete',
+    'large-javascript-libraries',
   ],
   categories: {
+    // @ts-ignore: `title` is required in CategoryJson. setting to the same value as the default
+    // config is awkward - easier to omit the property here. Will defer to default config.
+    'performance': {
+      auditRefs: [
+        {id: 'large-javascript-libraries', weight: 0, group: 'diagnostics'},
+      ],
+    },
     // @ts-ignore: `title` is required in CategoryJson. setting to the same value as the default
     // config is awkward - easier to omit the property here. Will defer to default config.
     'best-practices': {

package/lighthouse-core/config/metrics-to-audits.js

@@ -38,7 +38,6 @@ const tbtRelevantAudits = [
   'dom-size',
   'duplicated-javascript',
   'legacy-javascript',
-  'viewport',
 ];
 
 const clsRelevantAudits = [

package/lighthouse-core/fraggle-rock/config/config.js

@@ -16,7 +16,6 @@ const {
   isValidArtifactDependency,
   throwInvalidArtifactDependency,
   assertArtifactTopologicalOrder,
-  assertValidConfig,
 } = require('./validation.js');
 const {filterConfigByGatherMode, filterConfigByExplicitFilters} = require('./filters.js');
 const {
@@ -251,13 +250,15 @@ function initializeConfig(configJSON, context) {
     settings,
   };
 
-  const {warnings} = assertValidConfig(config);
+  // TODO(FR-COMPAT): validate navigations
+  // TODO(FR-COMPAT): validate audits
+  // TODO(FR-COMPAT): validate categories
 
   config = filterConfigByGatherMode(config, context.gatherMode);
   config = filterConfigByExplicitFilters(config, settings);
 
   log.timeEnd(status);
-  return {config, warnings};
+  return {config, warnings: []};
 }
 
 module.exports = {resolveWorkingCopy, initializeConfig};

package/lighthouse-core/fraggle-rock/config/default-config.js

@@ -158,6 +158,7 @@ const defaultConfig = {
         artifacts.EmbeddedContent,
         artifacts.FontSize,
         artifacts.FormElements,
+        artifacts.FullPageScreenshot,
         artifacts.GatherContext,
         artifacts.GlobalListeners,
         artifacts.IFrameElements,
@@ -186,9 +187,6 @@ const defaultConfig = {
         // Compat artifacts come last.
         artifacts.devtoolsLogs,
         artifacts.traces,
-
-        // FullPageScreenshot comes at the very end so all other node analysis is captured.
-        artifacts.FullPageScreenshot,
       ],
     },
   ],