lighthouse 8.0.0-dev.20210709 → 8.0.0

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

@@ -7,7 +7,8 @@
 
 const makeComputedArtifact = require('../computed-artifact.js');
 const ComputedMetric = require('./metric.js');
-const TraceProcessor = require('../../lib/tracehouse/trace-processor.js');
+const LHError = require('../../lib/lh-error.js');
+const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
 const LanternTotalBlockingTime = require('./lantern-total-blocking-time.js');
 const TimetoInteractive = require('./interactive.js');
 
@@ -31,15 +32,14 @@ class TotalBlockingTime extends ComputedMetric {
   static get BLOCKING_TIME_THRESHOLD() {
     return 50;
   }
-
   /**
    * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
-   * @param {number} startTimeMs
-   * @param {number} endTimeMs
+   * @param {number} fcpTimeInMs
+   * @param {number} interactiveTimeMs
    * @return {number}
    */
-  static calculateSumOfBlockingTime(topLevelEvents, startTimeMs, endTimeMs) {
-    if (endTimeMs <= startTimeMs) return 0;
+  static calculateSumOfBlockingTime(topLevelEvents, fcpTimeInMs, interactiveTimeMs) {
+    if (interactiveTimeMs <= fcpTimeInMs) return 0;
 
     const threshold = TotalBlockingTime.BLOCKING_TIME_THRESHOLD;
     let sumBlockingTime = 0;
@@ -47,22 +47,23 @@ class TotalBlockingTime extends ComputedMetric {
       // Early exit for small tasks, which should far outnumber long tasks.
       if (event.duration < threshold) continue;
 
-      // We only want to consider tasks that fall in our time range (FCP and TTI for navigations).
+      // We only want to consider tasks that fall between FCP and TTI.
       // FCP is picked as the lower bound because there is little risk of user input happening
       // before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
       // optimizing to reach FCP as fast as possible without having to worry about task lengths.
-      if (event.end < startTimeMs) continue;
+      if (event.end < fcpTimeInMs) continue;
 
-      // TTI is picked as the upper bound because we want a well defined end point for page load.
-      if (event.start > endTimeMs) continue;
+      // TTI is picked as the upper bound because we want a well defined end point so that the
+      // metric does not rely on how long we trace.
+      if (event.start > interactiveTimeMs) continue;
 
       // We first perform the clipping, and then calculate Blocking Region. So if we have a 150ms
       // task [0, 150] and FCP happens midway at 50ms, we first clip the task to [50, 150], and then
       // calculate the Blocking Region to be [100, 150]. The rational here is that tasks before FCP
       // are unimportant, so we care whether the main thread is busy more than 50ms at a time only
       // after FCP.
-      const clippedStart = Math.max(event.start, startTimeMs);
-      const clippedEnd = Math.min(event.end, endTimeMs);
+      const clippedStart = Math.max(event.start, fcpTimeInMs);
+      const clippedEnd = Math.min(event.end, interactiveTimeMs);
       const clippedDuration = clippedEnd - clippedStart;
       if (clippedDuration < threshold) continue;
 
@@ -70,7 +71,7 @@ class TotalBlockingTime extends ComputedMetric {
       // Example:
       //   [              250ms Task                   ]
       //   | First 50ms |   Blocking Region (200ms)    |
-      sumBlockingTime += clippedDuration - threshold;
+      sumBlockingTime += (clippedDuration - threshold);
     }
 
     return sumBlockingTime;
@@ -82,8 +83,7 @@ class TotalBlockingTime extends ComputedMetric {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static computeSimulatedMetric(data, context) {
-    const metricData = ComputedMetric.getMetricComputationInput(data);
-    return LanternTotalBlockingTime.request(metricData, context);
+    return LanternTotalBlockingTime.request(data, context);
   }
 
   /**
@@ -92,29 +92,22 @@ class TotalBlockingTime extends ComputedMetric {
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data, context) {
-    const events = TraceProcessor.getMainThreadTopLevelEvents(data.processedTrace);
+    const {firstContentfulPaint} = data.traceOfTab.timings;
+    if (!firstContentfulPaint) {
+      throw new LHError(LHError.errors.NO_FCP);
+    }
 
-    if (data.processedNavigation) {
-      const {firstContentfulPaint} = data.processedNavigation.timings;
-      const metricData = ComputedMetric.getMetricComputationInput(data);
-      const interactiveTimeMs = (await TimetoInteractive.request(metricData, context)).timing;
+    const interactiveTimeMs = (await TimetoInteractive.request(data, context)).timing;
 
-      return {
-        timing: TotalBlockingTime.calculateSumOfBlockingTime(
-          events,
-          firstContentfulPaint,
-          interactiveTimeMs
-        ),
-      };
-    } else {
-      return {
-        timing: TotalBlockingTime.calculateSumOfBlockingTime(
-          events,
-          0,
-          data.processedTrace.timestamps.traceEnd
-        ),
-      };
-    }
+    const events = TracingProcessor.getMainThreadTopLevelEvents(data.traceOfTab);
+
+    return {
+      timing: TotalBlockingTime.calculateSumOfBlockingTime(
+        events,
+        firstContentfulPaint,
+        interactiveTimeMs
+      ),
+    };
   }
 }
 

package/lighthouse-core/computed/page-dependency-graph.js

@@ -11,7 +11,7 @@ const CPUNode = require('../lib/dependency-graph/cpu-node.js');
 const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 const TracingProcessor = require('../lib/tracehouse/trace-processor.js');
 const NetworkRequest = require('../lib/network-request.js');
-const ProcessedTrace = require('./processed-trace.js');
+const TraceOfTab = require('./trace-of-tab.js');
 const NetworkRecords = require('./network-records.js');
 
 /** @typedef {import('../lib/dependency-graph/base-node.js').Node} Node */
@@ -102,18 +102,18 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Array<CPUNode>}
    */
-  static getCPUNodes({mainThreadEvents}) {
+  static getCPUNodes(traceOfTab) {
     /** @type {Array<CPUNode>} */
     const nodes = [];
     let i = 0;
 
-    TracingProcessor.assertHasToplevelEvents(mainThreadEvents);
+    TracingProcessor.assertHasToplevelEvents(traceOfTab.mainThreadEvents);
 
-    while (i < mainThreadEvents.length) {
-      const evt = mainThreadEvents[i];
+    while (i < traceOfTab.mainThreadEvents.length) {
+      const evt = traceOfTab.mainThreadEvents[i];
       i++;
 
       // Skip all trace events that aren't schedulable tasks with sizable duration
@@ -126,10 +126,10 @@ class PageDependencyGraph {
       const children = [];
       for (
         const endTime = evt.ts + evt.dur;
-        i < mainThreadEvents.length && mainThreadEvents[i].ts < endTime;
+        i < traceOfTab.mainThreadEvents.length && traceOfTab.mainThreadEvents[i].ts < endTime;
         i++
       ) {
-        children.push(mainThreadEvents[i]);
+        children.push(traceOfTab.mainThreadEvents[i]);
       }
 
       nodes.push(new CPUNode(evt, children));
@@ -380,13 +380,13 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @return {Node}
    */
-  static createGraph(processedTrace, networkRecords) {
+  static createGraph(traceOfTab, networkRecords) {
     const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
-    const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
+    const cpuNodes = PageDependencyGraph.getCPUNodes(traceOfTab);
 
     // The root request is the earliest network request, using position in networkRecords array to break ties.
     const rootRequest = networkRecords.reduce((min, r) => (r.startTime < min.startTime ? r : min));
@@ -458,12 +458,12 @@ class PageDependencyGraph {
   static async compute_(data, context) {
     const trace = data.trace;
     const devtoolsLog = data.devtoolsLog;
-    const [processedTrace, networkRecords] = await Promise.all([
-      ProcessedTrace.request(trace, context),
+    const [traceOfTab, networkRecords] = await Promise.all([
+      TraceOfTab.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    return PageDependencyGraph.createGraph(processedTrace, networkRecords);
+    return PageDependencyGraph.createGraph(traceOfTab, networkRecords);
   }
 }
 

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

@@ -9,8 +9,9 @@ const makeComputedArtifact = require('./computed-artifact.js');
 const NetworkRecords = require('./network-records.js');
 const URL = require('../lib/url-shim.js');
 const NetworkRequest = require('../lib/network-request.js');
+const MainResource = require('./main-resource.js');
 const Budget = require('../config/budget.js');
-const Util = require('../../report/renderer/util.js');
+const Util = require('../report/html/renderer/util.js');
 
 /** @typedef {{count: number, resourceSize: number, transferSize: number}} ResourceEntry */
 
@@ -106,8 +107,11 @@ class ResourceSummary {
    * @return {Promise<Record<LH.Budget.ResourceType,ResourceEntry>>}
    */
   static async compute_(data, context) {
-    const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
-    return ResourceSummary.summarize(networkRecords, data.URL.finalUrl, data.budgets);
+    const [networkRecords, mainResource] = await Promise.all([
+      NetworkRecords.request(data.devtoolsLog, context),
+      MainResource.request({devtoolsLog: data.devtoolsLog, URL: data.URL}, context),
+    ]);
+    return ResourceSummary.summarize(networkRecords, mainResource.url, data.budgets);
   }
 }
 

package/lighthouse-core/computed/speedline.js

@@ -8,7 +8,7 @@
 const makeComputedArtifact = require('./computed-artifact.js');
 const speedline = require('speedline-core');
 const LHError = require('../lib/lh-error.js');
-const ProcessedTrace = require('./processed-trace.js');
+const TraceOfTab = require('./trace-of-tab.js');
 
 class Speedline {
   /**
@@ -19,13 +19,13 @@ class Speedline {
   static async compute_(trace, context) {
     // speedline() may throw without a promise, so we resolve immediately
     // to get in a promise chain.
-    return ProcessedTrace.request(trace, context).then(processedTrace => {
+    return TraceOfTab.request(trace, context).then(traceOfTab => {
       // Use a shallow copy of traceEvents so speedline can sort as it pleases.
       // See https://github.com/GoogleChrome/lighthouse/issues/2333
       const traceEvents = trace.traceEvents.slice();
       // Force use of timeOrigin as reference point for speedline
       // See https://github.com/GoogleChrome/lighthouse/issues/2095
-      const timeOrigin = processedTrace.timestamps.timeOrigin;
+      const timeOrigin = traceOfTab.timestamps.timeOrigin;
       return speedline(traceEvents, {
         timeOrigin,
         fastMode: true,

package/lighthouse-core/computed/trace-of-tab.js

@@ -5,26 +5,97 @@
  */
 'use strict';
 
-/** @fileoverview This file is no longer used internally, but remains here for backcompat with plugins. */
-
-const log = require('lighthouse-logger');
 const makeComputedArtifact = require('./computed-artifact.js');
-const ProcessedTrace = require('./processed-trace.js');
-const ProcessedNavigation = require('./processed-navigation.js');
+const LHError = require('../lib/lh-error.js');
+const TraceProcessor = require('../lib/tracehouse/trace-processor.js');
+
+// TraceProcessor throws generic errors, but we'd like our special localized and code-specific LHError
+// objects to be thrown instead.
+class LHTraceProcessor extends TraceProcessor {
+  /**
+   * @return {Error}
+   */
+  static createNoNavstartError() {
+    return new LHError(LHError.errors.NO_NAVSTART);
+  }
+
+  /**
+   * This isn't currently used, but will be when the time origin of trace processing is changed.
+   * @see {TraceProcessor.computeTimeOrigin}
+   * @see https://github.com/GoogleChrome/lighthouse/pull/11253#discussion_r507985527
+   * @return {Error}
+   */
+  static createNoResourceSendRequestError() {
+    return new LHError(LHError.errors.NO_RESOURCE_REQUEST);
+  }
+
+  /**
+   * @return {Error}
+   */
+  static createNoTracingStartedError() {
+    return new LHError(LHError.errors.NO_TRACING_STARTED);
+  }
+}
+
 
 class TraceOfTab {
   /**
-     * @param {LH.Trace} trace
-     * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<any>}
-    */
-  static async compute_(trace, context) {
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-    return {...processedTrace, ...processedNavigation};
+   * Finds key trace events, identifies main process/thread, and returns timings of trace events
+   * in milliseconds since navigation start in addition to the standard microsecond monotonic timestamps.
+   * @param {LH.Trace} trace
+   * @return {Promise<LH.Artifacts.TraceOfTab>}
+  */
+  static async compute_(trace) {
+    // Trace of tab doesn't require FCP to exist, but all of LH requires it.
+    // We'll check that we got an FCP here and re-type accordingly so all of our consumers don't
+    // have to repeat this check.
+    const traceOfTab = await LHTraceProcessor.computeTraceOfTab(trace);
+    const {
+      timings,
+      timestamps,
+      firstContentfulPaintEvt,
+      firstContentfulPaintAllFramesEvt,
+    } = traceOfTab;
+    const {
+      firstContentfulPaint: firstContentfulPaintTiming,
+      firstContentfulPaintAllFrames: firstContentfulPaintAllFramesTiming,
+    } = timings;
+    const {
+      firstContentfulPaint: firstContentfulPaintTs,
+      firstContentfulPaintAllFrames: firstContentfulPaintAllFramesTs,
+    } = timestamps;
+
+    if (
+      !firstContentfulPaintEvt ||
+      firstContentfulPaintTiming === undefined ||
+      firstContentfulPaintTs === undefined ||
+      // FCP-AF will only be undefined if FCP is also undefined.
+      // These conditions are for enforcing types and should never actually trigger.
+      !firstContentfulPaintAllFramesEvt ||
+      firstContentfulPaintAllFramesTiming === undefined ||
+      firstContentfulPaintAllFramesTs === undefined
+    ) {
+      throw new LHError(LHError.errors.NO_FCP);
+    }
+
+    // We already know that `traceOfTab` is good to go at this point, but tsc doesn't yet.
+    // Help tsc out by reconstructing the object manually with the known defined values.
+    return {
+      ...traceOfTab,
+      firstContentfulPaintEvt,
+      firstContentfulPaintAllFramesEvt,
+      timings: {
+        ...timings,
+        firstContentfulPaint: firstContentfulPaintTiming,
+        firstContentfulPaintAllFrames: firstContentfulPaintAllFramesTiming,
+      },
+      timestamps: {
+        ...timestamps,
+        firstContentfulPaint: firstContentfulPaintTs,
+        firstContentfulPaintAllFrames: firstContentfulPaintAllFramesTs,
+      },
+    };
   }
 }
 
-log.warn(`trace-of-tab`, `trace-of-tab is deprecated, use processed-trace / processed-navigation instead`); // eslint-disable-line max-len
 module.exports = makeComputedArtifact(TraceOfTab);
-

package/lighthouse-core/computed/user-timings.js

@@ -6,7 +6,7 @@
 'use strict';
 
 const makeComputedArtifact = require('./computed-artifact.js');
-const ProcessedTrace = require('./processed-trace.js');
+const TraceOfTab = require('./trace-of-tab.js');
 
 /** @typedef {{name: string, isMark: true, args: LH.TraceEvent['args'], startTime: number}} MarkEvent */
 /** @typedef {{name: string, isMark: false, args: LH.TraceEvent['args'], startTime: number, endTime: number, duration: number}} MeasureEvent */
@@ -18,7 +18,7 @@ class UserTimings {
    * @return {Promise<Array<MarkEvent|MeasureEvent>>}
    */
   static async compute_(trace, context) {
-    const processedTrace = await ProcessedTrace.request(trace, context);
+    const traceOfTab = await TraceOfTab.request(trace, context);
     /** @type {Array<MarkEvent|MeasureEvent>} */
     const userTimings = [];
     /** @type {Record<string, number>} */
@@ -28,7 +28,7 @@ class UserTimings {
     // The event phases we are interested in are mark and instant events (R, i, I)
     // and duration events which correspond to measures (B, b, E, e).
     // @see https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview#
-    processedTrace.processEvents.filter(evt => {
+    traceOfTab.processEvents.filter(evt => {
       if (!evt.cat.includes('blink.user_timing')) {
         return false;
       }
@@ -69,9 +69,9 @@ class UserTimings {
 
     // baseline the timestamps against the timeOrigin, and translate to milliseconds
     userTimings.forEach(ut => {
-      ut.startTime = (ut.startTime - processedTrace.timeOriginEvt.ts) / 1000;
+      ut.startTime = (ut.startTime - traceOfTab.timeOriginEvt.ts) / 1000;
       if (!ut.isMark) {
-        ut.endTime = (ut.endTime - processedTrace.timeOriginEvt.ts) / 1000;
+        ut.endTime = (ut.endTime - traceOfTab.timeOriginEvt.ts) / 1000;
         ut.duration = ut.duration / 1000;
       }
     });

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

@@ -146,7 +146,6 @@ const defaultConfig = {
       'iframe-elements',
       'form-elements',
       'main-document-content',
-      'gather-context',
       'global-listeners',
       'dobetterweb/appcache',
       'dobetterweb/doctype',

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

@@ -57,9 +57,9 @@ function resolveWorkingCopy(configJSON, context) {
  * Looks up the required artifact IDs for each dependency, throwing if no earlier artifact satisfies the dependency.
  *
  * @param {LH.Config.ArtifactJson} artifact
- * @param {LH.Config.AnyFRGathererDefn} gatherer
- * @param {Map<Symbol, LH.Config.AnyArtifactDefn>} artifactDefnsBySymbol
- * @return {LH.Config.AnyArtifactDefn['dependencies']}
+ * @param {LH.Config.FRGathererDefn} gatherer
+ * @param {Map<Symbol, LH.Config.ArtifactDefn>} artifactDefnsBySymbol
+ * @return {LH.Config.ArtifactDefn['dependencies']}
  */
 function resolveArtifactDependencies(artifact, gatherer, artifactDefnsBySymbol) {
   if (!('dependencies' in gatherer.instance.meta)) return undefined;
@@ -86,7 +86,7 @@ function resolveArtifactDependencies(artifact, gatherer, artifactDefnsBySymbol)
  *
  * @param {LH.Config.ArtifactJson[]|null|undefined} artifacts
  * @param {string|undefined} configDir
- * @return {LH.Config.AnyArtifactDefn[] | null}
+ * @return {LH.Config.ArtifactDefn[] | null}
  */
 function resolveArtifactsToDefns(artifacts, configDir) {
   if (!artifacts) return null;
@@ -94,7 +94,7 @@ function resolveArtifactsToDefns(artifacts, configDir) {
   const status = {msg: 'Resolve artifact definitions', id: 'lh:config:resolveArtifactsToDefns'};
   log.time(status, 'verbose');
 
-  /** @type {Map<Symbol, LH.Config.AnyArtifactDefn>} */
+  /** @type {Map<Symbol, LH.Config.ArtifactDefn>} */
   const artifactDefnsBySymbol = new Map();
 
   const coreGathererList = Runner.getGathererList();
@@ -108,9 +108,7 @@ function resolveArtifactsToDefns(artifacts, configDir) {
       throw new Error(`${gatherer.instance.name} gatherer does not support Fraggle Rock`);
     }
 
-    /** @type {LH.Config.AnyArtifactDefn} */
-    // @ts-expect-error - Typescript can't validate the gatherer and dependencies match
-    // even though it knows that they're each valid on their own.
+    /** @type {LH.Config.ArtifactDefn<LH.Gatherer.DependencyKey>} */
     const artifact = {
       id: artifactJson.id,
       gatherer,
@@ -129,7 +127,7 @@ function resolveArtifactsToDefns(artifacts, configDir) {
 /**
  *
  * @param {LH.Config.NavigationJson[]|null|undefined} navigations
- * @param {LH.Config.AnyArtifactDefn[]|null|undefined} artifactDefns
+ * @param {LH.Config.ArtifactDefn[]|null|undefined} artifactDefns
  * @return {LH.Config.NavigationDefn[] | null}
  */
 function resolveNavigationsToDefns(navigations, artifactDefns) {

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

@@ -7,29 +7,6 @@
 
 const legacyDefaultConfig = require('../../config/default-config.js');
 
-/** @type {LH.Config.AuditJson[]} */
-const frAudits = [
-  'byte-efficiency/uses-responsive-images-snapshot',
-];
-
-/** @type {Record<string, LH.Config.AuditRefJson[]>} */
-const frCategoryAuditRefExtensions = {
-  'performance': [
-    {id: 'uses-responsive-images-snapshot', weight: 0, group: 'diagnostics'},
-  ],
-};
-
-/** @return {LH.Config.Json['categories']} */
-function mergeCategories() {
-  if (!legacyDefaultConfig.categories) return {};
-  const categories = legacyDefaultConfig.categories;
-  for (const key of Object.keys(frCategoryAuditRefExtensions)) {
-    if (!categories[key]) continue;
-    categories[key].auditRefs.push(...frCategoryAuditRefExtensions[key]);
-  }
-  return categories;
-}
-
 // Ensure all artifact IDs match the typedefs.
 /** @type {Record<keyof LH.FRArtifacts, string>} */
 const artifacts = {
@@ -47,10 +24,7 @@ const artifacts = {
   FontSize: '',
   FormElements: '',
   FullPageScreenshot: '',
-  GatherContext: '',
   GlobalListeners: '',
-  HostFormFactor: '',
-  HostUserAgent: '',
   IFrameElements: '',
   ImageElements: '',
   InstallabilityErrors: '',
@@ -64,8 +38,6 @@ const artifacts = {
   PasswordInputsWithPreventedPaste: '',
   ResponseCompression: '',
   RobotsTxt: '',
-  ServiceWorker: '',
-  ScriptElements: '',
   SourceMaps: '',
   Stacks: '',
   TagsBlockingFirstPaint: '',
@@ -85,8 +57,6 @@ for (const key of Object.keys(artifacts)) {
 const defaultConfig = {
   artifacts: [
     // Artifacts which can be depended on come first.
-    {id: artifacts.HostUserAgent, gatherer: 'host-user-agent'},
-    {id: artifacts.HostFormFactor, gatherer: 'host-form-factor'},
     {id: artifacts.DevtoolsLog, gatherer: 'devtools-log'},
     {id: artifacts.Trace, gatherer: 'trace'},
 
@@ -103,7 +73,6 @@ const defaultConfig = {
     {id: artifacts.FontSize, gatherer: 'seo/font-size'},
     {id: artifacts.FormElements, gatherer: 'form-elements'},
     {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
-    {id: artifacts.GatherContext, gatherer: 'gather-context'},
     {id: artifacts.GlobalListeners, gatherer: 'global-listeners'},
     {id: artifacts.IFrameElements, gatherer: 'iframe-elements'},
     {id: artifacts.ImageElements, gatherer: 'image-elements'},
@@ -118,8 +87,6 @@ const defaultConfig = {
     {id: artifacts.PasswordInputsWithPreventedPaste, gatherer: 'dobetterweb/password-inputs-with-prevented-paste'},
     {id: artifacts.ResponseCompression, gatherer: 'dobetterweb/response-compression'},
     {id: artifacts.RobotsTxt, gatherer: 'seo/robots-txt'},
-    {id: artifacts.ServiceWorker, gatherer: 'service-worker'},
-    {id: artifacts.ScriptElements, gatherer: 'script-elements'},
     {id: artifacts.SourceMaps, gatherer: 'source-maps'},
     {id: artifacts.Stacks, gatherer: 'stacks'},
     {id: artifacts.TagsBlockingFirstPaint, gatherer: 'dobetterweb/tags-blocking-first-paint'},
@@ -142,8 +109,6 @@ const defaultConfig = {
       cpuQuietThresholdMs: 1000,
       artifacts: [
         // Artifacts which can be depended on come first.
-        artifacts.HostUserAgent,
-        artifacts.HostFormFactor,
         artifacts.DevtoolsLog,
         artifacts.Trace,
 
@@ -159,7 +124,6 @@ const defaultConfig = {
         artifacts.FontSize,
         artifacts.FormElements,
         artifacts.FullPageScreenshot,
-        artifacts.GatherContext,
         artifacts.GlobalListeners,
         artifacts.IFrameElements,
         artifacts.ImageElements,
@@ -174,8 +138,6 @@ const defaultConfig = {
         artifacts.PasswordInputsWithPreventedPaste,
         artifacts.ResponseCompression,
         artifacts.RobotsTxt,
-        artifacts.ServiceWorker,
-        artifacts.ScriptElements,
         artifacts.SourceMaps,
         artifacts.Stacks,
         artifacts.TagsBlockingFirstPaint,
@@ -191,8 +153,8 @@ const defaultConfig = {
     },
   ],
   settings: legacyDefaultConfig.settings,
-  audits: [...(legacyDefaultConfig.audits || []), ...frAudits],
-  categories: mergeCategories(),
+  audits: legacyDefaultConfig.audits,
+  categories: legacyDefaultConfig.categories,
   groups: legacyDefaultConfig.groups,
 };
 

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

@@ -7,19 +7,6 @@
 
 const Audit = require('../../audits/audit.js');
 
-/** @type {Record<keyof LH.FRBaseArtifacts, string>} */
-const baseArtifactKeySource = {
-  fetchTime: '',
-  LighthouseRunWarnings: '',
-  BenchmarkIndex: '',
-  settings: '',
-  Timing: '',
-  URL: '',
-  PageLoadError: '',
-};
-
-const baseArtifactKeys = Object.keys(baseArtifactKeySource);
-
 /**
  * Filters an array of artifacts down to the set that supports the specified gather mode.
  *
@@ -38,35 +25,17 @@ function filterArtifactsByGatherMode(artifacts, mode) {
  * Filters an array of audits down to the set that can be computed using only the specified artifacts.
  *
  * @param {LH.Config.FRConfig['audits']} audits
- * @param {Array<LH.Config.AnyArtifactDefn>} availableArtifacts
+ * @param {Array<LH.Config.ArtifactDefn>} availableArtifacts
  * @return {LH.Config.FRConfig['audits']}
  */
 function filterAuditsByAvailableArtifacts(audits, availableArtifacts) {
   if (!audits) return null;
 
-  const availableArtifactIds = new Set(
-    availableArtifacts.map(artifact => artifact.id).concat(baseArtifactKeys)
-  );
-  return audits.filter(audit => {
-    const meta = audit.implementation.meta;
-    return meta.requiredArtifacts.every(id => availableArtifactIds.has(id));
-  });
-}
-
-/**
- * Optional `supportedModes` property can explicitly exclude an audit even if all required artifacts are available.
- *
- * @param {LH.Config.FRConfig['audits']} audits
- * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.FRConfig['audits']}
- */
-function filterAuditsByGatherMode(audits, mode) {
-  if (!audits) return null;
+  const availableAritfactIds = new Set(availableArtifacts.map(artifact => artifact.id));
 
-  return audits.filter(audit => {
-    const meta = audit.implementation.meta;
-    return !meta.supportedModes || meta.supportedModes.includes(mode);
-  });
+  return audits.filter(audit =>
+    audit.implementation.meta.requiredArtifacts.every(id => availableAritfactIds.has(id))
+  );
 }
 
 /**
@@ -117,8 +86,7 @@ function filterCategoriesByAvailableAudits(categories, availableAudits) {
  */
 function filterConfigByGatherMode(config, mode) {
   const artifacts = filterArtifactsByGatherMode(config.artifacts, mode);
-  const availableAudits = filterAuditsByAvailableArtifacts(config.audits, artifacts || []);
-  const audits = filterAuditsByGatherMode(availableAudits, mode);
+  const audits = filterAuditsByAvailableArtifacts(config.audits, artifacts || []);
   const categories = filterCategoriesByAvailableAudits(config.categories, audits || []);
 
   return {
@@ -133,6 +101,5 @@ module.exports = {
   filterConfigByGatherMode,
   filterArtifactsByGatherMode,
   filterAuditsByAvailableArtifacts,
-  filterAuditsByGatherMode,
   filterCategoriesByAvailableAudits,
 };