lighthouse 10.4.0 → 11.0.0

package/core/lib/navigation-error.js

@@ -95,6 +95,9 @@ function getNonHtmlError(finalRecord) {
   // If we never requested a document, there's no doctype error, let other cases handle it.
   if (!finalRecord) return undefined;
 
+  // If the document request error'd, we should not complain about a bad mimeType.
+  if (!finalRecord.mimeType || finalRecord.statusCode === -1) return undefined;
+
   // mimeType is determined by the browser, we assume Chrome is determining mimeType correctly,
   // independently of 'Content-Type' response headers, and always sending mimeType if well-formed.
   if (finalRecord.mimeType !== HTML_MIME_TYPE && finalRecord.mimeType !== XHTML_MIME_TYPE) {
@@ -163,6 +166,8 @@ function getPageLoadError(navigationError, context) {
   // Navigation errors are rather generic and express some failure of the page to render properly.
   // Use `navigationError` as the last resort.
   // Example: `NO_FCP`, the page never painted content for some unknown reason.
+  // Note that the caller possibly gave this to us as undefined, in which case we have determined
+  // there to be no error with this page load - but there was perhaps a warning.
   return navigationError;
 }
 

package/core/lib/network-recorder.d.ts

@@ -17,7 +17,7 @@ export class NetworkRecorder extends NetworkRecorder_base {
      * @param {LH.DevtoolsLog} devtoolsLog
      * @return {Array<LH.Artifacts.NetworkRequest>}
      */
-    static recordsFromLogs(devtoolsLog: import("../index.js").DevtoolsLog): Array<LH.Artifacts.NetworkRequest>;
+    static recordsFromLogs(devtoolsLog: LH.DevtoolsLog): Array<LH.Artifacts.NetworkRequest>;
     /** @type {NetworkRequest[]} */
     _records: NetworkRequest[];
     /** @type {Map<string, NetworkRequest>} */
@@ -117,5 +117,6 @@ export class NetworkRecorder extends NetworkRecorder_base {
     _findRealRequestAndSetSession(requestId: string, targetType: LH.Protocol.TargetType, sessionId: string | undefined): NetworkRequest | undefined;
 }
 import { NetworkRequest } from './network-request.js';
+import * as LH from '../../types/lh.js';
 export {};
 //# sourceMappingURL=network-recorder.d.ts.map

package/core/lib/network-recorder.js

@@ -8,6 +8,7 @@ import {EventEmitter} from 'events';
 
 import log from 'lighthouse-logger';
 
+import * as LH from '../../types/lh.js';
 import {NetworkRequest} from './network-request.js';
 import {PageDependencyGraph} from '../computed/page-dependency-graph.js';
 

package/core/lib/network-request.js

@@ -489,7 +489,7 @@ class NetworkRequest {
     // Bail if there was no totalTime.
     if (!totalHeader) return;
 
-    const totalMs = parseInt(totalHeader.value);
+    let totalMs = parseInt(totalHeader.value);
     const TCPMsHeader = this.responseHeaders.find(item => item.name === HEADER_TCP);
     const SSLMsHeader = this.responseHeaders.find(item => item.name === HEADER_SSL);
     const requestMsHeader = this.responseHeaders.find(item => item.name === HEADER_REQ);
@@ -502,11 +502,20 @@ class NetworkRequest {
     const requestMs = requestMsHeader ? Math.max(0, parseInt(requestMsHeader.value)) : 0;
     const responseMs = responseMsHeader ? Math.max(0, parseInt(responseMsHeader.value)) : 0;
 
-    // Bail if the timings don't add up.
-    if (TCPMs + requestMs + responseMs !== totalMs) {
+    if (Number.isNaN(TCPMs + requestMs + responseMs + totalMs)) {
       return;
     }
 
+    // If things don't add up, tweak the total a bit.
+    if (TCPMs + requestMs + responseMs !== totalMs) {
+      const delta = Math.abs(TCPMs + requestMs + responseMs - totalMs);
+      // We didn't see total being more than 5ms less than the total of the components.
+      // Allow some discrepancy in the timing, but not too much.
+      if (delta >= 25) return;
+
+      totalMs = TCPMs + requestMs + responseMs;
+    }
+
     // Bail if SSL time is > TCP time.
     if (SSLMs > TCPMs) {
       return;

package/core/lib/page-functions.d.ts

@@ -11,6 +11,8 @@ export namespace pageFunctions {
     export { wrapRequestIdleCallback };
     export { getBoundingClientRect };
     export { truncate };
+    export { esbuildFunctionWrapperString };
+    export { getRuntimeFunctionName };
 }
 /**
  * `typed-query-selector`'s CSS selector parser.
@@ -49,11 +51,11 @@ declare function wrapRuntimeEvalErrorInBrowser(err?: string | Error | undefined)
 };
 /**
  * @template {string} T
- * @param {T} selector Optional simple CSS selector to filter nodes on.
+ * @param {T=} selector Optional simple CSS selector to filter nodes on.
  *     Combinators are not supported.
  * @return {Array<ParseSelector<T>>}
  */
-declare function getElementsInDocument<T extends string>(selector: T): import("typed-query-selector/parser").ParseSelector<T, Element>[];
+declare function getElementsInDocument<T extends string>(selector?: T | undefined): import("typed-query-selector/parser").ParseSelector<T, Element>[];
 /**
  * Gets the opening tag text of the given node.
  * @param {Element|ShadowRoot} element
@@ -157,5 +159,11 @@ declare function truncate(string: string, characterLimit: number): string;
 declare namespace truncate {
     function toString(): string;
 }
+declare const esbuildFunctionWrapperString: string;
+/**
+ * @param {Function} fn
+ * @return {string}
+ */
+declare function getRuntimeFunctionName(fn: Function): string;
 export {};
 //# sourceMappingURL=page-functions.d.ts.map

package/core/lib/page-functions.js

@@ -4,6 +4,8 @@
  * 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.
  */
 
+import {createRequire} from 'module';
+
 import {Util} from '../../shared/util.js';
 
 /**
@@ -50,7 +52,7 @@ function wrapRuntimeEvalErrorInBrowser(err) {
 
 /**
  * @template {string} T
- * @param {T} selector Optional simple CSS selector to filter nodes on.
+ * @param {T=} selector Optional simple CSS selector to filter nodes on.
  *     Combinators are not supported.
  * @return {Array<ParseSelector<T>>}
  */
@@ -513,16 +515,89 @@ function truncate(string, characterLimit) {
   return Util.truncate(string, characterLimit);
 }
 
-/** @type {string} */
-const truncateRawString = truncate.toString();
-truncate.toString = () => `function truncate(string, characterLimit) {
+function isBundledEnvironment() {
+  // If we're in DevTools or LightRider, we are definitely bundled.
+  // TODO: refactor and delete `global.isDevtools`.
+  if (global.isDevtools || global.isLightrider) return true;
+
+  const require = createRequire(import.meta.url);
+
+  try {
+    // Not foolproof, but `lighthouse-logger` is a dependency of lighthouse that should always be resolvable.
+    // `require.resolve` will only throw in atypical/bundled environments.
+    require.resolve('lighthouse-logger');
+    return false;
+  } catch (err) {
+    return true;
+  }
+}
+
+// This is to support bundled lighthouse.
+// esbuild calls every function with a builtin `__name` (since we set keepNames: true),
+// whose purpose is to store the real name of the function so that esbuild can rename it to avoid
+// collisions. Anywhere we inject dynamically generated code at runtime for the browser to process,
+// we must manually include this function (because esbuild only does so once at the top scope of
+// the bundle, which is irrelevant for code executed in the browser).
+// When minified, esbuild will mangle the name of this wrapper function, so we need to determine what it
+// is at runtime in order to recreate it within the page.
+const esbuildFunctionWrapperString = createEsbuildFunctionWrapper();
+
+function createEsbuildFunctionWrapper() {
+  if (!isBundledEnvironment()) {
+    return '';
+  }
+
+  const functionAsString = (()=>{
+    // eslint-disable-next-line no-unused-vars
+    const a = ()=>{};
+  }).toString()
+    // When not minified, esbuild annotates the call to this function wrapper with PURE.
+    // We know further that the name of the wrapper function should be `__name`, but let's not
+    // hardcode that. Remove the PURE annotation to simplify the regex.
+    .replace('/* @__PURE__ */', '');
+  const functionStringMatch = functionAsString.match(/=\s*([\w_]+)\(/);
+  if (!functionStringMatch) {
+    throw new Error('Could not determine esbuild function wrapper name');
+  }
+
+  /**
+   * @param {Function} fn
+   * @param {string} value
+   */
+  const esbuildFunctionWrapper = (fn, value) =>
+    Object.defineProperty(fn, 'name', {value, configurable: true});
+  const wrapperFnName = functionStringMatch[1];
+  return `let ${wrapperFnName}=${esbuildFunctionWrapper}`;
+}
+
+/**
+ * @param {Function} fn
+ * @return {string}
+ */
+function getRuntimeFunctionName(fn) {
+  const match = fn.toString().match(/function ([\w$]+)/);
+  if (!match) throw new Error(`could not find function name for: ${fn}`);
+  return match[1];
+}
+
+// We setup a number of our page functions to automatically include their dependencies.
+// Because of esbuild bundling, we must refer to the actual (mangled) runtime function name.
+/** @type {Record<string, string>} */
+const names = {
+  truncate: getRuntimeFunctionName(truncate),
+  getNodeLabel: getRuntimeFunctionName(getNodeLabel),
+  getOuterHTMLSnippet: getRuntimeFunctionName(getOuterHTMLSnippet),
+  getNodeDetails: getRuntimeFunctionName(getNodeDetails),
+};
+
+truncate.toString = () => `function ${names.truncate}(string, characterLimit) {
   const Util = { ${Util.truncate} };
-  return (${truncateRawString})(string, characterLimit);
+  return Util.truncate(string, characterLimit);
 }`;
 
 /** @type {string} */
 const getNodeLabelRawString = getNodeLabel.toString();
-getNodeLabel.toString = () => `function getNodeLabel(element) {
+getNodeLabel.toString = () => `function ${names.getNodeLabel}(element) {
   ${truncate};
   return (${getNodeLabelRawString})(element);
 }`;
@@ -530,14 +605,14 @@ getNodeLabel.toString = () => `function getNodeLabel(element) {
 /** @type {string} */
 const getOuterHTMLSnippetRawString = getOuterHTMLSnippet.toString();
 // eslint-disable-next-line max-len
-getOuterHTMLSnippet.toString = () => `function getOuterHTMLSnippet(element, ignoreAttrs = [], snippetCharacterLimit = 500) {
+getOuterHTMLSnippet.toString = () => `function ${names.getOuterHTMLSnippet}(element, ignoreAttrs = [], snippetCharacterLimit = 500) {
   ${truncate};
   return (${getOuterHTMLSnippetRawString})(element, ignoreAttrs, snippetCharacterLimit);
 }`;
 
 /** @type {string} */
 const getNodeDetailsRawString = getNodeDetails.toString();
-getNodeDetails.toString = () => `function getNodeDetails(element) {
+getNodeDetails.toString = () => `function ${names.getNodeDetails}(element) {
   ${truncate};
   ${getNodePath};
   ${getNodeSelector};
@@ -560,4 +635,6 @@ export const pageFunctions = {
   wrapRequestIdleCallback,
   getBoundingClientRect,
   truncate,
+  esbuildFunctionWrapperString,
+  getRuntimeFunctionName,
 };

package/core/lib/sentry.js

@@ -126,9 +126,16 @@ async function init(opts) {
         if (opts.tags) {
           scope.setTags(opts.tags);
         }
-        if (opts.extra) {
-          scope.setExtras(opts.extra);
+
+        // Add extra details
+        let extra;
+        if (opts.extra) extra = {...opts.extra};
+        // @ts-expect-error Non-standard property
+        if (err.extra) extra = {...extra, ...err.extra};
+        if (extra) {
+          scope.setExtras(extra);
         }
+
         Sentry.captureException(err);
       });
     };

package/core/lib/stack-packs.js

@@ -39,6 +39,10 @@ const stackPacksToInclude = [
     packId: 'drupal',
     requiredStacks: ['js:drupal'],
   },
+  {
+    packId: 'nitropack',
+    requiredStacks: ['js:nitropack'],
+  },
   {
     packId: 'amp',
     requiredStacks: ['js:amp'],

package/core/runner.d.ts

@@ -1,19 +1,13 @@
-export type Connection = import('./legacy/gather/connections/connection.js').Connection;
 export type ArbitraryEqualityMap = import('./lib/arbitrary-equality-map.js').ArbitraryEqualityMap;
-export type Config = LH.Config.LegacyResolvedConfig;
-/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
 /** @typedef {import('./lib/arbitrary-equality-map.js').ArbitraryEqualityMap} ArbitraryEqualityMap */
-/** @typedef {LH.Config.LegacyResolvedConfig} Config */
 export class Runner {
     /**
-     * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
      * @param {LH.Artifacts} artifacts
-     * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+     * @param {{resolvedConfig: LH.Config.ResolvedConfig, computedCache: Map<string, ArbitraryEqualityMap>}} options
      * @return {Promise<LH.RunnerResult|undefined>}
      */
-    static audit<TConfig extends import("../types/config.js").default.ResolvedConfig | import("../types/config.js").default.LegacyResolvedConfig>(artifacts: LH.Artifacts, options: {
-        resolvedConfig: TConfig;
-        driverMock?: Driver | undefined;
+    static audit(artifacts: LH.Artifacts, options: {
+        resolvedConfig: LH.Config.ResolvedConfig;
         computedCache: Map<string, ArbitraryEqualityMap>;
     }): Promise<LH.RunnerResult | undefined>;
     /**
@@ -26,17 +20,14 @@ export 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.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
+     * @param {(runnerData: {resolvedConfig: LH.Config.ResolvedConfig}) => Promise<LH.Artifacts>} gatherFn
+     * @param {{resolvedConfig: LH.Config.ResolvedConfig, computedCache: Map<string, ArbitraryEqualityMap>}} options
      * @return {Promise<LH.Artifacts>}
      */
-    static gather<TConfig_1 extends import("../types/config.js").default.ResolvedConfig | import("../types/config.js").default.LegacyResolvedConfig>(gatherFn: (runnerData: {
-        resolvedConfig: TConfig_1;
-        driverMock?: Driver | undefined;
+    static gather(gatherFn: (runnerData: {
+        resolvedConfig: LH.Config.ResolvedConfig;
     }) => Promise<LH.Artifacts>, options: {
-        resolvedConfig: TConfig_1;
-        driverMock?: Driver | undefined;
+        resolvedConfig: LH.Config.ResolvedConfig;
         computedCache: Map<string, ArbitraryEqualityMap>;
     }): Promise<LH.Artifacts>;
     /**
@@ -52,18 +43,6 @@ export class Runner {
      * @return {LH.Result.Timing}
      */
     static _getTiming(artifacts: LH.Artifacts): LH.Result.Timing;
-    /**
-     * Establish connection, load page and collect all required artifacts
-     * @param {string} requestedUrl
-     * @param {{resolvedConfig: Config, computedCache: Map<string, ArbitraryEqualityMap>, driverMock?: Driver}} runnerOpts
-     * @param {Connection} connection
-     * @return {Promise<LH.Artifacts>}
-     */
-    static _gatherArtifactsFromBrowser(requestedUrl: string, runnerOpts: {
-        resolvedConfig: Config;
-        computedCache: Map<string, ArbitraryEqualityMap>;
-        driverMock?: Driver;
-    }, connection: Connection): Promise<LH.Artifacts>;
     /**
      * Run all audits with specified settings and artifacts.
      * @param {LH.Config.Settings} settings
@@ -109,6 +88,5 @@ export class Runner {
      */
     static _getDataSavePath(settings: LH.Config.Settings): string;
 }
-import { Driver } from './legacy/gather/driver.js';
 import { Audit } from './audits/audit.js';
 //# sourceMappingURL=runner.d.ts.map

package/core/runner.js

@@ -11,8 +11,6 @@ import path from 'path';
 import log from 'lighthouse-logger';
 import isDeepEqual from 'lodash/isEqual.js';
 
-import {Driver} from './legacy/gather/driver.js';
-import {GatherRunner} from './legacy/gather/gather-runner.js';
 import {ReportScoring} from './scoring.js';
 import {Audit} from './audits/audit.js';
 import * as format from '../shared/localization/format.js';
@@ -28,15 +26,12 @@ import UrlUtils from './lib/url-utils.js';
 
 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.LegacyResolvedConfig} Config */
 
 class Runner {
   /**
-   * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
    * @param {LH.Artifacts} artifacts
-   * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+   * @param {{resolvedConfig: LH.Config.ResolvedConfig, computedCache: Map<string, ArbitraryEqualityMap>}} options
    * @return {Promise<LH.RunnerResult|undefined>}
    */
   static async audit(artifacts, options) {
@@ -153,7 +148,7 @@ class Runner {
    * @param {LH.Artifacts.ComputedContext} context
    */
   static async getEntityClassification(artifacts, context) {
-    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs?.[Audit.DEFAULT_PASS];
     if (!devtoolsLog) return;
     const classifiedEntities = await EntityClassification.request(
       {URL: artifacts.URL, devtoolsLog}, context);
@@ -188,9 +183,8 @@ 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.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
+   * @param {(runnerData: {resolvedConfig: LH.Config.ResolvedConfig}) => Promise<LH.Artifacts>} gatherFn
+   * @param {{resolvedConfig: LH.Config.ResolvedConfig, computedCache: Map<string, ArbitraryEqualityMap>}} options
    * @return {Promise<LH.Artifacts>}
    */
   static async gather(gatherFn, options) {
@@ -217,7 +211,6 @@ class Runner {
 
         artifacts = await gatherFn({
           resolvedConfig: options.resolvedConfig,
-          driverMock: options.driverMock,
         });
 
         log.timeEnd(runnerStatus);
@@ -291,28 +284,6 @@ class Runner {
     return {entries: timingEntries, total: gatherTiming + auditTiming};
   }
 
-  /**
-   * Establish connection, load page and collect all required artifacts
-   * @param {string} requestedUrl
-   * @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.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.resolvedConfig.settings,
-      computedCache: runnerOpts.computedCache,
-    };
-    const artifacts = await GatherRunner.run(runnerOpts.resolvedConfig.passes, gatherOpts);
-    return artifacts;
-  }
-
   /**
    * Run all audits with specified settings and artifacts.
    * @param {LH.Config.Settings} settings
@@ -396,6 +367,8 @@ class Runner {
 
     let auditResult;
     try {
+      if (artifacts.PageLoadError) throw artifacts.PageLoadError;
+
       // Return an early error if an artifact required for the audit is missing or an error.
       for (const artifactName of audit.meta.requiredArtifacts) {
         const noArtifact = artifacts[artifactName] === undefined;
@@ -419,15 +392,11 @@ class Runner {
           // @ts-expect-error: TODO why is this a type error now?
           const artifactError = artifacts[artifactName];
 
-          Sentry.captureException(artifactError, {
-            tags: {gatherer: artifactName},
-            level: 'error',
-          });
-
           log.warn('Runner', `${artifactName} gatherer, required by audit ${audit.meta.id},` +
             ` encountered an error: ${artifactError.message}`);
 
-          // Create a friendlier display error and mark it as expected to avoid duplicates in Sentry
+          // Create a friendlier display error and mark it as expected to avoid duplicates in Sentry.
+          // The artifact error was already sent to Sentry in `collectPhaseArtifacts`.
           const error = new LighthouseError(LighthouseError.errors.ERRORED_REQUIRED_ARTIFACT,
               {artifactName, errorMessage: artifactError.message}, {cause: artifactError});
           // @ts-expect-error Non-standard property added to Error

package/core/user-flow.d.ts

@@ -1,4 +1,4 @@
-export type GatherStepRunnerOptions = WeakMap<LH.UserFlow.GatherStep, LH.Gatherer.FRGatherResult['runnerOptions']>;
+export type GatherStepRunnerOptions = WeakMap<LH.UserFlow.GatherStep, LH.Gatherer.GatherResult['runnerOptions']>;
 export class UserFlow {
     /**
      * @param {LH.Puppeteer.Page} page
@@ -24,10 +24,10 @@ export class UserFlow {
      */
     _getNextNavigationFlags(flags: LH.UserFlow.StepFlags | undefined): LH.UserFlow.StepFlags;
     /**
-     * @param {LH.Gatherer.FRGatherResult} gatherResult
+     * @param {LH.Gatherer.GatherResult} gatherResult
      * @param {LH.UserFlow.StepFlags} [flags]
      */
-    _addGatherStep(gatherResult: LH.Gatherer.FRGatherResult, flags?: LH.UserFlow.StepFlags | undefined): void;
+    _addGatherStep(gatherResult: LH.Gatherer.GatherResult, flags?: LH.UserFlow.StepFlags | undefined): void;
     /**
      * @param {LH.NavigationRequestor} requestor
      * @param {LH.UserFlow.StepFlags} [flags]
@@ -50,7 +50,7 @@ export class UserFlow {
     startTimespan(flags?: LH.UserFlow.StepFlags | undefined): Promise<void>;
     currentTimespan: {
         timespan: {
-            endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>;
+            endTimespanGather(): Promise<LH.Gatherer.GatherResult>;
         };
         flags: LH.UserFlow.StepFlags | undefined;
     } | undefined;

package/core/user-flow.js

@@ -15,7 +15,7 @@ import {mergeConfigFragment, deepClone} from './config/config-helpers.js';
 import * as i18n from './lib/i18n/i18n.js';
 import * as LH from '../types/lh.js';
 
-/** @typedef {WeakMap<LH.UserFlow.GatherStep, LH.Gatherer.FRGatherResult['runnerOptions']>} GatherStepRunnerOptions */
+/** @typedef {WeakMap<LH.UserFlow.GatherStep, LH.Gatherer.GatherResult['runnerOptions']>} GatherStepRunnerOptions */
 
 const UIStrings = {
   /**
@@ -107,7 +107,7 @@ class UserFlow {
   }
 
   /**
-   * @param {LH.Gatherer.FRGatherResult} gatherResult
+   * @param {LH.Gatherer.GatherResult} gatherResult
    * @param {LH.UserFlow.StepFlags} [flags]
    */
   _addGatherStep(gatherResult, flags) {