lighthouse 9.5.0-dev.20230111 → 9.5.0-dev.20230113

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/cli-flags.js

@@ -205,12 +205,16 @@ function getYargsParser(manualArgv) {
         type: 'string',
         describe: 'The path to the budget.json file for LightWallet.',
       },
+      'disable-full-page-screenshot': {
+        type: 'boolean',
+        describe: 'Disables collection of the full page screenshot, which can be quite large',
+      },
     })
     .group([
       'save-assets', 'list-all-audits', 'list-locales', 'list-trace-categories', 'additional-trace-categories',
       'config-path', 'preset', 'chrome-flags', 'port', 'hostname', 'form-factor', 'screenEmulation', 'emulatedUserAgent',
       'max-wait-for-load', 'enable-error-reporting', 'gather-mode', 'audit-mode',
-      'only-audits', 'only-categories', 'skip-audits', 'budget-path',
+      'only-audits', 'only-categories', 'skip-audits', 'budget-path', 'disable-full-page-screenshot',
     ], 'Configuration:')
 
     // Output

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/core-tests.js

@@ -15,6 +15,7 @@ import errorsIframeExpiredSsl from './test-definitions/errors-iframe-expired-ssl
 import errorsInfiniteLoop from './test-definitions/errors-infinite-loop.js';
 import formsAutoComplete from './test-definitions/forms-autocomplete.js';
 import fpsMax from './test-definitions/fps-max.js';
+import fpsMaxPassive from './test-definitions/fps-max-passive.js';
 import fpsScaled from './test-definitions/fps-scaled.js';
 import issuesMixedContent from './test-definitions/issues-mixed-content.js';
 import lanternFetch from './test-definitions/lantern-fetch.js';
@@ -79,6 +80,7 @@ const smokeTests = [
   formsAutoComplete,
   fpsMax,
   fpsScaled,
+  fpsMaxPassive,
   issuesMixedContent,
   lanternFetch,
   lanternIdleCallbackLong,

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/report-assert.js

@@ -391,30 +391,34 @@ function collateResults(localConsole, actual, expected) {
     return makeComparison(auditName + ' audit', actualResult, expectedResult);
   });
 
-  const timingAssertions = [];
+  /** @type {Comparison[]} */
+  const extraAssertions = [];
+
   if (expected.lhr.timing) {
     const comparison = makeComparison('timing', actual.lhr.timing, expected.lhr.timing);
-    timingAssertions.push(comparison);
+    extraAssertions.push(comparison);
   }
 
-  /** @type {Comparison[]} */
-  const requestCountAssertion = [];
   if (expected.networkRequests) {
-    requestCountAssertion.push(makeComparison(
+    extraAssertions.push(makeComparison(
       'Requests',
       actual.networkRequests,
       expected.networkRequests
     ));
   }
 
+  if (expected.lhr.fullPageScreenshot) {
+    extraAssertions.push(makeComparison('fullPageScreenshot', actual.lhr.fullPageScreenshot,
+      expected.lhr.fullPageScreenshot));
+  }
+
   return [
     makeComparison('final url', actual.lhr.finalDisplayedUrl, expected.lhr.finalDisplayedUrl),
     runtimeErrorAssertion,
     runWarningsAssertion,
-    ...requestCountAssertion,
     ...artifactAssertions,
     ...auditAssertions,
-    ...timingAssertions,
+    ...extraAssertions,
   ];
 }
 

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.