lighthouse 11.2.0 → 11.3.0

package/core/gather/driver/prepare.js

@@ -89,21 +89,22 @@ async function dismissJavaScriptDialogs(session) {
  * Reset the storage and warn if any stored data could be affecting the scores.
  * @param {LH.Gatherer.ProtocolSession} session
  * @param {string} url
+ * @param {LH.Config.Settings['clearStorageTypes']} clearStorageTypes
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function resetStorageForUrl(session, url) {
+async function resetStorageForUrl(session, url, clearStorageTypes) {
   /** @type {Array<LH.IcuMessage>} */
   const warnings = [];
 
-  const importantStorageWarning = await storage.getImportantStorageWarning(session, url);
-  if (importantStorageWarning) warnings.push(importantStorageWarning);
-
-  const clearDataWarnings = await storage.clearDataForOrigin(session, url);
+  const clearDataWarnings = await storage.clearDataForOrigin(session, url, clearStorageTypes);
   warnings.push(...clearDataWarnings);
 
   const clearCacheWarnings = await storage.clearBrowserCaches(session);
   warnings.push(...clearCacheWarnings);
 
+  const importantStorageWarning = await storage.getImportantStorageWarning(session, url);
+  if (importantStorageWarning) warnings.push(importantStorageWarning);
+
   return {warnings};
 }
 
@@ -114,21 +115,17 @@ async function resetStorageForUrl(session, url) {
  *
  * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
- * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
  */
-async function prepareThrottlingAndNetwork(session, settings, options) {
+async function prepareThrottlingAndNetwork(session, settings) {
   const status = {msg: 'Preparing network conditions', id: `lh:gather:prepareThrottlingAndNetwork`};
   log.time(status);
 
-  if (options.disableThrottling) await emulation.clearThrottling(session);
-  else await emulation.throttle(session, settings);
+  await emulation.throttle(session, settings);
 
   // Set request blocking before any network activity.
   // No "clearing" is done at the end of the recording since Network.setBlockedURLs([]) will unset all if
   // neccessary at the beginning of the next section.
-  const blockedUrls = (options.blockedUrlPatterns || []).concat(
-    settings.blockedUrlPatterns || []
-  );
+  const blockedUrls = settings.blockedUrlPatterns || [];
   await session.sendCommand('Network.setBlockedURLs', {urls: blockedUrls});
 
   const headers = settings.extraHeaders;
@@ -163,10 +160,7 @@ async function prepareTargetForTimespanMode(driver, settings) {
   log.time(status);
 
   await prepareDeviceEmulation(driver, settings);
-  await prepareThrottlingAndNetwork(driver.defaultSession, settings, {
-    disableThrottling: false,
-    blockedUrlPatterns: undefined,
-  });
+  await prepareThrottlingAndNetwork(driver.defaultSession, settings);
   await warmUpIntlSegmenter(driver);
 
   log.timeEnd(status);
@@ -192,11 +186,16 @@ async function warmUpIntlSegmenter(driver) {
  *
  * @param {LH.Gatherer.Driver} driver
  * @param {LH.Config.Settings} settings
+ * @param {LH.NavigationRequestor} requestor
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function prepareTargetForNavigationMode(driver, settings) {
+async function prepareTargetForNavigationMode(driver, settings, requestor) {
   const status = {msg: 'Preparing target for navigation mode', id: 'lh:prepare:navigationMode'};
   log.time(status);
 
+  /** @type {Array<LH.IcuMessage>} */
+  const warnings = [];
+
   await prepareDeviceEmulation(driver, settings);
 
   // Automatically handle any JavaScript dialogs to prevent a hung renderer.
@@ -212,41 +211,21 @@ async function prepareTargetForNavigationMode(driver, settings) {
 
   await warmUpIntlSegmenter(driver);
 
-  log.timeEnd(status);
-}
-
-/**
- * Prepares a target for a particular navigation by resetting storage and setting network.
- *
- * This method assumes `prepareTargetForNavigationMode` has already been invoked.
- *
- * @param {LH.Gatherer.ProtocolSession} session
- * @param {LH.Config.Settings} settings
- * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {requestor: LH.NavigationRequestor}} navigation
- * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
- */
-async function prepareTargetForIndividualNavigation(session, settings, navigation) {
-  const status = {msg: 'Preparing target for navigation', id: 'lh:prepare:navigation'};
-  log.time(status);
-
-  /** @type {Array<LH.IcuMessage>} */
-  const warnings = [];
-
-  const {requestor} = navigation;
   const shouldResetStorage =
     !settings.disableStorageReset &&
-    !navigation.disableStorageReset &&
     // Without prior knowledge of the destination, we cannot know which URL to clear storage for.
     typeof requestor === 'string';
   if (shouldResetStorage) {
-    const requestedUrl = requestor;
-    const {warnings: storageWarnings} = await resetStorageForUrl(session, requestedUrl);
+    const {warnings: storageWarnings} = await resetStorageForUrl(driver.defaultSession,
+      requestor,
+      settings.clearStorageTypes);
     warnings.push(...storageWarnings);
   }
 
-  await prepareThrottlingAndNetwork(session, settings, navigation);
+  await prepareThrottlingAndNetwork(driver.defaultSession, settings);
 
   log.timeEnd(status);
+
   return {warnings};
 }
 
@@ -254,6 +233,5 @@ export {
   prepareThrottlingAndNetwork,
   prepareTargetForTimespanMode,
   prepareTargetForNavigationMode,
-  prepareTargetForIndividualNavigation,
   enableAsyncStacks,
 };

package/core/gather/driver/storage.d.ts

@@ -1,9 +1,10 @@
 /**
  * @param {LH.Gatherer.ProtocolSession} session
  * @param {string} url
+ * @param {LH.Config.Settings['clearStorageTypes']} clearStorageTypes
  * @return {Promise<LH.IcuMessage[]>}
  */
-export function clearDataForOrigin(session: LH.Gatherer.ProtocolSession, url: string): Promise<LH.IcuMessage[]>;
+export function clearDataForOrigin(session: LH.Gatherer.ProtocolSession, url: string, clearStorageTypes: LH.Config.Settings['clearStorageTypes']): Promise<LH.IcuMessage[]>;
 /**
  * Clear the network cache on disk and in memory.
  * @param {LH.Gatherer.ProtocolSession} session

package/core/gather/driver/storage.js

@@ -36,9 +36,10 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 /**
  * @param {LH.Gatherer.ProtocolSession} session
  * @param {string} url
+ * @param {LH.Config.Settings['clearStorageTypes']} clearStorageTypes
  * @return {Promise<LH.IcuMessage[]>}
  */
-async function clearDataForOrigin(session, url) {
+async function clearDataForOrigin(session, url, clearStorageTypes) {
   const status = {msg: 'Cleaning origin data', id: 'lh:storage:clearDataForOrigin'};
   log.time(status);
 
@@ -46,17 +47,7 @@ async function clearDataForOrigin(session, url) {
 
   const origin = new URL(url).origin;
 
-  // Clear some types of storage.
-  // Cookies are not cleared, so the user isn't logged out.
-  // indexeddb, websql, and localstorage are not cleared to prevent loss of potentially important data.
-  //   https://chromedevtools.github.io/debugger-protocol-viewer/tot/Storage/#type-StorageType
-  const typesToClear = [
-    // 'cookies',
-    'file_systems',
-    'shader_cache',
-    'service_workers',
-    'cache_storage',
-  ].join(',');
+  const typesToClear = clearStorageTypes.join(',');
 
   // `Storage.clearDataForOrigin` is one of our PROTOCOL_TIMEOUT culprits and this command is also
   // run in the context of PAGE_HUNG to cleanup. We'll keep the timeout low and just warn if it fails.

package/core/gather/gatherers/inspector-issues.js

@@ -67,6 +67,7 @@ class InspectorIssues extends BaseGatherer {
       bounceTrackingIssue: [],
       clientHintIssue: [],
       contentSecurityPolicyIssue: [],
+      cookieDeprecationMetadataIssue: [],
       corsIssue: [],
       deprecationIssue: [],
       federatedAuthRequestIssue: [],

package/core/gather/navigation-runner.d.ts

@@ -2,7 +2,6 @@ export type NavigationContext = {
     driver: Driver;
     page: LH.Puppeteer.Page;
     resolvedConfig: LH.Config.ResolvedConfig;
-    navigation: LH.Config.NavigationDefn;
     requestor: LH.NavigationRequestor;
     baseArtifacts: LH.BaseArtifacts;
     computedCache: Map<string, LH.ArbitraryEqualityMap>;
@@ -31,40 +30,18 @@ export function _setup({ driver, resolvedConfig, requestor }: {
 }>;
 /**
  * @param {NavigationContext} navigationContext
- * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
- */
-export function _setupNavigation({ requestor, driver, navigation, resolvedConfig }: NavigationContext): Promise<{
-    warnings: Array<LH.IcuMessage>;
-}>;
-/**
- * @param {NavigationContext} navigationContext
- * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined}>}
  */
 export function _navigate(navigationContext: NavigationContext): Promise<{
     requestedUrl: string;
     mainDocumentUrl: string;
     navigationError: LH.LighthouseError | undefined;
-    warnings: Array<LH.IcuMessage>;
 }>;
 /**
  * @param {NavigationContext} navigationContext
  * @return {ReturnType<typeof _computeNavigationResult>}
  */
 export function _navigation(navigationContext: NavigationContext): ReturnType<typeof _computeNavigationResult>;
-/**
- * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.BaseArtifacts, computedCache: NavigationContext['computedCache']}} args
- * @return {Promise<{artifacts: Partial<LH.Artifacts & LH.BaseArtifacts>}>}
- */
-export function _navigations(args: {
-    driver: Driver;
-    page: LH.Puppeteer.Page;
-    resolvedConfig: LH.Config.ResolvedConfig;
-    requestor: LH.NavigationRequestor;
-    baseArtifacts: LH.BaseArtifacts;
-    computedCache: NavigationContext['computedCache'];
-}): Promise<{
-    artifacts: Partial<LH.Artifacts & LH.BaseArtifacts>;
-}>;
 /**
  * @param {{requestedUrl?: string, driver: Driver, resolvedConfig: LH.Config.ResolvedConfig, lhBrowser?: LH.Puppeteer.Browser, lhPage?: LH.Puppeteer.Page}} args
  */
@@ -81,14 +58,9 @@ import { LighthouseError } from '../lib/lh-error.js';
 /**
  * @param {NavigationContext} navigationContext
  * @param {PhaseState} phaseState
- * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
  * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
- * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ * @return {Promise<Partial<LH.GathererArtifacts>>}
  */
-declare function _computeNavigationResult(navigationContext: NavigationContext, phaseState: PhaseState, setupResult: Awaited<ReturnType<typeof _setupNavigation>>, navigateResult: Awaited<ReturnType<typeof _navigate>>): Promise<{
-    artifacts: Partial<LH.GathererArtifacts>;
-    warnings: Array<LH.IcuMessage>;
-    pageLoadError: LH.LighthouseError | undefined;
-}>;
+declare function _computeNavigationResult(navigationContext: NavigationContext, phaseState: PhaseState, navigateResult: Awaited<ReturnType<typeof _navigate>>): Promise<Partial<LH.GathererArtifacts>>;
 export {};
 //# sourceMappingURL=navigation-runner.d.ts.map

package/core/gather/navigation-runner.js

@@ -14,7 +14,6 @@ import * as prepare from './driver/prepare.js';
 import {gotoURL} from './driver/navigation.js';
 import * as storage from './driver/storage.js';
 import * as emulation from '../lib/emulation.js';
-import {defaultNavigationConfig} from '../config/constants.js';
 import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 import * as format from '../../shared/localization/format.js';
@@ -30,7 +29,6 @@ import {NetworkRecords} from '../computed/network-records.js';
  * @property {Driver} driver
  * @property {LH.Puppeteer.Page} page
  * @property {LH.Config.ResolvedConfig} resolvedConfig
- * @property {LH.Config.NavigationDefn} navigation
  * @property {LH.NavigationRequestor} requestor
  * @property {LH.BaseArtifacts} baseArtifacts
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
@@ -50,36 +48,23 @@ async function _setup({driver, resolvedConfig, requestor}) {
 
   // We can't trigger the navigation through user interaction if we reset the page before starting.
   if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
-    await gotoURL(driver, defaultNavigationConfig.blankPage, {waitUntil: ['navigated']});
-  }
+    // Disable network monitor on the blank page to prevent it from picking up network requests and
+    // frame navigated events before the run starts.
+    await driver._networkMonitor?.disable();
 
-  const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'navigation'});
+    await gotoURL(driver, resolvedConfig.settings.blankPage, {waitUntil: ['navigated']});
 
-  await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings);
+    await driver._networkMonitor?.enable();
+  }
 
-  return {baseArtifacts};
-}
+  const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'navigation'});
 
-/**
- * @param {NavigationContext} navigationContext
- * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
- */
-async function _setupNavigation({requestor, driver, navigation, resolvedConfig}) {
-  // We can't trigger the navigation through user interaction if we reset the page before starting.
-  if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
-    await gotoURL(driver, navigation.blankPage, {...navigation, waitUntil: ['navigated']});
-  }
+  const {warnings} =
+    await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings, requestor);
 
-  const {warnings} = await prepare.prepareTargetForIndividualNavigation(
-    driver.defaultSession,
-    resolvedConfig.settings,
-    {
-      ...navigation,
-      requestor,
-    }
-  );
+  baseArtifacts.LighthouseRunWarnings.push(...warnings);
 
-  return {warnings};
+  return {baseArtifacts};
 }
 
 /**
@@ -91,20 +76,20 @@ async function _cleanupNavigation({driver}) {
 
 /**
  * @param {NavigationContext} navigationContext
- * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined}>}
  */
 async function _navigate(navigationContext) {
   const {driver, resolvedConfig, requestor} = navigationContext;
 
   try {
     const {requestedUrl, mainDocumentUrl, warnings} = await gotoURL(driver, requestor, {
-      ...navigationContext.navigation,
-      debugNavigation: resolvedConfig.settings.debugNavigation,
-      maxWaitForFcp: resolvedConfig.settings.maxWaitForFcp,
-      maxWaitForLoad: resolvedConfig.settings.maxWaitForLoad,
-      waitUntil: navigationContext.navigation.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
+      ...resolvedConfig.settings,
+      waitUntil: resolvedConfig.settings.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
     });
-    return {requestedUrl, mainDocumentUrl, navigationError: undefined, warnings};
+
+    navigationContext.baseArtifacts.LighthouseRunWarnings.push(...warnings);
+
+    return {requestedUrl, mainDocumentUrl, navigationError: undefined};
   } catch (err) {
     if (!(err instanceof LighthouseError)) throw err;
     if (err.code !== 'NO_FCP' && err.code !== 'PAGE_HUNG') throw err;
@@ -115,7 +100,6 @@ async function _navigate(navigationContext) {
       requestedUrl: requestor,
       mainDocumentUrl: requestor,
       navigationError: err,
-      warnings: [],
     };
   }
 }
@@ -158,36 +142,33 @@ async function _collectDebugData(navigationContext, phaseState) {
 /**
  * @param {NavigationContext} navigationContext
  * @param {PhaseState} phaseState
- * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
  * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
- * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ * @return {Promise<Partial<LH.GathererArtifacts>>}
  */
 async function _computeNavigationResult(
   navigationContext,
   phaseState,
-  setupResult,
   navigateResult
 ) {
-  const {navigationError, mainDocumentUrl} = navigateResult;
-  const warnings = [...setupResult.warnings, ...navigateResult.warnings];
+  const {navigationError, requestedUrl, mainDocumentUrl} = navigateResult;
   const debugData = await _collectDebugData(navigationContext, phaseState);
   const pageLoadError = debugData.records
     ? getPageLoadError(navigationError, {
       url: mainDocumentUrl,
-      loadFailureMode: navigationContext.navigation.loadFailureMode,
+      ignoreStatusCode: navigationContext.resolvedConfig.settings.ignoreStatusCode,
       networkRecords: debugData.records,
-      warnings,
+      warnings: navigationContext.baseArtifacts.LighthouseRunWarnings,
     })
     : navigationError;
 
   if (pageLoadError) {
     const locale = navigationContext.resolvedConfig.settings.locale;
     const localizedMessage = format.getFormatted(pageLoadError.friendlyMessage, locale);
-    log.error('NavigationRunner', localizedMessage, navigateResult.requestedUrl);
+    log.error('NavigationRunner', localizedMessage, requestedUrl);
 
     /** @type {Partial<LH.GathererArtifacts>} */
     const artifacts = {};
-    const pageLoadErrorId = `pageLoadError-${navigationContext.navigation.id}`;
+    const pageLoadErrorId = 'pageLoadError-defaultPass';
     if (debugData.devtoolsLog) {
       artifacts.DevtoolsLogError = debugData.devtoolsLog;
       artifacts.devtoolsLogs = {[pageLoadErrorId]: debugData.devtoolsLog};
@@ -197,20 +178,14 @@ async function _computeNavigationResult(
       artifacts.traces = {[pageLoadErrorId]: debugData.trace};
     }
 
-    return {
-      pageLoadError,
-      artifacts,
-      warnings: [...warnings, pageLoadError.friendlyMessage],
-    };
+    navigationContext.baseArtifacts.LighthouseRunWarnings.push(pageLoadError.friendlyMessage);
+    navigationContext.baseArtifacts.PageLoadError = pageLoadError;
+
+    return artifacts;
   } else {
     await collectPhaseArtifacts({phase: 'getArtifact', ...phaseState});
 
-    const artifacts = await awaitArtifacts(phaseState.artifactState);
-    return {
-      artifacts,
-      warnings,
-      pageLoadError: undefined,
-    };
+    return await awaitArtifacts(phaseState.artifactState);
   }
 }
 
@@ -219,6 +194,10 @@ async function _computeNavigationResult(
  * @return {ReturnType<typeof _computeNavigationResult>}
  */
 async function _navigation(navigationContext) {
+  if (!navigationContext.resolvedConfig.artifacts) {
+    throw new Error('No artifacts were defined on the config');
+  }
+
   const artifactState = getEmptyArtifactState();
   const phaseState = {
     url: await navigationContext.driver.url(),
@@ -226,14 +205,12 @@ async function _navigation(navigationContext) {
     driver: navigationContext.driver,
     page: navigationContext.page,
     computedCache: navigationContext.computedCache,
-    artifactDefinitions: navigationContext.navigation.artifacts,
+    artifactDefinitions: navigationContext.resolvedConfig.artifacts,
     artifactState,
     baseArtifacts: navigationContext.baseArtifacts,
     settings: navigationContext.resolvedConfig.settings,
   };
 
-  const setupResult = await _setupNavigation(navigationContext);
-
   const disableAsyncStacks =
     await prepare.enableAsyncStacks(navigationContext.driver.defaultSession);
 
@@ -262,58 +239,7 @@ async function _navigation(navigationContext) {
 
   await _cleanupNavigation(navigationContext);
 
-  return _computeNavigationResult(navigationContext, phaseState, setupResult, navigateResult);
-}
-
-/**
- * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.BaseArtifacts, computedCache: NavigationContext['computedCache']}} args
- * @return {Promise<{artifacts: Partial<LH.Artifacts & LH.BaseArtifacts>}>}
- */
-async function _navigations(args) {
-  const {
-    driver,
-    page,
-    resolvedConfig,
-    requestor,
-    baseArtifacts,
-    computedCache,
-  } = args;
-
-  if (!resolvedConfig.artifacts || !resolvedConfig.navigations) {
-    throw new Error('No artifacts were defined on the config');
-  }
-
-  /** @type {Partial<LH.Artifacts & LH.BaseArtifacts>} */
-  const artifacts = {};
-  /** @type {Array<LH.IcuMessage>} */
-  const LighthouseRunWarnings = [];
-
-  for (const navigation of resolvedConfig.navigations) {
-    const navigationContext = {
-      driver,
-      page,
-      navigation,
-      requestor,
-      resolvedConfig,
-      baseArtifacts,
-      computedCache,
-    };
-
-    let shouldHaltNavigations = false;
-    const navigationResult = await _navigation(navigationContext);
-    if (navigation.loadFailureMode === 'fatal') {
-      if (navigationResult.pageLoadError) {
-        artifacts.PageLoadError = navigationResult.pageLoadError;
-        shouldHaltNavigations = true;
-      }
-    }
-
-    LighthouseRunWarnings.push(...navigationResult.warnings);
-    Object.assign(artifacts, navigationResult.artifacts);
-    if (shouldHaltNavigations) break;
-  }
-
-  return {artifacts: {...artifacts, LighthouseRunWarnings}};
+  return _computeNavigationResult(navigationContext, phaseState, navigateResult);
 }
 
 /**
@@ -321,7 +247,12 @@ async function _navigations(args) {
  */
 async function _cleanup({requestedUrl, driver, resolvedConfig, lhBrowser, lhPage}) {
   const didResetStorage = !resolvedConfig.settings.disableStorageReset && requestedUrl;
-  if (didResetStorage) await storage.clearDataForOrigin(driver.defaultSession, requestedUrl);
+  if (didResetStorage) {
+    await storage.clearDataForOrigin(driver.defaultSession,
+    requestedUrl,
+    resolvedConfig.settings.clearStorageTypes
+    );
+  }
 
   await driver.disconnect();
 
@@ -369,11 +300,15 @@ async function navigationGather(page, requestor, options = {}) {
         driver,
         lhBrowser,
         lhPage,
+        page,
         resolvedConfig,
         requestor: normalizedRequestor,
+        computedCache: new Map(),
       };
       const {baseArtifacts} = await _setup(context);
-      const {artifacts} = await _navigations({...context, page, baseArtifacts, computedCache});
+
+      const artifacts = await _navigation({...context, baseArtifacts});
+
       await _cleanup(context);
 
       return finalizeArtifacts(baseArtifacts, artifacts);
@@ -386,9 +321,7 @@ async function navigationGather(page, requestor, options = {}) {
 export {
   navigationGather,
   _setup,
-  _setupNavigation,
   _navigate,
   _navigation,
-  _navigations,
   _cleanup,
 };

package/core/lib/navigation-error.d.ts

@@ -1,9 +1,13 @@
 /**
  * Returns an error if the original network request failed or wasn't found.
  * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @param {{warnings: Array<string | LH.IcuMessage>, ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode']}} context
  * @return {LH.LighthouseError|undefined}
  */
-export function getNetworkError(mainRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
+export function getNetworkError(mainRecord: LH.Artifacts.NetworkRequest | undefined, context: {
+    warnings: Array<string | LH.IcuMessage>;
+    ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode'];
+}): LH.LighthouseError | undefined;
 /**
  * Returns an error if we ended up on the `chrome-error` page and all other requests failed.
  * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
@@ -15,12 +19,12 @@ export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | u
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
     url: string;
-    loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'];
+    ignoreStatusCode?: boolean | undefined;
     networkRecords: Array<LH.Artifacts.NetworkRequest>;
     warnings: Array<string | LH.IcuMessage>;
 }): LH.LighthouseError | undefined;
@@ -33,6 +37,7 @@ export function getPageLoadError(navigationError: LH.LighthouseError | undefined
 export function getNonHtmlError(finalRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
 export namespace UIStrings {
     const warningXhtml: string;
+    const warningStatusCode: string;
 }
 import { NetworkRequest } from './network-request.js';
 import { LighthouseError } from './lh-error.js';

package/core/lib/navigation-error.js

@@ -16,6 +16,13 @@ const UIStrings = {
    */
   warningXhtml:
     'The page MIME type is XHTML: Lighthouse does not explicitly support this document type',
+  /**
+   * @description Warning shown in report when the page under test returns an error code, which Lighthouse is not able to reliably load so we display a warning.
+   * @example {404} errorCode
+   */
+  warningStatusCode: 'Lighthouse was unable to reliably load the page you requested. Make sure' +
+    ' you are testing the correct URL and that the server is properly responding' +
+    ' to all requests. (Status code: {errorCode})',
 };
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
@@ -27,9 +34,10 @@ const XHTML_MIME_TYPE = 'application/xhtml+xml';
 /**
  * Returns an error if the original network request failed or wasn't found.
  * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @param {{warnings: Array<string | LH.IcuMessage>, ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode']}} context
  * @return {LH.LighthouseError|undefined}
  */
-function getNetworkError(mainRecord) {
+function getNetworkError(mainRecord, context) {
   if (!mainRecord) {
     return new LighthouseError(LighthouseError.errors.NO_DOCUMENT_REQUEST);
   } else if (mainRecord.failed) {
@@ -47,9 +55,13 @@ function getNetworkError(mainRecord) {
         LighthouseError.errors.FAILED_DOCUMENT_REQUEST, {errorDetails: netErr});
     }
   } else if (mainRecord.hasErrorStatusCode()) {
-    return new LighthouseError(LighthouseError.errors.ERRORED_DOCUMENT_REQUEST, {
-      statusCode: `${mainRecord.statusCode}`,
-    });
+    if (context.ignoreStatusCode) {
+      context.warnings.push(str_(UIStrings.warningStatusCode, {errorCode: mainRecord.statusCode}));
+    } else {
+      return new LighthouseError(LighthouseError.errors.ERRORED_DOCUMENT_REQUEST, {
+        statusCode: `${mainRecord.statusCode}`,
+      });
+    }
   }
 }
 
@@ -113,11 +125,11 @@ function getNonHtmlError(finalRecord) {
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, ignoreStatusCode?: LH.Config.Settings['ignoreStatusCode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 function getPageLoadError(navigationError, context) {
-  const {url, loadFailureMode, networkRecords} = context;
+  const {url, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
   let mainRecord = NetworkAnalyzer.findResourceForUrl(networkRecords, url);
 
@@ -144,14 +156,10 @@ function getPageLoadError(navigationError, context) {
     context.warnings.push(str_(UIStrings.warningXhtml));
   }
 
-  const networkError = getNetworkError(mainRecord);
+  const networkError = getNetworkError(mainRecord, context);
   const interstitialError = getInterstitialError(mainRecord, networkRecords);
   const nonHtmlError = getNonHtmlError(finalRecord);
 
-  // Check to see if we need to ignore the page load failure.
-  // e.g. When the driver is offline, the load will fail without page offline support.
-  if (loadFailureMode === 'ignore') return;
-
   // We want to special-case the interstitial beyond FAILED_DOCUMENT_REQUEST. See https://github.com/GoogleChrome/lighthouse/pull/8865#issuecomment-497507618
   if (interstitialError) return interstitialError;