lighthouse 9.5.0-dev.20230102 → 9.5.0-dev.20230104

package/core/config/config-helpers.js

@@ -120,7 +120,7 @@ const mergeConfigFragment = _mergeConfigFragment;
  * Merge an array of items by a caller-defined key. `mergeConfigFragment` is used to merge any items
  * with a matching key.
  *
- * @template T
+ * @template {Record<string, any>} T
  * @param {Array<T>|null|undefined} baseArray
  * @param {Array<T>|null|undefined} extensionArray
  * @param {(item: T) => string} keyFn

package/core/config/config.js

@@ -238,7 +238,7 @@ function resolveFakeNavigations(artifactDefns, settings) {
  * @param {LH.Gatherer.GatherMode} gatherMode
  * @param {LH.Config.Json=} configJSON
  * @param {LH.Flags=} flags
- * @return {Promise<{config: LH.Config.FRConfig, warnings: string[]}>}
+ * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig, warnings: string[]}>}
  */
 async function initializeConfig(gatherMode, configJSON, flags = {}) {
   const status = {msg: 'Initialize config', id: 'lh:config'};
@@ -256,8 +256,8 @@ async function initializeConfig(gatherMode, configJSON, flags = {}) {
 
   const navigations = resolveFakeNavigations(artifacts, settings);
 
-  /** @type {LH.Config.FRConfig} */
-  let config = {
+  /** @type {LH.Config.ResolvedConfig} */
+  let resolvedConfig = {
     artifacts,
     navigations,
     audits: await resolveAuditsToDefns(configWorkingCopy.audits, configDir),
@@ -266,25 +266,25 @@ async function initializeConfig(gatherMode, configJSON, flags = {}) {
     settings,
   };
 
-  const {warnings} = assertValidConfig(config);
+  const {warnings} = assertValidConfig(resolvedConfig);
 
-  config = filterConfigByGatherMode(config, gatherMode);
-  config = filterConfigByExplicitFilters(config, settings);
+  resolvedConfig = filterConfigByGatherMode(resolvedConfig, gatherMode);
+  resolvedConfig = filterConfigByExplicitFilters(resolvedConfig, settings);
 
   log.timeEnd(status);
-  return {config, warnings};
+  return {resolvedConfig, warnings};
 }
 
 /**
- * @param {LH.Config.FRConfig} config
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
  * @return {string}
  */
-function getConfigDisplayString(config) {
-  /** @type {LH.Config.FRConfig} */
-  const jsonConfig = JSON.parse(JSON.stringify(config));
+function getConfigDisplayString(resolvedConfig) {
+  /** @type {LH.Config.ResolvedConfig} */
+  const resolvedConfigCopy = JSON.parse(JSON.stringify(resolvedConfig));
 
-  if (jsonConfig.navigations) {
-    for (const navigation of jsonConfig.navigations) {
+  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;
@@ -292,8 +292,8 @@ function getConfigDisplayString(config) {
     }
   }
 
-  if (jsonConfig.artifacts) {
-    for (const artifactDefn of jsonConfig.artifacts) {
+  if (resolvedConfigCopy.artifacts) {
+    for (const artifactDefn of resolvedConfigCopy.artifacts) {
       // @ts-expect-error Breaking the Config.AnyArtifactDefn type.
       artifactDefn.gatherer = artifactDefn.gatherer.path;
       // Dependencies are not declared on Config JSON
@@ -301,8 +301,8 @@ function getConfigDisplayString(config) {
     }
   }
 
-  if (jsonConfig.audits) {
-    for (const auditDefn of jsonConfig.audits) {
+  if (resolvedConfigCopy.audits) {
+    for (const auditDefn of resolvedConfigCopy.audits) {
       // @ts-expect-error Breaking the Config.AuditDefn type.
       auditDefn.implementation = undefined;
       if (Object.keys(auditDefn.options).length === 0) {
@@ -313,9 +313,9 @@ function getConfigDisplayString(config) {
   }
 
   // Printed config is more useful with localized strings.
-  format.replaceIcuMessages(jsonConfig, jsonConfig.settings.locale);
+  format.replaceIcuMessages(resolvedConfigCopy, resolvedConfigCopy.settings.locale);
 
-  return JSON.stringify(jsonConfig, null, 2);
+  return JSON.stringify(resolvedConfigCopy, null, 2);
 }
 
 export {

package/core/config/filters.js

@@ -39,7 +39,7 @@ const filterResistantArtifactIds = ['Stacks', 'NetworkUserAgent'];
  * If `onlyCategories` is not set, this function returns the list of all audit IDs across all
  * categories.
  *
- * @param {LH.Config.FRConfig['categories']} allCategories
+ * @param {LH.Config.ResolvedConfig['categories']} allCategories
  * @param {string[] | undefined} onlyCategories
  * @return {Set<string>}
  */
@@ -55,9 +55,9 @@ function getAuditIdsInCategories(allCategories, onlyCategories) {
 /**
  * Filters an array of artifacts down to the set that's required by the specified audits.
  *
- * @param {LH.Config.FRConfig['artifacts']} artifacts
- * @param {LH.Config.FRConfig['audits']} audits
- * @return {LH.Config.FRConfig['artifacts']}
+ * @param {LH.Config.ResolvedConfig['artifacts']} artifacts
+ * @param {LH.Config.ResolvedConfig['audits']} audits
+ * @return {LH.Config.ResolvedConfig['artifacts']}
  */
 function filterArtifactsByAvailableAudits(artifacts, audits) {
   if (!artifacts) return null;
@@ -95,9 +95,9 @@ function filterArtifactsByAvailableAudits(artifacts, audits) {
 /**
  * Filters an array of artifacts down to the set that supports the specified gather mode.
  *
- * @param {LH.Config.FRConfig['artifacts']} artifacts
+ * @param {LH.Config.ResolvedConfig['artifacts']} artifacts
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.FRConfig['artifacts']}
+ * @return {LH.Config.ResolvedConfig['artifacts']}
  */
 function filterArtifactsByGatherMode(artifacts, mode) {
   if (!artifacts) return null;
@@ -109,9 +109,9 @@ function filterArtifactsByGatherMode(artifacts, mode) {
 /**
  * Filters an array of navigations down to the set supported by the available artifacts.
  *
- * @param {LH.Config.FRConfig['navigations']} navigations
+ * @param {LH.Config.ResolvedConfig['navigations']} navigations
  * @param {Array<LH.Config.AnyArtifactDefn>} availableArtifacts
- * @return {LH.Config.FRConfig['navigations']}
+ * @return {LH.Config.ResolvedConfig['navigations']}
  */
 function filterNavigationsByAvailableArtifacts(navigations, availableArtifacts) {
   if (!navigations) return navigations;
@@ -133,9 +133,9 @@ function filterNavigationsByAvailableArtifacts(navigations, availableArtifacts)
 /**
  * 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 {LH.Config.ResolvedConfig['audits']} audits
  * @param {Array<LH.Config.AnyArtifactDefn>} availableArtifacts
- * @return {LH.Config.FRConfig['audits']}
+ * @return {LH.Config.ResolvedConfig['audits']}
  */
 function filterAuditsByAvailableArtifacts(audits, availableArtifacts) {
   if (!audits) return null;
@@ -152,9 +152,9 @@ function filterAuditsByAvailableArtifacts(audits, availableArtifacts) {
 /**
  * Optional `supportedModes` property can explicitly exclude an audit even if all required artifacts are available.
  *
- * @param {LH.Config.FRConfig['audits']} audits
+ * @param {LH.Config.ResolvedConfig['audits']} audits
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.FRConfig['audits']}
+ * @return {LH.Config.ResolvedConfig['audits']}
  */
 function filterAuditsByGatherMode(audits, mode) {
   if (!audits) return null;
@@ -168,9 +168,9 @@ function filterAuditsByGatherMode(audits, mode) {
 /**
  * Optional `supportedModes` property can explicitly exclude a category even if some audits are available.
  *
- * @param {LH.Config.Config['categories']} categories
+ * @param {LH.Config.LegacyResolvedConfig['categories']} categories
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.Config['categories']}
+ * @return {LH.Config.LegacyResolvedConfig['categories']}
  */
 function filterCategoriesByGatherMode(categories, mode) {
   if (!categories) return null;
@@ -185,9 +185,9 @@ function filterCategoriesByGatherMode(categories, mode) {
 /**
  * Filters a categories object and their auditRefs down to the specified category ids.
  *
- * @param {LH.Config.Config['categories']} categories
+ * @param {LH.Config.LegacyResolvedConfig['categories']} categories
  * @param {string[] | null | undefined} onlyCategories
- * @return {LH.Config.Config['categories']}
+ * @return {LH.Config.LegacyResolvedConfig['categories']}
  */
 function filterCategoriesByExplicitFilters(categories, onlyCategories) {
   if (!categories || !onlyCategories) return categories;
@@ -201,7 +201,7 @@ function filterCategoriesByExplicitFilters(categories, onlyCategories) {
  * Logs a warning if any specified onlyCategory is not a known category that can
  * be included.
  *
- * @param {LH.Config.Config['categories']} allCategories
+ * @param {LH.Config.LegacyResolvedConfig['categories']} allCategories
  * @param {string[] | null} onlyCategories
  * @return {void}
  */
@@ -219,9 +219,9 @@ function warnOnUnknownOnlyCategories(allCategories, onlyCategories) {
  * Filters a categories object and their auditRefs down to the set that can be computed using
  * only the specified audits.
  *
- * @param {LH.Config.Config['categories']} categories
+ * @param {LH.Config.LegacyResolvedConfig['categories']} categories
  * @param {Array<LH.Config.AuditDefn>} availableAudits
- * @return {LH.Config.Config['categories']}
+ * @return {LH.Config.LegacyResolvedConfig['categories']}
  */
 function filterCategoriesByAvailableAudits(categories, availableAudits) {
   if (!categories) return categories;
@@ -257,19 +257,19 @@ function filterCategoriesByAvailableAudits(categories, availableAudits) {
 /**
  * Filters a config's artifacts, audits, and categories down to the set that supports the specified gather mode.
  *
- * @param {LH.Config.FRConfig} config
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
  * @param {LH.Gatherer.GatherMode} mode
- * @return {LH.Config.FRConfig}
+ * @return {LH.Config.ResolvedConfig}
  */
-function filterConfigByGatherMode(config, mode) {
-  const artifacts = filterArtifactsByGatherMode(config.artifacts, mode);
-  const supportedAudits = filterAuditsByGatherMode(config.audits, mode);
+function filterConfigByGatherMode(resolvedConfig, mode) {
+  const artifacts = filterArtifactsByGatherMode(resolvedConfig.artifacts, mode);
+  const supportedAudits = filterAuditsByGatherMode(resolvedConfig.audits, mode);
   const audits = filterAuditsByAvailableArtifacts(supportedAudits, artifacts || []);
-  const supportedCategories = filterCategoriesByGatherMode(config.categories, mode);
+  const supportedCategories = filterCategoriesByGatherMode(resolvedConfig.categories, mode);
   const categories = filterCategoriesByAvailableAudits(supportedCategories, audits || []);
 
   return {
-    ...config,
+    ...resolvedConfig,
     artifacts,
     audits,
     categories,
@@ -280,22 +280,22 @@ function filterConfigByGatherMode(config, mode) {
  * Filters a config's artifacts, audits, and categories down to the requested set.
  * Skip audits overrides inclusion via `onlyAudits`/`onlyCategories`.
  *
- * @param {LH.Config.FRConfig} config
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
  * @param {Pick<LH.Config.Settings, 'onlyAudits'|'onlyCategories'|'skipAudits'>} filters
- * @return {LH.Config.FRConfig}
+ * @return {LH.Config.ResolvedConfig}
  */
-function filterConfigByExplicitFilters(config, filters) {
+function filterConfigByExplicitFilters(resolvedConfig, filters) {
   const {onlyAudits, onlyCategories, skipAudits} = filters;
 
-  warnOnUnknownOnlyCategories(config.categories, onlyCategories);
+  warnOnUnknownOnlyCategories(resolvedConfig.categories, onlyCategories);
 
-  let baseAuditIds = getAuditIdsInCategories(config.categories, undefined);
+  let baseAuditIds = getAuditIdsInCategories(resolvedConfig.categories, undefined);
   if (onlyCategories) {
-    baseAuditIds = getAuditIdsInCategories(config.categories, onlyCategories);
+    baseAuditIds = getAuditIdsInCategories(resolvedConfig.categories, onlyCategories);
   } else if (onlyAudits) {
     baseAuditIds = new Set();
-  } else if (!config.categories || !Object.keys(config.categories).length) {
-    baseAuditIds = new Set(config.audits?.map(audit => audit.implementation.meta.id));
+  } else if (!resolvedConfig.categories || !Object.keys(resolvedConfig.categories).length) {
+    baseAuditIds = new Set(resolvedConfig.audits?.map(audit => audit.implementation.meta.id));
   }
 
   const auditIdsToKeep = new Set(
@@ -306,17 +306,19 @@ function filterConfigByExplicitFilters(config, filters) {
     ].filter(auditId => !skipAudits || !skipAudits.includes(auditId))
   );
 
-  const audits = auditIdsToKeep.size && config.audits ?
-    config.audits.filter(audit => auditIdsToKeep.has(audit.implementation.meta.id)) :
-    config.audits;
+  const audits = auditIdsToKeep.size && resolvedConfig.audits ?
+    resolvedConfig.audits.filter(audit => auditIdsToKeep.has(audit.implementation.meta.id)) :
+    resolvedConfig.audits;
 
-  const availableCategories = filterCategoriesByAvailableAudits(config.categories, audits || []);
+  const availableCategories =
+    filterCategoriesByAvailableAudits(resolvedConfig.categories, audits || []);
   const categories = filterCategoriesByExplicitFilters(availableCategories, onlyCategories);
-  const artifacts = filterArtifactsByAvailableAudits(config.artifacts, audits);
-  const navigations = filterNavigationsByAvailableArtifacts(config.navigations, artifacts || []);
+  const artifacts = filterArtifactsByAvailableAudits(resolvedConfig.artifacts, audits);
+  const navigations =
+    filterNavigationsByAvailableArtifacts(resolvedConfig.navigations, artifacts || []);
 
   return {
-    ...config,
+    ...resolvedConfig,
     artifacts,
     navigations,
     audits,

package/core/config/validation.js

@@ -79,7 +79,7 @@ function assertValidFRGatherer(gathererDefn) {
 
 /**
  * Throws an error if the provided object does not implement the required navigations interface.
- * @param {LH.Config.FRConfig['navigations']} navigationsDefn
+ * @param {LH.Config.ResolvedConfig['navigations']} navigationsDefn
  * @return {{warnings: string[]}}
  */
 function assertValidFRNavigations(navigationsDefn) {
@@ -164,9 +164,9 @@ function assertValidAudit(auditDefinition) {
 }
 
 /**
- * @param {LH.Config.FRConfig['categories']} categories
- * @param {LH.Config.FRConfig['audits']} audits
- * @param {LH.Config.FRConfig['groups']} groups
+ * @param {LH.Config.ResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['audits']} audits
+ * @param {LH.Config.ResolvedConfig['groups']} groups
  */
 function assertValidCategories(categories, audits, groups) {
   if (!categories) {
@@ -247,22 +247,22 @@ function assertArtifactTopologicalOrder(navigations) {
 }
 
 /**
- * @param {LH.Config.FRConfig} config
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
  * @return {{warnings: string[]}}
  */
-function assertValidConfig(config) {
-  const {warnings} = assertValidFRNavigations(config.navigations);
+function assertValidConfig(resolvedConfig) {
+  const {warnings} = assertValidFRNavigations(resolvedConfig.navigations);
 
-  for (const artifactDefn of config.artifacts || []) {
+  for (const artifactDefn of resolvedConfig.artifacts || []) {
     assertValidFRGatherer(artifactDefn.gatherer);
   }
 
-  for (const auditDefn of config.audits || []) {
+  for (const auditDefn of resolvedConfig.audits || []) {
     assertValidAudit(auditDefn);
   }
 
-  assertValidCategories(config.categories, config.audits, config.groups);
-  assertValidSettings(config.settings);
+  assertValidCategories(resolvedConfig.categories, resolvedConfig.audits, resolvedConfig.groups);
+  assertValidSettings(resolvedConfig.settings);
   return {warnings};
 }
 

package/core/gather/base-artifacts.js

@@ -12,12 +12,12 @@ import {
 } from './driver/environment.js';
 
 /**
- * @param {LH.Config.FRConfig} config
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
  * @param {LH.Gatherer.FRTransitionalDriver} driver
  * @param {{gatherMode: LH.Gatherer.GatherMode}} context
  * @return {Promise<LH.BaseArtifacts>}
  */
-async function getBaseArtifacts(config, driver, context) {
+async function getBaseArtifacts(resolvedConfig, driver, context) {
   const BenchmarkIndex = await getBenchmarkIndex(driver.executionContext);
   const {userAgent} = await getBrowserVersion(driver.defaultSession);
 
@@ -26,7 +26,7 @@ async function getBaseArtifacts(config, driver, context) {
     fetchTime: new Date().toJSON(),
     Timing: [],
     LighthouseRunWarnings: [],
-    settings: config.settings,
+    settings: resolvedConfig.settings,
     // Environment artifacts that can always be computed.
     BenchmarkIndex,
     HostUserAgent: userAgent,

package/core/gather/driver/prepare.js

@@ -70,6 +70,7 @@ async function dismissJavaScriptDialogs(session) {
 }
 
 /**
+ * Reset the storage and warn if any stored data could be affecting the scores.
  * @param {LH.Gatherer.FRProtocolSession} session
  * @param {string} url
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
@@ -78,11 +79,14 @@ async function resetStorageForUrl(session, url) {
   /** @type {Array<LH.IcuMessage>} */
   const warnings = [];
 
-  // Reset the storage and warn if there appears to be other important data.
-  const warning = await storage.getImportantStorageWarning(session, url);
-  if (warning) warnings.push(warning);
-  await storage.clearDataForOrigin(session, url);
-  await storage.clearBrowserCaches(session);
+  const importantStorageWarning = await storage.getImportantStorageWarning(session, url);
+  if (importantStorageWarning) warnings.push(importantStorageWarning);
+
+  const clearDataWarnings = await storage.clearDataForOrigin(session, url);
+  warnings.push(...clearDataWarnings);
+
+  const clearCacheWarnings = await storage.clearBrowserCaches(session);
+  warnings.push(...clearCacheWarnings);
 
   return {warnings};
 }

package/core/gather/driver/storage.js

@@ -8,6 +8,7 @@ import log from 'lighthouse-logger';
 
 import * as i18n from '../../lib/i18n/i18n.js';
 
+/* eslint-disable max-len */
 const UIStrings = {
   /**
    * @description A warning that previously-saved data may have affected the measured performance and instructions on how to avoid the problem. "locations" will be a list of possible types of data storage locations, e.g. "IndexedDB",  "Local Storage", or "Web SQL".
@@ -22,7 +23,12 @@ const UIStrings = {
       `Audit this page in an incognito window to prevent those resources ` +
       `from affecting your scores.}
   }`,
+  /** A warning that the data in the browser cache may have affected the measured performance because the operation to clear the browser cache timed out. */
+  warningCacheTimeout: 'Clearing the browser cache timed out. Try auditing this page again and file a bug if the issue persists.',
+  /** A warning that the data on the page's origin may have affected the measured performance because the operation to clear the origin data timed out. */
+  warningOriginDataTimeout: 'Clearing the origin data timed out. Try auditing this page again and file a bug if the issue persists.',
 };
+/* eslint-enable max-len */
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
@@ -30,12 +36,14 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 /**
  * @param {LH.Gatherer.FRProtocolSession} session
  * @param {string} url
- * @return {Promise<void>}
+ * @return {Promise<LH.IcuMessage[]>}
  */
 async function clearDataForOrigin(session, url) {
   const status = {msg: 'Cleaning origin data', id: 'lh:storage:clearDataForOrigin'};
   log.time(status);
 
+  const warnings = [];
+
   const origin = new URL(url).origin;
 
   // Clear some types of storage.
@@ -62,12 +70,15 @@ async function clearDataForOrigin(session, url) {
   } catch (err) {
     if (/** @type {LH.LighthouseError} */ (err).code === 'PROTOCOL_TIMEOUT') {
       log.warn('Driver', 'clearDataForOrigin timed out');
+      warnings.push(str_(UIStrings.warningOriginDataTimeout));
     } else {
       throw err;
     }
   } finally {
     log.timeEnd(status);
   }
+
+  return warnings;
 }
 
 /**
@@ -102,19 +113,32 @@ async function getImportantStorageWarning(session, url) {
 /**
  * Clear the network cache on disk and in memory.
  * @param {LH.Gatherer.FRProtocolSession} session
- * @return {Promise<void>}
+ * @return {Promise<LH.IcuMessage[]>}
  */
 async function clearBrowserCaches(session) {
   const status = {msg: 'Cleaning browser cache', id: 'lh:storage:clearBrowserCaches'};
   log.time(status);
 
-  // Wipe entire disk cache
-  await session.sendCommand('Network.clearBrowserCache');
-  // Toggle 'Disable Cache' to evict the memory cache
-  await session.sendCommand('Network.setCacheDisabled', {cacheDisabled: true});
-  await session.sendCommand('Network.setCacheDisabled', {cacheDisabled: false});
+  const warnings = [];
+
+  try {
+    // Wipe entire disk cache
+    await session.sendCommand('Network.clearBrowserCache');
+    // Toggle 'Disable Cache' to evict the memory cache
+    await session.sendCommand('Network.setCacheDisabled', {cacheDisabled: true});
+    await session.sendCommand('Network.setCacheDisabled', {cacheDisabled: false});
+  } catch (err) {
+    if (/** @type {LH.LighthouseError} */ (err).code === 'PROTOCOL_TIMEOUT') {
+      log.warn('Driver', 'clearBrowserCaches timed out');
+      warnings.push(str_(UIStrings.warningCacheTimeout));
+    } else {
+      throw err;
+    }
+  } finally {
+    log.timeEnd(status);
+  }
 
-  log.timeEnd(status);
+  return warnings;
 }
 
 export {

package/core/gather/navigation-runner.js

@@ -29,7 +29,7 @@ import {NetworkRecords} from '../computed/network-records.js';
  * @typedef NavigationContext
  * @property {Driver} driver
  * @property {LH.Puppeteer.Page} page
- * @property {LH.Config.FRConfig} config
+ * @property {LH.Config.ResolvedConfig} resolvedConfig
  * @property {LH.Config.NavigationDefn} navigation
  * @property {LH.NavigationRequestor} requestor
  * @property {LH.FRBaseArtifacts} baseArtifacts
@@ -42,20 +42,20 @@ const DEFAULT_HOSTNAME = '127.0.0.1';
 const DEFAULT_PORT = 9222;
 
 /**
- * @param {{driver: Driver, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor}} args
+ * @param {{driver: Driver, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor}} args
  * @return {Promise<{baseArtifacts: LH.FRBaseArtifacts}>}
  */
-async function _setup({driver, config, requestor}) {
+async function _setup({driver, resolvedConfig, requestor}) {
   await driver.connect();
 
   // We can't trigger the navigation through user interaction if we reset the page before starting.
-  if (typeof requestor === 'string' && !config.settings.skipAboutBlank) {
+  if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
     await gotoURL(driver, defaultNavigationConfig.blankPage, {waitUntil: ['navigated']});
   }
 
-  const baseArtifacts = await getBaseArtifacts(config, driver, {gatherMode: 'navigation'});
+  const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'navigation'});
 
-  await prepare.prepareTargetForNavigationMode(driver, config.settings);
+  await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings);
 
   return {baseArtifacts};
 }
@@ -64,15 +64,15 @@ async function _setup({driver, config, requestor}) {
  * @param {NavigationContext} navigationContext
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function _setupNavigation({requestor, driver, navigation, config}) {
+async function _setupNavigation({requestor, driver, navigation, resolvedConfig}) {
   // We can't trigger the navigation through user interaction if we reset the page before starting.
-  if (typeof requestor === 'string' && !config.settings.skipAboutBlank) {
+  if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
     await gotoURL(driver, navigation.blankPage, {...navigation, waitUntil: ['navigated']});
   }
 
   const {warnings} = await prepare.prepareTargetForIndividualNavigation(
     driver.defaultSession,
-    config.settings,
+    resolvedConfig.settings,
     {
       ...navigation,
       requestor,
@@ -94,14 +94,14 @@ async function _cleanupNavigation({driver}) {
  * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
  */
 async function _navigate(navigationContext) {
-  const {driver, config, requestor} = navigationContext;
+  const {driver, resolvedConfig, requestor} = navigationContext;
 
   try {
     const {requestedUrl, mainDocumentUrl, warnings} = await gotoURL(driver, requestor, {
       ...navigationContext.navigation,
-      debugNavigation: config.settings.debugNavigation,
-      maxWaitForFcp: config.settings.maxWaitForFcp,
-      maxWaitForLoad: config.settings.maxWaitForLoad,
+      debugNavigation: resolvedConfig.settings.debugNavigation,
+      maxWaitForFcp: resolvedConfig.settings.maxWaitForFcp,
+      maxWaitForLoad: resolvedConfig.settings.maxWaitForLoad,
       waitUntil: navigationContext.navigation.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
     });
     return {requestedUrl, mainDocumentUrl, navigationError: undefined, warnings};
@@ -181,7 +181,7 @@ async function _computeNavigationResult(
     : navigationError;
 
   if (pageLoadError) {
-    const locale = navigationContext.config.settings.locale;
+    const locale = navigationContext.resolvedConfig.settings.locale;
     const localizedMessage = format.getFormatted(pageLoadError.friendlyMessage, locale);
     log.error('NavigationRunner', localizedMessage, navigateResult.requestedUrl);
 
@@ -223,7 +223,7 @@ async function _navigation(navigationContext) {
     artifactDefinitions: navigationContext.navigation.artifacts,
     artifactState,
     baseArtifacts: navigationContext.baseArtifacts,
-    settings: navigationContext.config.settings,
+    settings: navigationContext.resolvedConfig.settings,
   };
 
   const setupResult = await _setupNavigation(navigationContext);
@@ -250,24 +250,33 @@ async function _navigation(navigationContext) {
 }
 
 /**
- * @param {{driver: Driver, page: LH.Puppeteer.Page, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache']}} args
+ * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache']}} args
  * @return {Promise<{artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>}>}
  */
-async function _navigations({driver, page, config, requestor, baseArtifacts, computedCache}) {
-  if (!config.navigations) throw new Error('No navigations configured');
+async function _navigations(args) {
+  const {
+    driver,
+    page,
+    resolvedConfig,
+    requestor,
+    baseArtifacts,
+    computedCache,
+  } = args;
+
+  if (!resolvedConfig.navigations) throw new Error('No navigations configured');
 
   /** @type {Partial<LH.FRArtifacts & LH.FRBaseArtifacts>} */
   const artifacts = {};
   /** @type {Array<LH.IcuMessage>} */
   const LighthouseRunWarnings = [];
 
-  for (const navigation of config.navigations) {
+  for (const navigation of resolvedConfig.navigations) {
     const navigationContext = {
       driver,
       page,
       navigation,
       requestor,
-      config,
+      resolvedConfig,
       baseArtifacts,
       computedCache,
     };
@@ -290,10 +299,10 @@ async function _navigations({driver, page, config, requestor, baseArtifacts, com
 }
 
 /**
- * @param {{requestedUrl?: string, driver: Driver, config: LH.Config.FRConfig}} args
+ * @param {{requestedUrl?: string, driver: Driver, resolvedConfig: LH.Config.ResolvedConfig}} args
  */
-async function _cleanup({requestedUrl, driver, config}) {
-  const didResetStorage = !config.settings.disableStorageReset && requestedUrl;
+async function _cleanup({requestedUrl, driver, resolvedConfig}) {
+  const didResetStorage = !resolvedConfig.settings.disableStorageReset && requestedUrl;
   if (didResetStorage) await storage.clearDataForOrigin(driver.defaultSession, requestedUrl);
 
   await driver.disconnect();
@@ -306,15 +315,15 @@ async function _cleanup({requestedUrl, driver, config}) {
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function navigationGather(page, requestor, options = {}) {
-  const {flags = {}} = options;
+  const {flags = {}, config} = options;
   log.setLevel(flags.logLevel || 'error');
 
-  const {config} = await initializeConfig('navigation', options.config, flags);
+  const {resolvedConfig} = await initializeConfig('navigation', config, flags);
   const computedCache = new Map();
 
   const isCallback = typeof requestor === 'function';
 
-  const runnerOptions = {config, computedCache};
+  const runnerOptions = {resolvedConfig, computedCache};
   const artifacts = await Runner.gather(
     async () => {
       const normalizedRequestor = isCallback ? requestor : UrlUtils.normalizeUrl(requestor);
@@ -330,7 +339,7 @@ async function navigationGather(page, requestor, options = {}) {
       const driver = new Driver(page);
       const context = {
         driver,
-        config,
+        resolvedConfig,
         requestor: normalizedRequestor,
       };
       const {baseArtifacts} = await _setup(context);

package/core/gather/snapshot-runner.js

@@ -18,10 +18,10 @@ import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function snapshotGather(page, options = {}) {
-  const {flags = {}} = options;
+  const {flags = {}, config} = options;
   log.setLevel(flags.logLevel || 'error');
 
-  const {config} = await initializeConfig('snapshot', options.config, flags);
+  const {resolvedConfig} = await initializeConfig('snapshot', config, flags);
   const driver = new Driver(page);
   await driver.connect();
 
@@ -29,15 +29,16 @@ async function snapshotGather(page, options = {}) {
   const computedCache = new Map();
   const url = await driver.url();
 
-  const runnerOptions = {config, computedCache};
+  const runnerOptions = {resolvedConfig, computedCache};
   const artifacts = await Runner.gather(
     async () => {
-      const baseArtifacts = await getBaseArtifacts(config, driver, {gatherMode: 'snapshot'});
+      const baseArtifacts =
+        await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'snapshot'});
       baseArtifacts.URL = {
         finalDisplayedUrl: url,
       };
 
-      const artifactDefinitions = config.artifacts || [];
+      const artifactDefinitions = resolvedConfig.artifacts || [];
       const artifactState = getEmptyArtifactState();
       await collectPhaseArtifacts({
         phase: 'getArtifact',
@@ -48,7 +49,7 @@ async function snapshotGather(page, options = {}) {
         artifactDefinitions,
         artifactState,
         computedCache,
-        settings: config.settings,
+        settings: resolvedConfig.settings,
       });
 
       await driver.disconnect();

package/core/gather/timespan-runner.js

@@ -19,17 +19,17 @@ import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
  * @return {Promise<{endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>}>}
  */
 async function startTimespanGather(page, options = {}) {
-  const {flags = {}} = options;
+  const {flags = {}, config} = options;
   log.setLevel(flags.logLevel || 'error');
 
-  const {config} = await initializeConfig('timespan', options.config, flags);
+  const {resolvedConfig} = await initializeConfig('timespan', config, flags);
   const driver = new Driver(page);
   await driver.connect();
 
   /** @type {Map<string, LH.ArbitraryEqualityMap>} */
   const computedCache = new Map();
-  const artifactDefinitions = config.artifacts || [];
-  const baseArtifacts = await getBaseArtifacts(config, driver, {gatherMode: 'timespan'});
+  const artifactDefinitions = resolvedConfig.artifacts || [];
+  const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'timespan'});
   const artifactState = getEmptyArtifactState();
   /** @type {Omit<import('./runner-helpers.js').CollectPhaseArtifactOptions, 'phase'>} */
   const phaseOptions = {
@@ -40,10 +40,10 @@ async function startTimespanGather(page, options = {}) {
     baseArtifacts,
     computedCache,
     gatherMode: 'timespan',
-    settings: config.settings,
+    settings: resolvedConfig.settings,
   };
 
-  await prepareTargetForTimespanMode(driver, config.settings);
+  await prepareTargetForTimespanMode(driver, resolvedConfig.settings);
   await collectPhaseArtifacts({phase: 'startInstrumentation', ...phaseOptions});
   await collectPhaseArtifacts({phase: 'startSensitiveInstrumentation', ...phaseOptions});
 
@@ -51,7 +51,7 @@ async function startTimespanGather(page, options = {}) {
     async endTimespanGather() {
       const finalDisplayedUrl = await driver.url();
 
-      const runnerOptions = {config, computedCache};
+      const runnerOptions = {resolvedConfig, computedCache};
       const artifacts = await Runner.gather(
         async () => {
           baseArtifacts.URL = {finalDisplayedUrl};

package/core/index.js

@@ -8,7 +8,7 @@ import log from 'lighthouse-logger';
 
 import {Runner} from './runner.js';
 import {CriConnection} from './legacy/gather/connections/cri.js';
-import {Config} from './legacy/config/config.js';
+import {LegacyResolvedConfig} from './legacy/config/config.js';
 import UrlUtils from './lib/url-utils.js';
 import {Driver} from './legacy/gather/driver.js';
 import {UserFlow, auditGatherSteps} from './user-flow.js';
@@ -63,9 +63,9 @@ async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
   flags.logLevel = flags.logLevel || 'error';
   log.setLevel(flags.logLevel);
 
-  const config = await Config.fromJson(configJSON, flags);
+  const resolvedConfig = await LegacyResolvedConfig.fromJson(configJSON, flags);
   const computedCache = new Map();
-  const options = {config, computedCache};
+  const options = {resolvedConfig, computedCache};
   const connection = userConnection || new CriConnection(flags.port, flags.hostname);
 
   // kick off a lighthouse run

package/core/legacy/config/config.js

@@ -55,15 +55,15 @@ const BASE_ARTIFACT_BLANKS = {
 const BASE_ARTIFACT_NAMES = Object.keys(BASE_ARTIFACT_BLANKS);
 
 /**
- * @param {Config['passes']} passes
- * @param {Config['audits']} audits
+ * @param {LegacyResolvedConfig['passes']} passes
+ * @param {LegacyResolvedConfig['audits']} audits
  */
 function assertValidPasses(passes, audits) {
   if (!Array.isArray(passes)) {
     return;
   }
 
-  const requestedGatherers = Config.getGatherersRequestedByAudits(audits);
+  const requestedGatherers = LegacyResolvedConfig.getGatherersRequestedByAudits(audits);
   // Base artifacts are provided by GatherRunner, so start foundGatherers with them.
   const foundGatherers = new Set(BASE_ARTIFACT_NAMES);
 
@@ -129,15 +129,15 @@ function assertValidGatherer(gathererInstance, gathererName) {
 }
 
 /**
- * @implements {LH.Config.Config}
+ * @implements {LH.Config.LegacyResolvedConfig}
  */
-class Config {
+class LegacyResolvedConfig {
   /**
    * Resolves the provided config (inherits from extended config, if set), resolves
    * all referenced modules, and validates.
    * @param {LH.Config.Json=} configJSON If not provided, uses the default config.
    * @param {LH.Flags=} flags
-   * @return {Promise<Config>}
+   * @return {Promise<LegacyResolvedConfig>}
    */
   static async fromJson(configJSON, flags) {
     const status = {msg: 'Create config', id: 'lh:init:config'};
@@ -161,7 +161,8 @@ class Config {
       if (configJSON.extends !== 'lighthouse:default') {
         throw new Error('`lighthouse:default` is the only valid extension method.');
       }
-      configJSON = Config.extendConfigJSON(deepCloneConfigJson(legacyDefaultConfig), configJSON);
+      configJSON = LegacyResolvedConfig.extendConfigJSON(
+        deepCloneConfigJson(legacyDefaultConfig), configJSON);
     }
 
     // The directory of the config path, if one was provided.
@@ -173,15 +174,15 @@ class Config {
     const settings = resolveSettings(configJSON.settings || {}, flags);
 
     // Augment passes with necessary defaults and require gatherers.
-    const passesWithDefaults = Config.augmentPassesWithDefaults(configJSON.passes);
-    Config.adjustDefaultPassForThrottling(settings, passesWithDefaults);
-    const passes = await Config.requireGatherers(passesWithDefaults, configDir);
+    const passesWithDefaults = LegacyResolvedConfig.augmentPassesWithDefaults(configJSON.passes);
+    LegacyResolvedConfig.adjustDefaultPassForThrottling(settings, passesWithDefaults);
+    const passes = await LegacyResolvedConfig.requireGatherers(passesWithDefaults, configDir);
 
-    const audits = await Config.requireAudits(configJSON.audits, configDir);
+    const audits = await LegacyResolvedConfig.requireAudits(configJSON.audits, configDir);
 
-    const config = new Config(configJSON, {settings, passes, audits});
+    const resolvedConfig = new LegacyResolvedConfig(configJSON, {settings, passes, audits});
     log.timeEnd(status);
-    return config;
+    return resolvedConfig;
   }
 
   /**
@@ -202,7 +203,7 @@ class Config {
     /** @type {?Record<string, LH.Config.Group>} */
     this.groups = configJSON.groups || null;
 
-    Config.filterConfigIfNeeded(this);
+    LegacyResolvedConfig.filterConfigIfNeeded(this);
 
     assertValidPasses(this.passes, this.audits);
     validation.assertValidCategories(this.categories, this.audits, this.groups);
@@ -308,7 +309,7 @@ class Config {
 
   /**
    * Filter out any unrequested items from the config, based on requested categories or audits.
-   * @param {Config} config
+   * @param {LegacyResolvedConfig} config
    */
   static filterConfigIfNeeded(config) {
     const settings = config.settings;
@@ -317,18 +318,19 @@ class Config {
     }
 
     // 1. Filter to just the chosen categories/audits
-    const {categories, requestedAuditNames} = Config.filterCategoriesAndAudits(config.categories,
-      settings);
+    const {categories, requestedAuditNames} =
+      LegacyResolvedConfig.filterCategoriesAndAudits(config.categories, settings);
 
     // 2. Resolve which audits will need to run
     const audits = config.audits && config.audits.filter(auditDefn =>
         requestedAuditNames.has(auditDefn.implementation.meta.id));
 
     // 3. Resolve which gatherers will need to run
-    const requestedGathererIds = Config.getGatherersRequestedByAudits(audits);
+    const requestedGathererIds = LegacyResolvedConfig.getGatherersRequestedByAudits(audits);
 
     // 4. Filter to only the neccessary passes
-    const passes = Config.generatePassesNeededByGatherers(config.passes, requestedGathererIds);
+    const passes =
+      LegacyResolvedConfig.generatePassesNeededByGatherers(config.passes, requestedGathererIds);
 
     config.categories = categories;
     config.audits = audits;
@@ -337,9 +339,9 @@ class Config {
 
   /**
    * Filter out any unrequested categories or audits from the categories object.
-   * @param {Config['categories']} oldCategories
+   * @param {LegacyResolvedConfig['categories']} oldCategories
    * @param {LH.Config.Settings} settings
-   * @return {{categories: Config['categories'], requestedAuditNames: Set<string>}}
+   * @return {{categories: LegacyResolvedConfig['categories'], requestedAuditNames: Set<string>}}
    */
   static filterCategoriesAndAudits(oldCategories, settings) {
     if (!oldCategories) {
@@ -350,7 +352,7 @@ class Config {
       throw new Error('Cannot set both skipAudits and onlyAudits');
     }
 
-    /** @type {NonNullable<Config['categories']>} */
+    /** @type {NonNullable<LegacyResolvedConfig['categories']>} */
     const categories = {};
     const filterByIncludedCategory = !!settings.onlyCategories;
     const filterByIncludedAudit = !!settings.onlyAudits;
@@ -424,7 +426,7 @@ class Config {
 
   /**
    * From some requested audits, return names of all required and optional artifacts
-   * @param {Config['audits']} audits
+   * @param {LegacyResolvedConfig['audits']} audits
    * @return {Set<string>}
    */
   static getGatherersRequestedByAudits(audits) {
@@ -447,9 +449,9 @@ class Config {
 
   /**
    * Filters to only requested passes and gatherers, returning a new passes array.
-   * @param {Config['passes']} passes
+   * @param {LegacyResolvedConfig['passes']} passes
    * @param {Set<string>} requestedGatherers
-   * @return {Config['passes']}
+   * @return {LegacyResolvedConfig['passes']}
    */
   static generatePassesNeededByGatherers(passes, requestedGatherers) {
     if (!passes) {
@@ -488,7 +490,7 @@ class Config {
    * leaving only an array of AuditDefns.
    * @param {LH.Config.Json['audits']} audits
    * @param {string=} configDir
-   * @return {Promise<Config['audits']>}
+   * @return {Promise<LegacyResolvedConfig['audits']>}
    */
   static async requireAudits(audits, configDir) {
     const status = {msg: 'Requiring audits', id: 'lh:config:requireAudits'};
@@ -504,7 +506,7 @@ class Config {
    * provided) using `resolveModulePath`, returning an array of full Passes.
    * @param {?Array<Required<LH.Config.PassJson>>} passes
    * @param {string=} configDir
-   * @return {Promise<Config['passes']>}
+   * @return {Promise<LegacyResolvedConfig['passes']>}
    */
   static async requireGatherers(passes, configDir) {
     if (!passes) {
@@ -535,4 +537,4 @@ class Config {
   }
 }
 
-export {Config};
+export {LegacyResolvedConfig};

package/core/runner.js

@@ -28,18 +28,18 @@ const moduleDir = getModuleDirectory(import.meta);
 
 /** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
 /** @typedef {import('./lib/arbitrary-equality-map.js').ArbitraryEqualityMap} ArbitraryEqualityMap */
-/** @typedef {LH.Config.Config} Config */
+/** @typedef {LH.Config.LegacyResolvedConfig} Config */
 
 class Runner {
   /**
-   * @template {LH.Config.Config | LH.Config.FRConfig} TConfig
+   * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
    * @param {LH.Artifacts} artifacts
-   * @param {{config: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+   * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
    * @return {Promise<LH.RunnerResult|undefined>}
    */
   static async audit(artifacts, options) {
-    const {config, computedCache} = options;
-    const settings = config.settings;
+    const {resolvedConfig, computedCache} = options;
+    const settings = resolvedConfig.settings;
 
     try {
       const runnerStatus = {msg: 'Audit phase', id: 'lh:runner:audit'};
@@ -54,10 +54,10 @@ class Runner {
       // Potentially quit early
       if (settings.gatherMode && !settings.auditMode) return;
 
-      if (!config.audits) {
+      if (!resolvedConfig.audits) {
         throw new Error('No audits to evaluate.');
       }
-      const auditResultsById = await Runner._runAudits(settings, config.audits, artifacts,
+      const auditResultsById = await Runner._runAudits(settings, resolvedConfig.audits, artifacts,
           lighthouseRunWarnings, computedCache);
 
       // LHR construction phase
@@ -79,8 +79,8 @@ class Runner {
 
       /** @type {Record<string, LH.RawIcu<LH.Result.Category>>} */
       let categories = {};
-      if (config.categories) {
-        categories = ReportScoring.scoreAllCategories(config.categories, auditResultsById);
+      if (resolvedConfig.categories) {
+        categories = ReportScoring.scoreAllCategories(resolvedConfig.categories, auditResultsById);
       }
 
       log.timeEnd(resultsStatus);
@@ -108,7 +108,7 @@ class Runner {
         audits: auditResultsById,
         configSettings: settings,
         categories,
-        categoryGroups: config.groups || undefined,
+        categoryGroups: resolvedConfig.groups || undefined,
         stackPacks: stackPacks.getStackPacks(artifacts.Stacks),
         timing: this._getTiming(artifacts),
         i18n: {
@@ -142,13 +142,13 @@ class Runner {
    * -G and -A will run partial lighthouse pipelines,
    * and -GA will run everything plus save artifacts and lhr to disk.
    *
-   * @template {LH.Config.Config | LH.Config.FRConfig} TConfig
-   * @param {(runnerData: {config: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
-   * @param {{config: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+   * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
+   * @param {(runnerData: {resolvedConfig: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
+   * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
    * @return {Promise<LH.Artifacts>}
    */
   static async gather(gatherFn, options) {
-    const settings = options.config.settings;
+    const settings = options.resolvedConfig.settings;
 
     // Either load saved artifacts from disk or from the browser.
     try {
@@ -170,7 +170,7 @@ class Runner {
         log.time(runnerStatus, 'verbose');
 
         artifacts = await gatherFn({
-          config: options.config,
+          resolvedConfig: options.resolvedConfig,
           driverMock: options.driverMock,
         });
 
@@ -248,22 +248,22 @@ class Runner {
   /**
    * Establish connection, load page and collect all required artifacts
    * @param {string} requestedUrl
-   * @param {{config: Config, computedCache: Map<string, ArbitraryEqualityMap>, driverMock?: Driver}} runnerOpts
+   * @param {{resolvedConfig: Config, computedCache: Map<string, ArbitraryEqualityMap>, driverMock?: Driver}} runnerOpts
    * @param {Connection} connection
    * @return {Promise<LH.Artifacts>}
    */
   static async _gatherArtifactsFromBrowser(requestedUrl, runnerOpts, connection) {
-    if (!runnerOpts.config.passes) {
+    if (!runnerOpts.resolvedConfig.passes) {
       throw new Error('No browser artifacts are either provided or requested.');
     }
     const driver = runnerOpts.driverMock || new Driver(connection);
     const gatherOpts = {
       driver,
       requestedUrl,
-      settings: runnerOpts.config.settings,
+      settings: runnerOpts.resolvedConfig.settings,
       computedCache: runnerOpts.computedCache,
     };
-    const artifacts = await GatherRunner.run(runnerOpts.config.passes, gatherOpts);
+    const artifacts = await GatherRunner.run(runnerOpts.resolvedConfig.passes, gatherOpts);
     return artifacts;
   }
 

package/core/user-flow.js

@@ -323,9 +323,9 @@ async function auditGatherSteps(gatherSteps, options) {
       // Step specific configs take precedence over a config for the entire flow.
       const configJson = options.config;
       const {gatherMode} = artifacts.GatherContext;
-      const {config} = await initializeConfig(gatherMode, configJson, flags);
+      const {resolvedConfig} = await initializeConfig(gatherMode, configJson, flags);
       runnerOptions = {
-        config,
+        resolvedConfig,
         computedCache: new Map(),
       };
     }

package/dist/report/bundle.esm.js

@@ -5286,7 +5286,8 @@ class TopbarFeatures {
    */
   _setUpCollapseDetailsAfterPrinting() {
     // FF and IE implement these old events.
-    if ('onbeforeprint' in self) {
+    const supportsOldPrintEvents = 'onbeforeprint' in self;
+    if (supportsOldPrintEvents) {
       self.addEventListener('afterprint', this.collapseAllDetails);
     } else {
       // Note: FF implements both window.onbeforeprint and media listeners. However,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "9.5.0-dev.20230102",
+  "version": "9.5.0-dev.20230104",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -127,8 +127,8 @@
     "@types/ws": "^7.0.0",
     "@types/yargs": "^17.0.8",
     "@types/yargs-parser": "^20.2.1",
-    "@typescript-eslint/eslint-plugin": "^5.27.1",
-    "@typescript-eslint/parser": "^5.27.1",
+    "@typescript-eslint/eslint-plugin": "^5.48.0",
+    "@typescript-eslint/parser": "^5.48.0",
     "acorn": "^8.5.0",
     "angular": "^1.7.4",
     "archiver": "^3.0.0",
@@ -178,7 +178,7 @@
     "terser": "^5.3.8",
     "testdouble": "^3.16.5",
     "typed-query-selector": "^2.6.1",
-    "typescript": "^4.7.3",
+    "typescript": "^4.9.4",
     "wait-for-expect": "^3.0.2",
     "webtreemap-cdt": "^3.2.1"
   },

package/report/renderer/topbar-features.js

@@ -240,7 +240,8 @@ export class TopbarFeatures {
    */
   _setUpCollapseDetailsAfterPrinting() {
     // FF and IE implement these old events.
-    if ('onbeforeprint' in self) {
+    const supportsOldPrintEvents = 'onbeforeprint' in self;
+    if (supportsOldPrintEvents) {
       self.addEventListener('afterprint', this.collapseAllDetails);
     } else {
       // Note: FF implements both window.onbeforeprint and media listeners. However,

package/shared/localization/locales/en-US.json

@@ -1679,9 +1679,15 @@
   "core/gather/driver/navigation.js | warningTimeout": {
     "message": "The page loaded too slowly to finish within the time limit. Results may be incomplete."
   },
+  "core/gather/driver/storage.js | warningCacheTimeout": {
+    "message": "Clearing the browser cache timed out. Try auditing this page again and file a bug if the issue persists."
+  },
   "core/gather/driver/storage.js | warningData": {
     "message": "{locationCount, plural,\n    =1 {There may be stored data affecting loading performance in this location: {locations}. Audit this page in an incognito window to prevent those resources from affecting your scores.}\n    other {There may be stored data affecting loading performance in these locations: {locations}. Audit this page in an incognito window to prevent those resources from affecting your scores.}\n  }"
   },
+  "core/gather/driver/storage.js | warningOriginDataTimeout": {
+    "message": "Clearing the origin data timed out. Try auditing this page again and file a bug if the issue persists."
+  },
   "core/lib/bfcache-strings.js | appBanner": {
     "message": "Pages that requested an AppBanner are not currently eligible for back/forward cache."
   },

package/shared/localization/locales/en-XL.json

@@ -1679,9 +1679,15 @@
   "core/gather/driver/navigation.js | warningTimeout": {
     "message": "T̂h́ê ṕâǵê ĺôád̂éd̂ t́ôó ŝĺôẃl̂ý t̂ó f̂ín̂íŝh́ ŵít̂h́îń t̂h́ê t́îḿê ĺîḿît́. R̂éŝúl̂t́ŝ ḿâý b̂é îńĉóm̂ṕl̂ét̂é."
   },
+  "core/gather/driver/storage.js | warningCacheTimeout": {
+    "message": "Ĉĺêár̂ín̂ǵ t̂h́ê b́r̂óŵśêŕ ĉáĉh́ê t́îḿêd́ ôút̂. T́r̂ý âúd̂ít̂ín̂ǵ t̂h́îś p̂áĝé âǵâín̂ án̂d́ f̂íl̂é â b́ûǵ îf́ t̂h́ê íŝśûé p̂ér̂śîśt̂ś."
+  },
   "core/gather/driver/storage.js | warningData": {
     "message": "{locationCount, plural,\n    =1 {T̂h́êŕê ḿâý b̂é ŝt́ôŕêd́ d̂át̂á âf́f̂éĉt́îńĝ ĺôád̂ín̂ǵ p̂ér̂f́ôŕm̂án̂ćê ín̂ t́ĥíŝ ĺôćât́îón̂: {locations}. Áûd́ît́ t̂h́îś p̂áĝé îń âń îńĉóĝńît́ô ẃîńd̂óŵ t́ô ṕr̂év̂én̂t́ t̂h́ôśê ŕêśôúr̂ćêś f̂ŕôḿ âf́f̂éĉt́îńĝ ýôúr̂ śĉór̂éŝ.}\n    other {T́ĥér̂é m̂áŷ b́ê śt̂ór̂éd̂ d́ât́â áf̂f́êćt̂ín̂ǵ l̂óâd́îńĝ ṕêŕf̂ór̂ḿâńĉé îń t̂h́êśê ĺôćât́îón̂ś: {locations}. Âúd̂ít̂ t́ĥíŝ ṕâǵê ín̂ án̂ ín̂ćôǵn̂ít̂ó ŵín̂d́ôẃ t̂ó p̂ŕêv́êńt̂ t́ĥóŝé r̂éŝóûŕĉéŝ f́r̂óm̂ áf̂f́êćt̂ín̂ǵ ŷóûŕ ŝćôŕêś.}\n  }"
   },
+  "core/gather/driver/storage.js | warningOriginDataTimeout": {
+    "message": "Ĉĺêár̂ín̂ǵ t̂h́ê ór̂íĝín̂ d́ât́â t́îḿêd́ ôút̂. T́r̂ý âúd̂ít̂ín̂ǵ t̂h́îś p̂áĝé âǵâín̂ án̂d́ f̂íl̂é â b́ûǵ îf́ t̂h́ê íŝśûé p̂ér̂śîśt̂ś."
+  },
   "core/lib/bfcache-strings.js | appBanner": {
     "message": "P̂áĝéŝ t́ĥát̂ ŕêq́ûéŝt́êd́ âń Âṕp̂B́âńn̂ér̂ ár̂é n̂ót̂ ćûŕr̂én̂t́l̂ý êĺîǵîb́l̂é f̂ór̂ b́âćk̂/f́ôŕŵár̂d́ ĉáĉh́ê."
   },

package/types/config.d.ts

@@ -34,9 +34,9 @@ declare module Config {
   }
 
   /**
-   * The normalized and fully resolved config.
+   * The normalized and fully resolved legacy config.
    */
-  interface Config {
+  interface LegacyResolvedConfig {
     settings: Settings;
     passes: Pass[] | null;
     audits: AuditDefn[] | null;
@@ -45,9 +45,9 @@ declare module Config {
   }
 
   /**
-   * The normalized and fully resolved Fraggle Rock config.
+   * The normalized and fully resolved config.
    */
-  interface FRConfig {
+  interface ResolvedConfig {
     settings: Settings;
     artifacts: AnyArtifactDefn[] | null;
     navigations: NavigationDefn[] | null;

package/types/gatherer.d.ts

@@ -67,7 +67,7 @@ declare module Gatherer {
   interface FRGatherResult {
     artifacts: Artifacts;
     runnerOptions: {
-      config: Config.FRConfig;
+      resolvedConfig: Config.ResolvedConfig;
       computedCache: Map<string, ArbitraryEqualityMap>
     }
   }