lighthouse 9.5.0-dev.20230110 → 9.5.0-dev.20230112

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: [
@@ -217,8 +217,11 @@ const defaultConfig = {
     {id: artifacts.devtoolsLogs, gatherer: 'devtools-log-compat'},
     {id: artifacts.traces, gatherer: 'trace-compat'},
 
-    // FullPageScreenshot comes at the very end so all other node analysis is captured.
+    // FullPageScreenshot comes at the end so all other node analysis is captured.
     {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
+
+    // BFCacheErrors comes at the very end because it can perform a page navigation.
+    {id: artifacts.BFCacheFailures, gatherer: 'bf-cache-failures'},
   ],
   audits: [
     'is-on-https',
@@ -374,6 +377,7 @@ const defaultConfig = {
     'seo/canonical',
     'seo/manual/structured-data',
     'work-during-interaction',
+    'bf-cache',
   ],
   groups: {
     'metrics': {
@@ -513,9 +517,9 @@ 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},
 
         // Budget audits.
         {id: 'performance-budget', weight: 0, group: 'budgets'},
@@ -618,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: {

package/core/config/lr-mobile-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 config = {
   extends: 'lighthouse:default',
   settings: {

package/core/config/perf-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 perfConfig = {
   extends: 'lighthouse:default',
   settings: {

package/core/config/validation.js

@@ -39,16 +39,16 @@ function isValidArtifactDependency(dependent, dependency) {
 
 /**
  * Throws if pluginName is invalid or (somehow) collides with a category in the
- * configJSON being added to.
- * @param {LH.Config.Json} configJSON
+ * config being added to.
+ * @param {LH.Config} config
  * @param {string} pluginName
  */
-function assertValidPluginName(configJSON, pluginName) {
+function assertValidPluginName(config, pluginName) {
   if (!pluginName.startsWith('lighthouse-plugin-')) {
     throw new Error(`plugin name '${pluginName}' does not start with 'lighthouse-plugin-'`);
   }
 
-  if (configJSON.categories?.[pluginName]) {
+  if (config.categories?.[pluginName]) {
     throw new Error(`plugin name '${pluginName}' not allowed because it is the id of a category already found in config`); // eslint-disable-line max-len
   }
 }

package/core/gather/driver/execution-context.js

@@ -61,8 +61,8 @@ class ExecutionContext {
     await this._session.sendCommand('Page.enable');
     await this._session.sendCommand('Runtime.enable');
 
-    const resourceTreeResponse = await this._session.sendCommand('Page.getResourceTree');
-    const mainFrameId = resourceTreeResponse.frameTree.frame.id;
+    const frameTreeResponse = await this._session.sendCommand('Page.getFrameTree');
+    const mainFrameId = frameTreeResponse.frameTree.frame.id;
 
     const isolatedWorldResponse = await this._session.sendCommand('Page.createIsolatedWorld', {
       frameId: mainFrameId,

package/core/gather/driver/network-monitor.js

@@ -95,8 +95,8 @@ class NetworkMonitor extends NetworkMonitorEventEmitter {
     const frameNavigations = this._frameNavigations;
     if (!frameNavigations.length) return {};
 
-    const resourceTreeResponse = await this._session.sendCommand('Page.getResourceTree');
-    const mainFrameId = resourceTreeResponse.frameTree.frame.id;
+    const frameTreeResponse = await this._session.sendCommand('Page.getFrameTree');
+    const mainFrameId = frameTreeResponse.frameTree.frame.id;
     const mainFrameNavigations = frameNavigations.filter(frame => frame.id === mainFrameId);
     if (!mainFrameNavigations.length) log.warn('NetworkMonitor', 'No detected navigations');
 

package/core/gather/driver/wait-for-condition.js

@@ -13,7 +13,13 @@ import {ExecutionContext} from './execution-context.js';
 
 /** @typedef {InstanceType<import('./network-monitor.js')['NetworkMonitor']>} NetworkMonitor */
 /** @typedef {import('./network-monitor.js').NetworkMonitorEvent} NetworkMonitorEvent */
-/** @typedef {{promise: Promise<void>, cancel: function(): void}} CancellableWait */
+
+/**
+ * @template [T=void]
+ * @typedef CancellableWait
+ * @prop {Promise<T>} promise
+ * @prop {() => void} cancel
+ */
 
 /**
  * @typedef WaitOptions
@@ -40,7 +46,7 @@ function waitForNothing() {
  * Returns a promise that resolve when a frame has been navigated.
  * Used for detecting that our about:blank reset has been completed.
  * @param {LH.Gatherer.FRProtocolSession} session
- * @return {CancellableWait}
+ * @return {CancellableWait<LH.Crdp.Page.FrameNavigatedEvent>}
  */
 function waitForFrameNavigated(session) {
   /** @type {(() => void)} */
@@ -48,6 +54,7 @@ function waitForFrameNavigated(session) {
     throw new Error('waitForFrameNavigated.cancel() called before it was defined');
   };
 
+  /** @type {Promise<LH.Crdp.Page.FrameNavigatedEvent>} */
   const promise = new Promise((resolve, reject) => {
     session.once('Page.frameNavigated', resolve);
     cancel = () => {

package/core/gather/gatherers/bf-cache-failures.js

@@ -8,6 +8,8 @@ import FRGatherer from '../base-gatherer.js';
 import {waitForFrameNavigated, waitForLoadEvent} from '../driver/wait-for-condition.js';
 import DevtoolsLog from './devtools-log.js';
 
+const FAILURE_EVENT_TIMEOUT = 100;
+
 class BFCacheFailures extends FRGatherer {
   /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
   meta = {
@@ -101,16 +103,32 @@ class BFCacheFailures extends FRGatherer {
     const history = await session.sendCommand('Page.getNavigationHistory');
     const entry = history.entries[history.currentIndex];
 
+    // In theory, we should be able to use about:blank here
+    // but that sometimes produces BrowsingInstanceNotSwapped failures.
+    // DevTools uses chrome://terms as it's temporary page so we should stick with that.
+    // https://github.com/GoogleChrome/lighthouse/issues/14665
     await Promise.all([
-      session.sendCommand('Page.navigate', {url: 'about:blank'}),
+      session.sendCommand('Page.navigate', {url: 'chrome://terms'}),
       waitForLoadEvent(session, 0).promise,
     ]);
 
-    await Promise.all([
+    const [, frameNavigatedEvent] = await Promise.all([
       session.sendCommand('Page.navigateToHistoryEntry', {entryId: entry.id}),
       waitForFrameNavigated(session).promise,
     ]);
 
+    // The bfcache failure event is not necessarily emitted by this point.
+    // If we are expecting a bfcache failure event but haven't seen one, we should wait for it.
+    if (frameNavigatedEvent.type !== 'BackForwardCacheRestore' && !bfCacheEvent) {
+      await new Promise(resolve => setTimeout(resolve, FAILURE_EVENT_TIMEOUT));
+
+      // If we still can't get the failure reasons after the timeout we should fail loudly,
+      // otherwise this gatherer will return no failures when there should be failures.
+      if (!bfCacheEvent) {
+        throw new Error('bfcache failed but the failure reasons were not emitted in time');
+      }
+    }
+
     session.off('Page.backForwardCacheNotUsed', onBfCacheNotUsed);
 
     return bfCacheEvent;
@@ -136,7 +154,7 @@ class BFCacheFailures extends FRGatherer {
    */
   async getArtifact(context) {
     const events = this.passivelyCollectBFCacheEvents(context);
-    if (context.gatherMode === 'navigation') {
+    if (context.gatherMode === 'navigation' && !context.settings.usePassiveGathering) {
       const activelyCollectedEvent = await this.activelyCollectBFCacheEvent(context);
       if (activelyCollectedEvent) events.push(activelyCollectedEvent);
     }

package/core/gather/navigation-runner.js

@@ -311,7 +311,7 @@ async function _cleanup({requestedUrl, driver, resolvedConfig}) {
 /**
  * @param {LH.Puppeteer.Page|undefined} page
  * @param {LH.NavigationRequestor|undefined} requestor
- * @param {{config?: LH.Config.Json, flags?: LH.Flags}} [options]
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function navigationGather(page, requestor, options = {}) {

package/core/gather/snapshot-runner.js

@@ -14,7 +14,7 @@ import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 
 /**
  * @param {LH.Puppeteer.Page} page
- * @param {{config?: LH.Config.Json, flags?: LH.Flags}} [options]
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function snapshotGather(page, options = {}) {

package/core/gather/timespan-runner.js

@@ -15,7 +15,7 @@ import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 
 /**
  * @param {LH.Puppeteer.Page} page
- * @param {{config?: LH.Config.Json, flags?: LH.Flags}} [options]
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
  * @return {Promise<{endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>}>}
  */
 async function startTimespanGather(page, options = {}) {