lighthouse 11.2.0-dev.20231017 → 11.2.0-dev.20231018

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

@@ -21,7 +21,7 @@ import yargs from 'yargs';
 import * as yargsHelpers from 'yargs/helpers';
 import log from 'lighthouse-logger';
 
-import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
+import {runSmokehouse, getShardedDefinitions, DEFAULT_RETRIES, DEFAULT_CONCURRENT_RUNS} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../shared/root.js';
 import exclusions from '../config/exclusions.js';
@@ -139,10 +139,12 @@ async function begin() {
       'jobs': {
         type: 'number',
         alias: 'j',
+        default: DEFAULT_CONCURRENT_RUNS,
         describe: 'Manually set the number of jobs to run at once. `1` runs all tests serially',
       },
       'retries': {
         type: 'number',
+        default: DEFAULT_RETRIES,
         describe: 'The number of times to retry failing tests before accepting. Defaults to 0',
       },
       'runner': {
@@ -164,6 +166,15 @@ async function begin() {
         default: false,
         describe: 'Ignore any smoke test exclusions set.',
       },
+      'headless': {
+        type: 'boolean',
+        default: true,
+        hidden: true,
+      },
+      'no-headless': {
+        type: 'boolean',
+        describe: 'Launch Chrome in typical desktop headful mode, rather than our default of `--headless=new` (https://developer.chrome.com/articles/new-headless/).', // eslint-disable-line max-len
+      },
     })
     .wrap(y.terminalWidth())
     .argv;
