lighthouse 11.2.0-dev.20231016 → 11.2.0-dev.20231018

package/core/config/validation.js

@@ -68,43 +68,6 @@ function assertValidArtifact(artifactDefn) {
   }
 }
 
-/**
- * Throws an error if the provided object does not implement the required navigations interface.
- * @param {LH.Config.ResolvedConfig['navigations']} navigationsDefn
- * @return {{warnings: string[]}}
- */
-function assertValidNavigations(navigationsDefn) {
-  if (!navigationsDefn || !navigationsDefn.length) return {warnings: []};
-
-  /** @type {string[]} */
-  const warnings = [];
-
-  // Assert that the first navigation has loadFailureMode fatal.
-  const firstNavigation = navigationsDefn[0];
-  if (firstNavigation.loadFailureMode !== 'fatal') {
-    const currentMode = firstNavigation.loadFailureMode;
-    const warning = [
-      `"${firstNavigation.id}" is the first navigation but had a failure mode of ${currentMode}.`,
-      `The first navigation will always be treated as loadFailureMode=fatal.`,
-    ].join(' ');
-
-    warnings.push(warning);
-    firstNavigation.loadFailureMode = 'fatal';
-  }
-
-  // Assert that navigations have unique IDs.
-  const navigationIds = navigationsDefn.map(navigation => navigation.id);
-  const duplicateId = navigationIds.find(
-    (id, i) => navigationIds.slice(i + 1).some(other => id === other)
-  );
-
-  if (duplicateId) {
-    throw new Error(`Navigation must have unique identifiers, but "${duplicateId}" was repeated.`);
-  }
-
-  return {warnings};
-}
-
 /**
  * Throws an error if the provided object does not implement the required properties of an audit
  * definition.
@@ -223,42 +186,36 @@ function assertValidSettings(settings) {
 }
 
 /**
- * Asserts that artifacts are in a valid dependency order that can be computed.
+ * Asserts that artifacts are unique, valid and are in a dependency order that can be computed.
  *
- * @param {Array<LH.Config.NavigationDefn>} navigations
+ * @param {Array<LH.Config.AnyArtifactDefn>} artifactDefns
  */
