lighthouse 9.5.0-dev.20230111 → 9.5.0-dev.20230112

package/cli/bin.js

@@ -63,20 +63,20 @@ async function begin() {
 
   const urlUnderTest = cliFlags._[0];
 
-  /** @type {LH.Config.Json|undefined} */
-  let configJson;
+  /** @type {LH.Config|undefined} */
+  let config;
   if (cliFlags.configPath) {
     // Resolve the config file path relative to where cli was called.
     cliFlags.configPath = path.resolve(process.cwd(), cliFlags.configPath);
 
     if (cliFlags.configPath.endsWith('.json')) {
-      configJson = JSON.parse(fs.readFileSync(cliFlags.configPath, 'utf-8'));
+      config = JSON.parse(fs.readFileSync(cliFlags.configPath, 'utf-8'));
     } else {
       const configModuleUrl = url.pathToFileURL(cliFlags.configPath).href;
-      configJson = (await import(configModuleUrl)).default;
+      config = (await import(configModuleUrl)).default;
     }
   } else if (cliFlags.preset) {
-    configJson = (await import(`../core/config/${cliFlags.preset}-config.js`)).default;
+    config = (await import(`../core/config/${cliFlags.preset}-config.js`)).default;
   }
 
   if (cliFlags.budgetPath) {
@@ -132,7 +132,7 @@ async function begin() {
     });
   }
 