@@ -173,9 +184,6 @@ async function begin() {
   const argv =
     /** @type {Awaited<typeof rawArgv> & LH.Util.CamelCasify<Awaited<typeof rawArgv>>} */ (rawArgv);
 
-  const jobs = Number.isFinite(argv.jobs) ? argv.jobs : undefined;
-  const retries = Number.isFinite(argv.retries) ? argv.retries : undefined;
-
   const runnerPath = runnerPaths[/** @type {keyof typeof runnerPaths} */ (argv.runner)];
   if (argv.runner === 'bundle') {
     console.log('\n✨ Be sure to have recently run this: yarn build-all');
@@ -210,9 +218,12 @@ async function begin() {
 
     const prunedTestDefns = pruneExpectedNetworkRequests(testDefns, takeNetworkRequestUrls);
     const options = {
-      jobs,
-      retries,
-      isDebug: argv.debug,
+      jobs: argv.jobs,
+      retries: argv.retries,
+      testRunnerOptions: {
+        isDebug: argv.debug,
+        headless: argv.headless,
+      },
       lighthouseRunner: runLighthouse,
       takeNetworkRequestUrls,
       setup,

package/cli/test/smokehouse/lighthouse-runners/bundle.d.ts

@@ -2,12 +2,10 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
-    isDebug?: boolean;
-} | undefined): Promise<{
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: Smokehouse.SmokehouseOptions['testRunnerOptions'] | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;
     log: string;

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

@@ -46,7 +46,7 @@ if (!isMainThread && parentPort) {
 /**
  * @param {string} url
  * @param {LH.Config|undefined} config
- * @param {{isDebug?: boolean}} testRunnerOptions
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
  */
 async function runBundledLighthouse(url, config, testRunnerOptions) {
@@ -74,12 +74,16 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
   const lighthouse = global.runBundledLighthouse;
 
   // Launch and connect to Chrome.
-  const launchedChrome = await ChromeLauncher.launch();
+  const launchedChrome = await ChromeLauncher.launch({
+    chromeFlags: [
+      testRunnerOptions?.headless ? '--headless=new' : '',
+    ],
+  });
   const port = launchedChrome.port;
 
   // Run Lighthouse.
   try {
-    const logLevel = testRunnerOptions.isDebug ? 'verbose' : 'info';
+    const logLevel = testRunnerOptions?.isDebug ? 'verbose' : 'info';
 
     // Puppeteer is not included in the bundle, we must create the page here.
     const browser = await puppeteer.connect({browserURL: `http://127.0.0.1:${port}`});
@@ -101,7 +105,7 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {

package/cli/test/smokehouse/lighthouse-runners/cli.d.ts

@@ -2,12 +2,10 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
-    isDebug?: boolean | undefined;
-} | undefined): Promise<{
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: Smokehouse.SmokehouseOptions['testRunnerOptions'] | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;
     log: string;

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

@@ -28,7 +28,7 @@ const execFileAsync = promisify(execFile);
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -46,11 +46,11 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
  * @param {string} url
  * @param {string} tmpPath
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean}=} options
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} options
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function internalRun(url, tmpPath, config, options) {
-  const {isDebug = false} = options || {};
+  const {isDebug, headless} = options || {};
   const localConsole = new LocalConsole();
 
   const outputPath = `${tmpPath}/smokehouse.report.json`;
@@ -67,6 +67,8 @@ async function internalRun(url, tmpPath, config, options) {
     '--quiet',
   ];
 
+  if (headless) args.push('--chrome-flags="--headless=new"');
+
   // Config can be optionally provided.
   if (config) {
     const configPath = `${tmpPath}/config.json`;

package/cli/test/smokehouse/lighthouse-runners/devtools.d.ts

@@ -5,9 +5,10 @@
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-export function runLighthouse(url: string, config?: LH.Config | undefined): Promise<{
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: Smokehouse.SmokehouseOptions['testRunnerOptions'] | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;
     log: string;

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

@@ -40,10 +40,12 @@ async function setup() {
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-async function runLighthouse(url, config) {
+async function runLighthouse(url, config, testRunnerOptions) {
   const chromeFlags = [
+    testRunnerOptions?.headless ? '--headless=new' : '',
     `--custom-devtools-frontend=file://${devtoolsDir}/out/LighthouseIntegration/gen/front_end`,
   ];
   const {lhr, artifacts, logs} = await testUrlFromDevtools(url, {

package/cli/test/smokehouse/smokehouse.d.ts

@@ -14,10 +14,10 @@ export type SmokehouseResult = {
 /**
  * Runs the selected smoke tests. Returns whether all assertions pass.
  * @param {Array<Smokehouse.TestDfn>} smokeTestDefns
- * @param {Smokehouse.SmokehouseOptions} smokehouseOptions
+ * @param {Partial<Smokehouse.SmokehouseOptions>} smokehouseOptions
  * @return {Promise<{success: boolean, testResults: SmokehouseResult[]}>}
  */
-export function runSmokehouse(smokeTestDefns: Array<Smokehouse.TestDfn>, smokehouseOptions: Smokehouse.SmokehouseOptions): Promise<{
+export function runSmokehouse(smokeTestDefns: Array<Smokehouse.TestDfn>, smokehouseOptions: Partial<Smokehouse.SmokehouseOptions>): Promise<{
     success: boolean;
     testResults: SmokehouseResult[];
 }>;
@@ -31,4 +31,6 @@ export function runSmokehouse(smokeTestDefns: Array<Smokehouse.TestDfn>, smokeho
  * @return {Array<Smokehouse.TestDfn>}
  */
 export function getShardedDefinitions(testDefns: Array<Smokehouse.TestDfn>, shardArg?: string | undefined): Array<Smokehouse.TestDfn>;
+export const DEFAULT_RETRIES: 0;
+export const DEFAULT_CONCURRENT_RUNS: 5;
 //# sourceMappingURL=smokehouse.d.ts.map

package/cli/test/smokehouse/smokehouse.js

@@ -46,12 +46,12 @@ const DEFAULT_RETRIES = 0;
 /**
  * Runs the selected smoke tests. Returns whether all assertions pass.
  * @param {Array<Smokehouse.TestDfn>} smokeTestDefns
- * @param {Smokehouse.SmokehouseOptions} smokehouseOptions
+ * @param {Partial<Smokehouse.SmokehouseOptions>} smokehouseOptions
  * @return {Promise<{success: boolean, testResults: SmokehouseResult[]}>}
  */
 async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
   const {
-    isDebug,
+    testRunnerOptions,
     jobs = DEFAULT_CONCURRENT_RUNS,
     retries = DEFAULT_RETRIES,
     lighthouseRunner = Object.assign(cliLighthouseRunner, {runnerName: 'cli'}),
@@ -73,7 +73,8 @@ async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
   const concurrentMapper = new ConcurrentMapper();
 
   const testOptions = {
-    isDebug,
+    testRunnerOptions,
+    jobs,
     retries,
     lighthouseRunner,
     takeNetworkRequestUrls,
@@ -133,7 +134,7 @@ function purpleify(str) {
 /**
  * Run Lighthouse in the selected runner.
  * @param {Smokehouse.TestDfn} smokeTestDefn
- * @param {{isDebug?: boolean, retries: number, lighthouseRunner: Smokehouse.LighthouseRunner, takeNetworkRequestUrls?: () => string[]}} testOptions
+ * @param {Smokehouse.SmokehouseOptions} testOptions
  * @return {Promise<SmokehouseResult>}
  */
 async function runSmokeTest(smokeTestDefn, testOptions) {
@@ -141,7 +142,7 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
   const {
     lighthouseRunner,
     retries,
-    isDebug,
+    testRunnerOptions,
     takeNetworkRequestUrls,
   } = testOptions;
   const requestedUrl = expectations.lhr.requestedUrl;
@@ -163,7 +164,7 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     // Run Lighthouse.
     try {
       result = {
-        ...await lighthouseRunner(requestedUrl, config, {isDebug}),
+        ...await lighthouseRunner(requestedUrl, config, testRunnerOptions),
         networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
       };
 
@@ -183,7 +184,7 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     // Assert result.
     report = getAssertionReport(result, expectations, {
       runner: lighthouseRunner.runnerName,
-      isDebug,
+      ...testRunnerOptions,
     });
 
     runs.push({
@@ -310,4 +311,6 @@ function getShardedDefinitions(testDefns, shardArg) {
 export {
   runSmokehouse,
   getShardedDefinitions,
+  DEFAULT_RETRIES,
+  DEFAULT_CONCURRENT_RUNS,
 };

package/core/config/config.d.ts

@@ -14,11 +14,10 @@ export function resolveWorkingCopy(config: LH.Config | undefined, context: {
  * @param {LH.Gatherer.GatherMode} gatherMode
  * @param {LH.Config=} config
  * @param {LH.Flags=} flags
- * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig, warnings: string[]}>}
+ * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig}>}
  */
 export function initializeConfig(gatherMode: LH.Gatherer.GatherMode, config?: LH.Config | undefined, flags?: LH.Flags | undefined): Promise<{
     resolvedConfig: LH.Config.ResolvedConfig;
-    warnings: string[];
 }>;
 /**
  * @param {LH.Config.ResolvedConfig} resolvedConfig

package/core/config/config.js

@@ -10,12 +10,11 @@ import log from 'lighthouse-logger';
 
 import {Runner} from '../runner.js';
 import defaultConfig from './default-config.js';
-import {defaultNavigationConfig, nonSimulatedPassConfigOverrides} from './constants.js'; // eslint-disable-line max-len
+import {nonSimulatedSettingsOverrides} from './constants.js'; // eslint-disable-line max-len
 import {
   throwInvalidDependencyOrder,
   isValidArtifactDependency,
   throwInvalidArtifactDependency,
-  assertArtifactTopologicalOrder,
   assertValidConfig,
 } from './validation.js';
 import {filterConfigByGatherMode, filterConfigByExplicitFilters} from './filters.js';
@@ -192,66 +191,34 @@ function overrideSettingsForGatherMode(settings, gatherMode) {
 /**
  * Overrides the quiet windows when throttlingMethod requires observation.
  *
- * @param {LH.Config.NavigationDefn} navigation
  * @param {LH.Config.Settings} settings
  */
-function overrideNavigationThrottlingWindows(navigation, settings) {
-  if (navigation.disableThrottling) return;
+function overrideThrottlingWindows(settings) {
   if (settings.throttlingMethod === 'simulate') return;
 
-  navigation.cpuQuietThresholdMs = Math.max(
-    navigation.cpuQuietThresholdMs || 0,
-    nonSimulatedPassConfigOverrides.cpuQuietThresholdMs
+  settings.cpuQuietThresholdMs = Math.max(
+    settings.cpuQuietThresholdMs || 0,
+    nonSimulatedSettingsOverrides.cpuQuietThresholdMs
   );
-  navigation.networkQuietThresholdMs = Math.max(
-    navigation.networkQuietThresholdMs || 0,
-    nonSimulatedPassConfigOverrides.networkQuietThresholdMs
+  settings.networkQuietThresholdMs = Math.max(
+    settings.networkQuietThresholdMs || 0,
+    nonSimulatedSettingsOverrides.networkQuietThresholdMs
   );
-  navigation.pauseAfterFcpMs = Math.max(
-    navigation.pauseAfterFcpMs || 0,
-    nonSimulatedPassConfigOverrides.pauseAfterFcpMs
+  settings.pauseAfterFcpMs = Math.max(
+    settings.pauseAfterFcpMs || 0,
+    nonSimulatedSettingsOverrides.pauseAfterFcpMs
   );
-  navigation.pauseAfterLoadMs = Math.max(
-    navigation.pauseAfterLoadMs || 0,
-    nonSimulatedPassConfigOverrides.pauseAfterLoadMs
+  settings.pauseAfterLoadMs = Math.max(
+    settings.pauseAfterLoadMs || 0,
+    nonSimulatedSettingsOverrides.pauseAfterLoadMs
   );
 }
 
-/**
- * @param {LH.Config.AnyArtifactDefn[]|null|undefined} artifactDefns
- * @param {LH.Config.Settings} settings
- * @return {LH.Config.NavigationDefn[] | null}
- */
-function resolveFakeNavigations(artifactDefns, settings) {
-  if (!artifactDefns) return null;
-
-  const status = {msg: 'Resolve navigation definitions', id: 'lh:config:resolveNavigationsToDefns'};
-  log.time(status, 'verbose');
-
-  const resolvedNavigation = {
-    ...defaultNavigationConfig,
-    artifacts: artifactDefns,
-    pauseAfterFcpMs: settings.pauseAfterFcpMs,
-    pauseAfterLoadMs: settings.pauseAfterLoadMs,
-    networkQuietThresholdMs: settings.networkQuietThresholdMs,
-    cpuQuietThresholdMs: settings.cpuQuietThresholdMs,
-    blankPage: settings.blankPage,
-  };
-
-  overrideNavigationThrottlingWindows(resolvedNavigation, settings);
-
-  const navigations = [resolvedNavigation];
-  assertArtifactTopologicalOrder(navigations);
-
-  log.timeEnd(status);
-  return navigations;
-}
-
 /**
  * @param {LH.Gatherer.GatherMode} gatherMode
  * @param {LH.Config=} config
  * @param {LH.Flags=} flags
- * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig, warnings: string[]}>}
+ * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig}>}
  */
 async function initializeConfig(gatherMode, config, flags = {}) {
   const status = {msg: 'Initialize config', id: 'lh:config'};
@@ -264,28 +231,26 @@ async function initializeConfig(gatherMode, config, flags = {}) {
 
   const settings = resolveSettings(configWorkingCopy.settings || {}, flags);
   overrideSettingsForGatherMode(settings, gatherMode);
+  overrideThrottlingWindows(settings);
 
   const artifacts = await resolveArtifactsToDefns(configWorkingCopy.artifacts, configDir);
 
-  const navigations = resolveFakeNavigations(artifacts, settings);
-
   /** @type {LH.Config.ResolvedConfig} */
   let resolvedConfig = {
     artifacts,
-    navigations,
     audits: await resolveAuditsToDefns(configWorkingCopy.audits, configDir),
     categories: configWorkingCopy.categories || null,
     groups: configWorkingCopy.groups || null,
     settings,
   };
 
-  const {warnings} = assertValidConfig(resolvedConfig);
+  assertValidConfig(resolvedConfig);
 
   resolvedConfig = filterConfigByGatherMode(resolvedConfig, gatherMode);
   resolvedConfig = filterConfigByExplicitFilters(resolvedConfig, settings);
 
   log.timeEnd(status);
-  return {resolvedConfig, warnings};
+  return {resolvedConfig};
 }
 
 /**
@@ -296,15 +261,6 @@ function getConfigDisplayString(resolvedConfig) {
   /** @type {LH.Config.ResolvedConfig} */
   const resolvedConfigCopy = JSON.parse(JSON.stringify(resolvedConfig));
 
-  if (resolvedConfigCopy.navigations) {
-    for (const navigation of resolvedConfigCopy.navigations) {
-      for (let i = 0; i < navigation.artifacts.length; ++i) {
-        // @ts-expect-error Breaking the Config.AnyArtifactDefn type.
-        navigation.artifacts[i] = navigation.artifacts[i].id;
-      }
-    }
-  }
-
   if (resolvedConfigCopy.artifacts) {
     for (const artifactDefn of resolvedConfigCopy.artifacts) {
       // @ts-expect-error Breaking the Config.AnyArtifactDefn type.

package/core/config/constants.d.ts

@@ -48,9 +48,7 @@ export namespace userAgents {
 }
 /** @type {LH.Config.Settings} */
 export const defaultSettings: LH.Config.Settings;
-/** @type {Required<LH.Config.NavigationJson>} */
-export const defaultNavigationConfig: Required<LH.Config.NavigationJson>;
-export namespace nonSimulatedPassConfigOverrides {
+export namespace nonSimulatedSettingsOverrides {
     const pauseAfterFcpMs: number;
     const pauseAfterLoadMs: number;
     const networkQuietThresholdMs: number;

package/core/config/constants.js

@@ -127,22 +127,7 @@ const defaultSettings = {
   skipAudits: null,
 };
 
-/** @type {Required<LH.Config.NavigationJson>} */
-const defaultNavigationConfig = {
-  id: 'defaultPass',
-  loadFailureMode: 'fatal',
-  disableThrottling: false,
-  disableStorageReset: false,
-  pauseAfterFcpMs: 0,
-  pauseAfterLoadMs: 0,
-  networkQuietThresholdMs: 0,
-  cpuQuietThresholdMs: 0,
-  blockedUrlPatterns: [],
-  blankPage: 'about:blank',
-  artifacts: [],
-};
-
-const nonSimulatedPassConfigOverrides = {
+const nonSimulatedSettingsOverrides = {
   pauseAfterFcpMs: 5250,
   pauseAfterLoadMs: 5250,
   networkQuietThresholdMs: 5250,
@@ -154,6 +139,5 @@ export {
   screenEmulationMetrics,
   userAgents,
   defaultSettings,
-  defaultNavigationConfig,
-  nonSimulatedPassConfigOverrides,
+  nonSimulatedSettingsOverrides,
 };

package/core/config/filters.d.ts

@@ -31,14 +31,6 @@ export function filterArtifactsByGatherMode(artifacts: LH.Config.ResolvedConfig[
  * @return {LH.Config.ResolvedConfig['artifacts']}
  */
 export function filterArtifactsByAvailableAudits(artifacts: LH.Config.ResolvedConfig['artifacts'], audits: LH.Config.ResolvedConfig['audits']): LH.Config.ResolvedConfig['artifacts'];
-/**
- * Filters an array of navigations down to the set supported by the available artifacts.
- *
- * @param {LH.Config.ResolvedConfig['navigations']} navigations
- * @param {Array<LH.Config.AnyArtifactDefn>} availableArtifacts
- * @return {LH.Config.ResolvedConfig['navigations']}
- */
-export function filterNavigationsByAvailableArtifacts(navigations: LH.Config.ResolvedConfig['navigations'], availableArtifacts: Array<LH.Config.AnyArtifactDefn>): LH.Config.ResolvedConfig['navigations'];
 /**
  * Filters an array of audits down to the set that can be computed using only the specified artifacts.
  *

package/core/config/filters.js

@@ -107,30 +107,6 @@ function filterArtifactsByGatherMode(artifacts, mode) {
   });
 }
 
-/**
- * Filters an array of navigations down to the set supported by the available artifacts.
- *
- * @param {LH.Config.ResolvedConfig['navigations']} navigations
- * @param {Array<LH.Config.AnyArtifactDefn>} availableArtifacts
- * @return {LH.Config.ResolvedConfig['navigations']}
- */
-function filterNavigationsByAvailableArtifacts(navigations, availableArtifacts) {
-  if (!navigations) return navigations;
-
-  const availableArtifactIds = new Set(
-    availableArtifacts.map(artifact => artifact.id).concat(baseArtifactKeys)
-  );
-
-  return navigations
-    .map(navigation => {
-      return {
-        ...navigation,
-        artifacts: navigation.artifacts.filter((artifact) => availableArtifactIds.has(artifact.id)),
-      };
-    })
-    .filter(navigation => navigation.artifacts.length);
-}
-
 /**
  * Filters an array of audits down to the set that can be computed using only the specified artifacts.
  *
@@ -318,13 +294,10 @@ function filterConfigByExplicitFilters(resolvedConfig, filters) {
   if (artifacts && resolvedConfig.settings.disableFullPageScreenshot) {
     artifacts = artifacts.filter(({id}) => id !== 'FullPageScreenshot');
   }
-  const navigations =
-    filterNavigationsByAvailableArtifacts(resolvedConfig.navigations, artifacts || []);
 
   return {
     ...resolvedConfig,
     artifacts,
-    navigations,
     audits,
     categories,
   };
@@ -335,7 +308,6 @@ export {
   filterConfigByExplicitFilters,
   filterArtifactsByGatherMode,
   filterArtifactsByAvailableAudits,
-  filterNavigationsByAvailableArtifacts,
   filterAuditsByAvailableArtifacts,
   filterAuditsByGatherMode,
   filterCategoriesByAvailableAudits,

package/core/config/validation.d.ts

@@ -19,14 +19,6 @@ export function assertValidPluginName(config: LH.Config, pluginName: string): vo
  * @param {LH.Config.AnyArtifactDefn} artifactDefn
  */
 export function assertValidArtifact(artifactDefn: LH.Config.AnyArtifactDefn): void;
-/**
- * Throws an error if the provided object does not implement the required navigations interface.
- * @param {LH.Config.ResolvedConfig['navigations']} navigationsDefn
- * @return {{warnings: string[]}}
- */
-export function assertValidNavigations(navigationsDefn: LH.Config.ResolvedConfig['navigations']): {
-    warnings: string[];
-};
 /**
  * Throws an error if the provided object does not implement the required properties of an audit
  * definition.
@@ -45,18 +37,15 @@ export function assertValidCategories(categories: LH.Config.ResolvedConfig['cate
  */
 export function assertValidSettings(settings: LH.Config.Settings): void;
 /**
- * Asserts that artifacts are in a valid dependency order that can be computed.
+ * Asserts that artifacts are unique, valid and are in a dependency order that can be computed.
  *
- * @param {Array<LH.Config.NavigationDefn>} navigations
+ * @param {Array<LH.Config.AnyArtifactDefn>} artifactDefns
  */
-export function assertArtifactTopologicalOrder(navigations: Array<LH.Config.NavigationDefn>): void;
+export function assertValidArtifacts(artifactDefns: Array<LH.Config.AnyArtifactDefn>): void;
 /**
  * @param {LH.Config.ResolvedConfig} resolvedConfig
- * @return {{warnings: string[]}}
  */
-export function assertValidConfig(resolvedConfig: LH.Config.ResolvedConfig): {
-    warnings: string[];
-};
+export function assertValidConfig(resolvedConfig: LH.Config.ResolvedConfig): void;
 /**
  * @param {string} artifactId
  * @param {string} dependencyKey