-function assertArtifactTopologicalOrder(navigations) {
+function assertValidArtifacts(artifactDefns) {
+  /** @type {Set<string>} */
   const availableArtifacts = new Set();
 
-  for (const navigation of navigations) {
-    for (const artifact of navigation.artifacts) {
-      availableArtifacts.add(artifact.id);
-      if (!artifact.dependencies) continue;
+  for (const artifact of artifactDefns) {
+    assertValidArtifact(artifact);
 
-      for (const [dependencyKey, {id: dependencyId}] of Object.entries(artifact.dependencies)) {
-        if (availableArtifacts.has(dependencyId)) continue;
-        throwInvalidDependencyOrder(artifact.id, dependencyKey);
-      }
+    if (availableArtifacts.has(artifact.id)) {
+      throw new Error(`Config defined multiple artifacts with id '${artifact.id}'`);
+    }
+
+    availableArtifacts.add(artifact.id);
+    if (!artifact.dependencies) continue;
+
+    for (const [dependencyKey, {id: dependencyId}] of Object.entries(artifact.dependencies)) {
+      if (availableArtifacts.has(dependencyId)) continue;
+      throwInvalidDependencyOrder(artifact.id, dependencyKey);
     }
   }
 }
 
 /**
  * @param {LH.Config.ResolvedConfig} resolvedConfig
- * @return {{warnings: string[]}}
  */
 function assertValidConfig(resolvedConfig) {
-  const {warnings} = assertValidNavigations(resolvedConfig.navigations);
-
-  /** @type {Set<string>} */
-  const artifactIds = new Set();
-  for (const artifactDefn of resolvedConfig.artifacts || []) {
-    if (artifactIds.has(artifactDefn.id)) {
-      throw new Error(`Config defined multiple artifacts with id '${artifactDefn.id}'`);
-    }
-    artifactIds.add(artifactDefn.id);
-    assertValidArtifact(artifactDefn);
-  }
+  assertValidArtifacts(resolvedConfig.artifacts || []);
 
   for (const auditDefn of resolvedConfig.audits || []) {
     assertValidAudit(auditDefn);
@@ -266,7 +223,6 @@ function assertValidConfig(resolvedConfig) {
 
   assertValidCategories(resolvedConfig.categories, resolvedConfig.audits, resolvedConfig.groups);
   assertValidSettings(resolvedConfig.settings);
-  return {warnings};
 }
 
 /**
@@ -303,11 +259,10 @@ export {
   isValidArtifactDependency,
   assertValidPluginName,
   assertValidArtifact,
-  assertValidNavigations,
   assertValidAudit,
   assertValidCategories,
   assertValidSettings,
-  assertArtifactTopologicalOrder,
+  assertValidArtifacts,
   assertValidConfig,
   throwInvalidDependencyOrder,
   throwInvalidArtifactDependency,

package/core/gather/base-artifacts.d.ts

@@ -9,8 +9,8 @@ export function getBaseArtifacts(resolvedConfig: LH.Config.ResolvedConfig, drive
 }): Promise<LH.BaseArtifacts>;
 /**
  * @param {LH.BaseArtifacts} baseArtifacts
- * @param {Partial<LH.Artifacts>} gathererArtifacts
+ * @param {Partial<LH.GathererArtifacts>} gathererArtifacts
  * @return {LH.Artifacts}
  */
-export function finalizeArtifacts(baseArtifacts: LH.BaseArtifacts, gathererArtifacts: Partial<LH.Artifacts>): LH.Artifacts;
+export function finalizeArtifacts(baseArtifacts: LH.BaseArtifacts, gathererArtifacts: Partial<LH.GathererArtifacts>): LH.Artifacts;
 //# sourceMappingURL=base-artifacts.d.ts.map

package/core/gather/base-artifacts.js

@@ -60,20 +60,20 @@ function deduplicateWarnings(warnings) {
 
 /**
  * @param {LH.BaseArtifacts} baseArtifacts
- * @param {Partial<LH.Artifacts>} gathererArtifacts
+ * @param {Partial<LH.GathererArtifacts>} gathererArtifacts
  * @return {LH.Artifacts}
  */
 function finalizeArtifacts(baseArtifacts, gathererArtifacts) {
-  const warnings = baseArtifacts.LighthouseRunWarnings
-    .concat(gathererArtifacts.LighthouseRunWarnings || [])
-    .concat(getEnvironmentWarnings({settings: baseArtifacts.settings, baseArtifacts}));
+  baseArtifacts.LighthouseRunWarnings.push(
+    ...getEnvironmentWarnings({settings: baseArtifacts.settings, baseArtifacts})
+  );
 
   // Cast to remove the partial from gathererArtifacts.
   const artifacts = /** @type {LH.Artifacts} */ ({...baseArtifacts, ...gathererArtifacts});
 
   // Set the post-run meta artifacts.
   artifacts.Timing = log.getTimeEntries();
-  artifacts.LighthouseRunWarnings = deduplicateWarnings(warnings);
+  artifacts.LighthouseRunWarnings = deduplicateWarnings(baseArtifacts.LighthouseRunWarnings);
 
   if (artifacts.PageLoadError && !artifacts.URL.finalDisplayedUrl) {
     artifacts.URL.finalDisplayedUrl = artifacts.URL.requestedUrl || '';

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

@@ -1,6 +1,6 @@
 export type NavigationOptions = {
     waitUntil: Array<'fcp' | 'load' | 'navigated'>;
-} & LH.Config.SharedPassNavigationJson & Partial<Pick<LH.Config.Settings, 'maxWaitForFcp' | 'maxWaitForLoad' | 'debugNavigation'>>;
+} & Partial<LH.Config.Settings>;
 /**
  * Navigates to the given URL, assuming that the page is not already on this URL.
  * Resolves on the url of the loaded page, taking into account any redirects.

package/core/gather/driver/navigation.js

@@ -39,7 +39,7 @@ const DEFAULT_NETWORK_QUIET_THRESHOLD = 5000;
 // Controls how long to wait between longtasks before determining the CPU is idle, off by default
 const DEFAULT_CPU_QUIET_THRESHOLD = 0;
 
-/** @typedef {{waitUntil: Array<'fcp'|'load'|'navigated'>} & LH.Config.SharedPassNavigationJson & Partial<Pick<LH.Config.Settings, 'maxWaitForFcp'|'maxWaitForLoad'|'debugNavigation'>>} NavigationOptions */
+/** @typedef {{waitUntil: Array<'fcp'|'load'|'navigated'>} & Partial<LH.Config.Settings>} NavigationOptions */
 
 /** @param {NavigationOptions} options */
 function resolveWaitForFullyLoadedOptions(options) {

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

@@ -5,12 +5,8 @@
  *
  * @param {LH.Gatherer.ProtocolSession} session
  * @param {LH.Config.Settings} settings
- * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
  */
-export function prepareThrottlingAndNetwork(session: LH.Gatherer.ProtocolSession, settings: LH.Config.Settings, options: {
-    disableThrottling: boolean;
-    blockedUrlPatterns?: string[];
-}): Promise<void>;
+export function prepareThrottlingAndNetwork(session: LH.Gatherer.ProtocolSession, settings: LH.Config.Settings): Promise<void>;
 /**
  * Prepares a target to be analyzed in timespan mode by enabling protocol domains, emulation, and throttling.
  *
@@ -26,21 +22,10 @@ export function prepareTargetForTimespanMode(driver: LH.Gatherer.Driver, setting
  *
  * @param {LH.Gatherer.Driver} driver
  * @param {LH.Config.Settings} settings
- */
-export function prepareTargetForNavigationMode(driver: LH.Gatherer.Driver, settings: LH.Config.Settings): Promise<void>;
-/**
- * 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
+ * @param {LH.NavigationRequestor} requestor
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-export function prepareTargetForIndividualNavigation(session: LH.Gatherer.ProtocolSession, settings: LH.Config.Settings, navigation: Pick<import("../../../types/config.js").default.NavigationDefn, "blockedUrlPatterns" | "disableStorageReset" | "disableThrottling"> & {
-    requestor: LH.NavigationRequestor;
-}): Promise<{
+export function prepareTargetForNavigationMode(driver: LH.Gatherer.Driver, settings: LH.Config.Settings, requestor: LH.NavigationRequestor): Promise<{
     warnings: Array<LH.IcuMessage>;
 }>;
 /**

package/core/gather/driver/prepare.js

@@ -114,21 +114,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 +159,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 +185,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 +210,20 @@ 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);
     warnings.push(...storageWarnings);
   }
 
-  await prepareThrottlingAndNetwork(session, settings, navigation);
+  await prepareThrottlingAndNetwork(driver.defaultSession, settings);
 
   log.timeEnd(status);
+
   return {warnings};
 }
 
@@ -254,6 +231,5 @@ export {
   prepareThrottlingAndNetwork,
   prepareTargetForTimespanMode,
   prepareTargetForNavigationMode,
-  prepareTargetForIndividualNavigation,
   enableAsyncStacks,
 };

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();
+
+    await gotoURL(driver, resolvedConfig.settings.blankPage, {waitUntil: ['navigated']});
+
+    await driver._networkMonitor?.enable();
   }
 
   const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'navigation'});
 
-  await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings);
-
-  return {baseArtifacts};
-}
+  const {warnings} =
+    await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings, requestor);
 
-/**
- * @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']});
-  }
+  baseArtifacts.LighthouseRunWarnings.push(...warnings);
 
-  const {warnings} = await prepare.prepareTargetForIndividualNavigation(
-    driver.defaultSession,
-    resolvedConfig.settings,
-    {
-      ...navigation,
-      requestor,
-    }
-  );
-
-  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,32 @@ 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,
       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 +177,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 +193,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 +204,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 +238,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);
 }
 
 /**
@@ -369,11 +294,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 +315,7 @@ async function navigationGather(page, requestor, options = {}) {
 export {
   navigationGather,
   _setup,
-  _setupNavigation,
   _navigate,
   _navigation,
-  _navigations,
   _cleanup,
 };