-  return runLighthouse(urlUnderTest, cliFlags, configJson);
+  return runLighthouse(urlUnderTest, cliFlags, config);
 }
 
 export {

package/cli/run.js

@@ -209,7 +209,7 @@ async function potentiallyKillChrome(launchedChrome) {
 /**
  * @param {string} url
  * @param {LH.CliFlags} flags
- * @param {LH.Config.Json|undefined} config
+ * @param {LH.Config|undefined} config
  * @return {Promise<LH.RunnerResult|undefined>}
  */
 async function runLighthouse(url, flags, config) {

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

@@ -26,9 +26,9 @@ import {loadArtifacts, saveArtifacts} from '../../../../core/lib/asset-saver.js'
 // This runs only in the worker. The rest runs on the main thread.
 if (!isMainThread && parentPort) {
   (async () => {
-    const {url, configJson, testRunnerOptions} = workerData;
+    const {url, config, testRunnerOptions} = workerData;
     try {
-      const result = await runBundledLighthouse(url, configJson, testRunnerOptions);
+      const result = await runBundledLighthouse(url, config, testRunnerOptions);
       // Save to assets directory because LighthouseError won't survive postMessage.
       const assetsDir = fs.mkdtempSync(os.tmpdir() + '/smoke-bundle-assets-');
       await saveArtifacts(result.artifacts, assetsDir);
@@ -46,11 +46,11 @@ if (!isMainThread && parentPort) {
 
 /**
  * @param {string} url
- * @param {LH.Config.Json|undefined} configJson
+ * @param {LH.Config|undefined} config
  * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
  */
-async function runBundledLighthouse(url, configJson, testRunnerOptions) {
+async function runBundledLighthouse(url, config, testRunnerOptions) {
   if (isMainThread || !parentPort) {
     throw new Error('must be called in worker');
   }
@@ -87,12 +87,12 @@ async function runBundledLighthouse(url, configJson, testRunnerOptions) {
     if (testRunnerOptions.useLegacyNavigation) {
       const connection = new CriConnection(port);
       runnerResult =
-        await legacyNavigation(url, {port, logLevel}, configJson, connection);
+        await legacyNavigation(url, {port, logLevel}, config, connection);
     } else {
       // Puppeteer is not included in the bundle, we must create the page here.
       const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
       const page = await browser.newPage();
-      runnerResult = await lighthouse(url, {port, logLevel}, configJson, page);
+      runnerResult = await lighthouse(url, {port, logLevel}, config, page);
     }
     if (!runnerResult) throw new Error('No runnerResult');
 
@@ -109,17 +109,17 @@ async function runBundledLighthouse(url, configJson, testRunnerOptions) {
 /**
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
- * @param {LH.Config.Json=} configJson
+ * @param {LH.Config=} config
  * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+async function runLighthouse(url, config, testRunnerOptions = {}) {
   /** @type {string[]} */
   const logs = [];
   const worker = new Worker(new URL(import.meta.url), {
     stdout: true,
     stderr: true,
-    workerData: {url, configJson, testRunnerOptions},
+    workerData: {url, config, testRunnerOptions},
   });
   worker.stdout.setEncoding('utf8');
   worker.stderr.setEncoding('utf8');

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

@@ -27,16 +27,16 @@ const execFileAsync = promisify(execFile);
 /**
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
- * @param {LH.Config.Json=} configJson
+ * @param {LH.Config=} config
  * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+async function runLighthouse(url, config, testRunnerOptions = {}) {
   const {isDebug} = testRunnerOptions;
   const tmpDir = `${LH_ROOT}/.tmp/smokehouse`;
   await fs.mkdir(tmpDir, {recursive: true});
   const tmpPath = await fs.mkdtemp(`${tmpDir}/smokehouse-`);
-  return internalRun(url, tmpPath, configJson, testRunnerOptions)
+  return internalRun(url, tmpPath, config, testRunnerOptions)
     // Wait for internalRun() before removing scratch directory.
     .finally(() => !isDebug && fs.rm(tmpPath, {recursive: true, force: true}));
 }
@@ -45,11 +45,11 @@ async function runLighthouse(url, configJson, testRunnerOptions = {}) {
  * Internal runner.
  * @param {string} url
  * @param {string} tmpPath
- * @param {LH.Config.Json=} configJson
+ * @param {LH.Config=} config
  * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} options
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
-async function internalRun(url, tmpPath, configJson, options) {
+async function internalRun(url, tmpPath, config, options) {
   const {isDebug = false, useLegacyNavigation = false} = options || {};
   const localConsole = new LocalConsole();
 
@@ -72,9 +72,9 @@ async function internalRun(url, tmpPath, configJson, options) {
   }
 
   // Config can be optionally provided.
-  if (configJson) {
+  if (config) {
     const configPath = `${tmpPath}/config.json`;
-    await fs.writeFile(configPath, JSON.stringify(configJson));
+    await fs.writeFile(configPath, JSON.stringify(config));
     args.push(`--config-path=${configPath}`);
   }
 

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

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

package/cli/test/smokehouse/readme.md

@@ -14,7 +14,7 @@ See [`SmokehouseOptions`](https://github.com/GoogleChrome/lighthouse/blob/main/c
 | -------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
 | `id`           | `string`                           | The string identifier of the test.                                                                                               |
 | `expectations` | `{lhr: Object, artifacts: Object}` | See below.                                                                                                                       |
-| `config`       | `LH.Config.Json` (optional)        | An optional Lighthouse config. If not specified, the default config is used.                                                     |
+| `config`       | `LH.Config` (optional)        | An optional Lighthouse config. If not specified, the default config is used.                                                     |
 | `runSerially`  | `boolean` (optional)               | An optional flag. If set to true, the test won't be run in parallel to other tests. Useful if the test is performance sensitive. |
 
 ### Expectations

package/cli/test/smokehouse/smokehouse.js

@@ -134,21 +134,21 @@ function purpleify(str) {
 }
 
 /**
- * @param {LH.Config.Json=} configJson
- * @return {LH.Config.Json|undefined}
+ * @param {LH.Config=} config
+ * @return {LH.Config|undefined}
  */
-function convertToLegacyConfig(configJson) {
-  if (!configJson) return configJson;
+function convertToLegacyConfig(config) {
+  if (!config) return config;
 
   return {
-    ...configJson,
+    ...config,
     passes: [{
       passName: 'defaultPass',
-      pauseAfterFcpMs: configJson.settings?.pauseAfterFcpMs,
-      pauseAfterLoadMs: configJson.settings?.pauseAfterLoadMs,
-      networkQuietThresholdMs: configJson.settings?.networkQuietThresholdMs,
-      cpuQuietThresholdMs: configJson.settings?.cpuQuietThresholdMs,
-      blankPage: configJson.settings?.blankPage,
+      pauseAfterFcpMs: config.settings?.pauseAfterFcpMs,
+      pauseAfterLoadMs: config.settings?.pauseAfterLoadMs,
+      networkQuietThresholdMs: config.settings?.networkQuietThresholdMs,
+      cpuQuietThresholdMs: config.settings?.cpuQuietThresholdMs,
+      blankPage: config.settings?.blankPage,
     }],
   };
 }
@@ -184,15 +184,15 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
       bufferedConsole.log(`  Retrying run (${i} out of ${retries} retries)…`);
     }
 
-    let configJson = smokeTestDefn.config;
+    let config = smokeTestDefn.config;
     if (useLegacyNavigation) {
-      configJson = convertToLegacyConfig(configJson);
+      config = convertToLegacyConfig(config);
     }
 
     // Run Lighthouse.
     try {
       result = {
-        ...await lighthouseRunner(requestedUrl, configJson, {isDebug, useLegacyNavigation}),
+        ...await lighthouseRunner(requestedUrl, config, {isDebug, useLegacyNavigation}),
         networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
       };
 

package/core/audits/seo/is-crawlable.js

@@ -10,6 +10,14 @@ import {Audit} from '../audit.js';
 import {MainResource} from '../../computed/main-resource.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 
+const BOT_USER_AGENTS = new Set([
+  undefined,
+  'Googlebot',
+  'bingbot',
+  'DuckDuckBot',
+  'archive.org_bot',
+]);
+
 const BLOCKLIST = new Set([
   'noindex',
   'none',
@@ -48,7 +56,7 @@ function isUnavailable(directive) {
 
 /**
  * Returns true if any of provided directives blocks page from being indexed
- * @param {string} directives
+ * @param {string} directives assumes no user-agent prefix
  * @return {boolean}
  */
 function hasBlockingDirective(directives) {
@@ -58,16 +66,18 @@ function hasBlockingDirective(directives) {
 }
 
 /**
- * Returns true if robots header specifies user agent (e.g. `googlebot: noindex`)
+ * Returns user agent if specified in robots header (e.g. `googlebot: noindex`)
  * @param {string} directives
- * @return {boolean}
+ * @return {string|undefined}
  */
-function hasUserAgent(directives) {
+function getUserAgentFromHeaderDirectives(directives) {
   const parts = directives.match(/^([^,:]+):/);
 
   // Check if directives are prefixed with `googlebot:`, `googlebot-news:`, `otherbot:`, etc.
   // but ignore `unavailable_after:` which is a valid directive
-  return !!parts && parts[1].toLowerCase() !== UNAVAILABLE_AFTER;
+  if (!!parts && parts[1].toLowerCase() !== UNAVAILABLE_AFTER) {
+    return parts[1];
+  }
 }
 
 class IsCrawlable extends Audit {
@@ -85,6 +95,74 @@ class IsCrawlable extends Audit {
     };
   }
 
+  /**
+   * @param {LH.Artifacts.MetaElement} metaElement
+   */
+  static handleMetaElement(metaElement) {
+    const content = metaElement.content || '';
+    if (hasBlockingDirective(content)) {
+      return {
+        source: {
+          ...Audit.makeNodeItem(metaElement.node),
+          snippet: `<meta name="${metaElement.name}" content="${content}" />`,
+        },
+      };
+    }
+  }
+
+  /**
+   * @param {string|undefined} userAgent
+   * @param {LH.Artifacts.NetworkRequest} mainResource
+   * @param {LH.Artifacts.MetaElement[]} metaElements
+   * @param {import('robots-parser').Robot|undefined} parsedRobotsTxt
+   * @param {URL} robotsTxtUrl
+   */
+  static determineIfCrawlableForUserAgent(userAgent, mainResource, metaElements,
+      parsedRobotsTxt, robotsTxtUrl) {
+    /** @type {LH.Audit.Details.Table['items']} */
+    const blockingDirectives = [];
+
+    // Prefer a meta element specific to a user agent, fallback to generic 'robots' if not present.
+    // https://developers.google.com/search/blog/2007/03/using-robots-meta-tag#directing-a-robots-meta-tag-specifically-at-googlebot
+    let meta;
+    if (userAgent) meta = metaElements.find(meta => meta.name === userAgent.toLowerCase());
+    if (!meta) meta = metaElements.find(meta => meta.name === 'robots');
+    if (meta) {
+      const blockingDirective = IsCrawlable.handleMetaElement(meta);
+      if (blockingDirective) blockingDirectives.push(blockingDirective);
+    }
+
+    for (const header of mainResource.responseHeaders || []) {
+      if (header.name.toLowerCase() !== ROBOTS_HEADER) continue;
+
+      const directiveUserAgent = getUserAgentFromHeaderDirectives(header.value);
+      if (directiveUserAgent !== userAgent && directiveUserAgent !== undefined) continue;
+
+      let directiveWithoutUserAgentPrefix = header.value.trim();
+      if (userAgent && header.value.startsWith(`${userAgent}:`)) {
+        directiveWithoutUserAgentPrefix = header.value.replace(`${userAgent}:`, '');
+      }
+      if (!hasBlockingDirective(directiveWithoutUserAgentPrefix)) continue;
+
+      blockingDirectives.push({source: `${header.name}: ${header.value}`});
+    }
+
+    if (parsedRobotsTxt && !parsedRobotsTxt.isAllowed(mainResource.url, userAgent)) {
+      const line = parsedRobotsTxt.getMatchingLineNumber(mainResource.url) || 1;
+      blockingDirectives.push({
+        source: {
+          type: /** @type {const} */ ('source-location'),
+          url: robotsTxtUrl.href,
+          urlProvider: /** @type {const} */ ('network'),
+          line: line - 1,
+          column: 0,
+        },
+      });
+    }
+
+    return blockingDirectives;
+  }
+
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context
@@ -92,57 +170,51 @@ class IsCrawlable extends Audit {
    */
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    const metaRobots = artifacts.MetaElements.find(meta => meta.name === 'robots');
     const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
-    /** @type {LH.Audit.Details.Table['items']} */
-    const blockingDirectives = [];
 
-    if (metaRobots) {
-      const metaRobotsContent = metaRobots.content || '';
-      const isBlocking = hasBlockingDirective(metaRobotsContent);
-
-      if (isBlocking) {
-        blockingDirectives.push({
-          source: {
-            ...Audit.makeNodeItem(metaRobots.node),
-            snippet: `<meta name="robots" content="${metaRobotsContent}" />`,
-          },
-        });
+    const robotsTxtUrl = new URL('/robots.txt', mainResource.url);
+    const parsedRobotsTxt = artifacts.RobotsTxt.content ?
+      robotsParser(robotsTxtUrl.href, artifacts.RobotsTxt.content) :
+      undefined;
+
+    // Only fail if all known bots and generic bots (UserAgent '*' or 'robots' directive)
+    // are blocked from crawling.
+    // If at least one bot is allowed, we pass the audit. Any known bots that are not allowed
+    // will be listed in a warning.
+
+    /** @type {Array<string|undefined>} */
+    const blockedUserAgents = [];
+    const genericBlockingDirectives = [];
+
+    for (const userAgent of BOT_USER_AGENTS) {
+      const blockingDirectives = IsCrawlable.determineIfCrawlableForUserAgent(
+        userAgent, mainResource, artifacts.MetaElements, parsedRobotsTxt, robotsTxtUrl);
+      if (blockingDirectives.length > 0) {
+        blockedUserAgents.push(userAgent);
+      }
+      if (userAgent === undefined) {
+        genericBlockingDirectives.push(...blockingDirectives);
       }
     }
 
-    mainResource.responseHeaders && mainResource.responseHeaders
-      .filter(h => h.name.toLowerCase() === ROBOTS_HEADER && !hasUserAgent(h.value) &&
-        hasBlockingDirective(h.value))
-      .forEach(h => blockingDirectives.push({source: `${h.name}: ${h.value}`}));
-
-    if (artifacts.RobotsTxt.content) {
-      const robotsFileUrl = new URL('/robots.txt', mainResource.url);
-      const robotsTxt = robotsParser(robotsFileUrl.href, artifacts.RobotsTxt.content);
-
-      if (!robotsTxt.isAllowed(mainResource.url)) {
-        const line = robotsTxt.getMatchingLineNumber(mainResource.url) || 1;
-        blockingDirectives.push({
-          source: {
-            type: /** @type {const} */ ('source-location'),
-            url: robotsFileUrl.href,
-            urlProvider: /** @type {const} */ ('network'),
-            line: line - 1,
-            column: 0,
-          },
-        });
-      }
+    const score = blockedUserAgents.length === BOT_USER_AGENTS.size ? 0 : 1;
+    const warnings = [];
+    if (score && blockedUserAgents.length > 0) {
+      const list = blockedUserAgents.filter(Boolean).join(', ');
+      // eslint-disable-next-line max-len
+      warnings.push(`The following bot user agents are blocked from crawling: ${list}. The audit is otherwise passing, because at least one bot was explicitly allowed.`);
     }
 
     /** @type {LH.Audit.Details.Table['headings']} */
     const headings = [
       {key: 'source', valueType: 'code', label: 'Blocking Directive Source'},
     ];
-    const details = Audit.makeTableDetails(headings, blockingDirectives);
+    const details = Audit.makeTableDetails(headings, score === 0 ? genericBlockingDirectives : []);
 
     return {
-      score: Number(blockingDirectives.length === 0),
+      score,
       details,
+      warnings,
     };
   }
 }

package/core/config/config-helpers.js

@@ -364,18 +364,18 @@ function resolveSettings(settingsJson = {}, overrides = undefined) {
 }
 
 /**
- * @param {LH.Config.Json} configJSON
+ * @param {LH.Config} config
  * @param {string | undefined} configDir
  * @param {{plugins?: string[]} | undefined} flags
- * @return {Promise<LH.Config.Json>}
+ * @return {Promise<LH.Config>}
  */
-async function mergePlugins(configJSON, configDir, flags) {
-  const configPlugins = configJSON.plugins || [];
+async function mergePlugins(config, configDir, flags) {
+  const configPlugins = config.plugins || [];
   const flagPlugins = flags?.plugins || [];
   const pluginNames = new Set([...configPlugins, ...flagPlugins]);
 
   for (const pluginName of pluginNames) {
-    validation.assertValidPluginName(configJSON, pluginName);
+    validation.assertValidPluginName(config, pluginName);
 
     // In bundled contexts, `resolveModulePath` will fail, so use the raw pluginName directly.
     const pluginPath = isBundledEnvironment() ?
@@ -384,10 +384,10 @@ async function mergePlugins(configJSON, configDir, flags) {
     const rawPluginJson = await requireWrapper(pluginPath);
     const pluginJson = ConfigPlugin.parsePlugin(rawPluginJson, pluginName);
 
-    configJSON = mergeConfigFragment(configJSON, pluginJson);
+    config = mergeConfigFragment(config, pluginJson);
   }
 
-  return configJSON;
+  return config;
 }
 
 
@@ -428,7 +428,7 @@ async function resolveGathererToDefn(gathererJson, coreGathererList, configDir)
  * Take an array of audits and audit paths and require any paths (possibly
  * relative to the optional `configDir`) using `resolveModule`,
  * leaving only an array of AuditDefns.
- * @param {LH.Config.Json['audits']} audits
+ * @param {LH.Config['audits']} audits
  * @param {string=} configDir
  * @return {Promise<Array<LH.Config.AuditDefn>|null>}
  */
@@ -585,10 +585,10 @@ function deepClone(json) {
 }
 
 /**
- * Deep clone a ConfigJson, copying over any "live" gatherer or audit that
+ * Deep clone a config, copying over any "live" gatherer or audit that
  * wouldn't make the JSON round trip.
- * @param {LH.Config.Json} json
- * @return {LH.Config.Json}
+ * @param {LH.Config} json
+ * @return {LH.Config}
  */
 function deepCloneConfigJson(json) {
   const cloned = deepClone(json);

package/core/config/config-plugin.js

@@ -215,11 +215,11 @@ class ConfigPlugin {
   }
 
   /**
-   * Extracts and validates a ConfigJson from the provided plugin input, throwing
+   * Extracts and validates a config from the provided plugin input, throwing
    * if it deviates from the expected object shape.
    * @param {unknown} pluginJson
    * @param {string} pluginName
-   * @return {LH.Config.Json}
+   * @return {LH.Config}
    */
   static parsePlugin(pluginJson, pluginName) {
     // Clone to prevent modifications of original and to deactivate any live properties.

package/core/config/config.js

@@ -38,19 +38,19 @@ const defaultConfigPath = path.join(
 );
 
 /**
- * @param {LH.Config.Json|undefined} configJSON
+ * @param {LH.Config|undefined} config
  * @param {{configPath?: string}} context
- * @return {{configWorkingCopy: LH.Config.Json, configDir?: string, configPath?: string}}
+ * @return {{configWorkingCopy: LH.Config, configDir?: string, configPath?: string}}
  */
-function resolveWorkingCopy(configJSON, context) {
+function resolveWorkingCopy(config, context) {
   let {configPath} = context;
 
   if (configPath && !path.isAbsolute(configPath)) {
     throw new Error('configPath must be an absolute path');
   }
 
-  if (!configJSON) {
-    configJSON = defaultConfig;
+  if (!config) {
+    config = defaultConfig;
     configPath = defaultConfigPath;
   }
 
@@ -58,24 +58,24 @@ function resolveWorkingCopy(configJSON, context) {
   const configDir = configPath ? path.dirname(configPath) : undefined;
 
   return {
-    configWorkingCopy: deepCloneConfigJson(configJSON),
+    configWorkingCopy: deepCloneConfigJson(config),
     configPath,
     configDir,
   };
 }
 
 /**
- * @param {LH.Config.Json} configJSON
- * @return {LH.Config.Json}
+ * @param {LH.Config} config
+ * @return {LH.Config}
  */
-function resolveExtensions(configJSON) {
-  if (!configJSON.extends) return configJSON;
+function resolveExtensions(config) {
+  if (!config.extends) return config;
 
-  if (configJSON.extends !== 'lighthouse:default') {
+  if (config.extends !== 'lighthouse:default') {
     throw new Error('`lighthouse:default` is the only valid extension method.');
   }
 
-  const {artifacts, ...extensionJSON} = configJSON;
+  const {artifacts, ...extensionJSON} = config;
   const defaultClone = deepCloneConfigJson(defaultConfig);
   const mergedConfig = mergeConfigFragment(defaultClone, extensionJSON);
 
@@ -236,15 +236,15 @@ function resolveFakeNavigations(artifactDefns, settings) {
 
 /**
  * @param {LH.Gatherer.GatherMode} gatherMode
- * @param {LH.Config.Json=} configJSON
+ * @param {LH.Config=} config
  * @param {LH.Flags=} flags
  * @return {Promise<{resolvedConfig: LH.Config.ResolvedConfig, warnings: string[]}>}
  */
-async function initializeConfig(gatherMode, configJSON, flags = {}) {
+async function initializeConfig(gatherMode, config, flags = {}) {
   const status = {msg: 'Initialize config', id: 'lh:config'};
   log.time(status, 'verbose');
 
-  let {configWorkingCopy, configDir} = resolveWorkingCopy(configJSON, flags);
+  let {configWorkingCopy, configDir} = resolveWorkingCopy(config, flags);
 
   configWorkingCopy = resolveExtensions(configWorkingCopy);
   configWorkingCopy = await mergePlugins(configWorkingCopy, configDir, flags);

package/core/config/default-config.js

@@ -170,7 +170,7 @@ for (const key of Object.keys(artifacts)) {
   artifacts[/** @type {keyof typeof artifacts} */ (key)] = key;
 }
 
-/** @type {LH.Config.Json} */
+/** @type {LH.Config} */
 const defaultConfig = {
   settings: constants.defaultSettings,
   artifacts: [
@@ -517,7 +517,6 @@ const defaultConfig = {
         {id: 'non-composited-animations', weight: 0},
         {id: 'unsized-images', weight: 0},
         {id: 'viewport', weight: 0},
-        {id: 'no-unload-listeners', weight: 0},
         {id: 'uses-responsive-images-snapshot', weight: 0},
         {id: 'work-during-interaction', weight: 0},
         {id: 'bf-cache', weight: 0},
@@ -623,6 +622,7 @@ const defaultConfig = {
         {id: 'doctype', weight: 1, group: 'best-practices-browser-compat'},
         {id: 'charset', weight: 1, group: 'best-practices-browser-compat'},
         // General Group
+        {id: 'no-unload-listeners', weight: 1, group: 'best-practices-general'},
         {id: 'js-libraries', weight: 0, group: 'best-practices-general'},
         {id: 'deprecations', weight: 1, group: 'best-practices-general'},
         {id: 'errors-in-console', weight: 1, group: 'best-practices-general'},

package/core/config/desktop-config.js

@@ -6,7 +6,7 @@
 
 import * as constants from './constants.js';
 
-/** @type {LH.Config.Json} */
+/** @type {LH.Config} */
 const config = {
   extends: 'lighthouse:default',
   settings: {

package/core/config/experimental-config.js

@@ -9,7 +9,7 @@
  * being enabled by default.
  */
 
-/** @type {LH.Config.Json} */
+/** @type {LH.Config} */
 const config = {
   extends: 'lighthouse:default',
   audits: [

package/core/config/full-config.js

@@ -4,7 +4,7 @@
  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  */
 
-/** @type {LH.Config.Json} */
+/** @type {LH.Config} */
 const fullConfig = {
   extends: 'lighthouse:default',
   settings: {},

package/core/config/lr-desktop-config.js

@@ -6,7 +6,7 @@
 
 import * as constants from './constants.js';
 
-/** @type {LH.Config.Json} */
+/** @type {LH.Config} */
 const config = {
   extends: 'lighthouse:default',
   settings: {