lighthouse 9.3.1 → 9.4.0

package/flow-report/src/topbar.tsx

@@ -16,7 +16,7 @@ import {saveFile} from '../../report/renderer/api';
 
 function saveHtml(flowResult: LH.FlowResult, htmlStr: string) {
   const blob = new Blob([htmlStr], {type: 'text/html'});
-  const filename = getFlowResultFilenamePrefix(flowResult);
+  const filename = getFlowResultFilenamePrefix(flowResult) + '.html';
   saveFile(blob, filename);
 }
 

package/flow-report/src/wrappers/report.tsx

@@ -33,7 +33,8 @@ export const Report: FunctionComponent<{hashState: LH.FlowResult.HashState}> =
 ({hashState}) => {
   const ref = useExternalRenderer<HTMLDivElement>(() => {
     return renderReport(hashState.currentLhr, {
-      disableAutoDarkModeAndFireworks: true,
+      disableFireworks: true,
+      disableDarkMode: true,
       omitTopbar: true,
       omitGlobalStyles: true,
       onPageAnchorRendered: link => convertAnchor(link, hashState.index),

package/flow-report/test/topbar-test.tsx

@@ -56,7 +56,7 @@ it('save button opens save dialog for HTML file', async () => {
 
   expect(mockSaveFile).toHaveBeenCalledWith(
     expect.any(Blob),
-    'User-flow_2021-09-14_22-24-22'
+    'User-flow_2021-09-14_22-24-22.html'
   );
 });
 

package/lighthouse-cli/bin.js

@@ -137,12 +137,9 @@ async function begin() {
       url: urlUnderTest,
       flags: cliFlags,
       environmentData: {
-        name: 'redacted', // prevent sentry from using hostname
+        serverName: 'redacted', // prevent sentry from using hostname
         environment: isDev() ? 'development' : 'production',
         release: pkg.version,
-        tags: {
-          channel: 'cli',
-        },
       },
     });
   }

package/lighthouse-cli/run.js

@@ -208,7 +208,7 @@ async function runLighthouseWithFraggleRock(url, flags, config, launchedChrome)
   const page = await browser.newPage();
   flags.channel = 'fraggle-rock-cli';
   const configContext = {configPath: flags.configPath, settingsOverrides: flags};
-  return fraggleRock.navigation({url, page, config, configContext});
+  return fraggleRock.navigation(url, {page, config, configContext});
 }
 
 /**

package/lighthouse-cli/test/smokehouse/core-tests.js

@@ -10,12 +10,11 @@ import byteEfficiency from './test-definitions/byte-efficiency.js';
 import byteGzip from './test-definitions/byte-gzip.js';
 import cspAllowAll from './test-definitions/csp-allow-all.js';
 import cspBlockAll from './test-definitions/csp-block-all.js';
-import cspBlockAllM91 from './test-definitions/csp-block-all-m91.js';
 import dbw from './test-definitions/dobetterweb.js';
 import errorsExpiredSsl from './test-definitions/errors-expired-ssl.js';
 import errorsIframeExpiredSsl from './test-definitions/errors-iframe-expired-ssl.js';
 import errorsInfiniteLoop from './test-definitions/errors-infinite-loop.js';
-// import formsAutoComplete from './test-definitions/forms-autocomplete.js';
+import formsAutoComplete from './test-definitions/forms-autocomplete.js';
 import issuesMixedContent from './test-definitions/issues-mixed-content.js';
 import lanternFetch from './test-definitions/lantern-fetch.js';
 import lanternIdleCallbackLong from './test-definitions/lantern-idle-callback-long.js';
@@ -60,6 +59,7 @@ import seoPassing from './test-definitions/seo-passing.js';
 import seoStatus403 from './test-definitions/seo-status-403.js';
 import seoTapTargets from './test-definitions/seo-tap-targets.js';
 import sourceMaps from './test-definitions/source-maps.js';
+import timing from './test-definitions/timing.js';
 
 /** @type {ReadonlyArray<Smokehouse.TestDfn>} */
 const smokeTests = [
@@ -68,13 +68,11 @@ const smokeTests = [
   byteGzip,
   cspAllowAll,
   cspBlockAll,
-  cspBlockAllM91,
   dbw,
   errorsExpiredSsl,
   errorsIframeExpiredSsl,
   errorsInfiniteLoop,
-  // TODO: restore when --enable-features=AutofillShowTypePredictions is not needed.
-  // formsAutoComplete,
+  formsAutoComplete,
   issuesMixedContent,
   lanternOnline,
   lanternSetTimeout,
@@ -119,6 +117,7 @@ const smokeTests = [
   seoStatus403,
   seoTapTargets,
   sourceMaps,
+  timing,
 ];
 
 export default smokeTests;

package/lighthouse-cli/test/smokehouse/readme.md

@@ -64,11 +64,15 @@ Individual elements of an array can be asserted by using numeric properties in a
 
 However, if an array literal is used as the expectation, an extra condition is enforced that the actual array _must_ have the same length as the provided expected array.
 
+Arrays can be checked against a subset of elements using the special `_includes` property. The value of `_includes` _must_ be an array. Each assertion in `_includes` will remove the matching item from consideration for the rest.
+
 **Examples**:
 | Actual | Expected | Result |
 | -- | -- | -- |
 | `[{url: 'http://badssl.com'}, {url: 'http://example.com'}]` | `{1: {url: 'http://example.com'}}` | ✅ PASS |
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `{length: 2}` | ✅ PASS |
+| `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}]}` | ✅ PASS |
+| `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}, {timeInMs: 5}]}` | ❌ FAIL |
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `[{timeInMs: 5}]` | ❌ FAIL |
 
 ### Special environment checks

package/lighthouse-cli/test/smokehouse/report-assert.js

@@ -111,6 +111,35 @@ function findDifference(path, actual, expected) {
     const keyPath = path + keyAccessor;
     const expectedValue = expected[key];
 
+    if (key === '_includes') {
+      if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
+      if (!Array.isArray(actual)) {
+        return {
+          path,
+          actual: 'Actual value is not an array',
+          expected,
+        };
+      }
+
+      const actualCopy = [...actual];
+      for (const expectedEntry of expectedValue) {
+        const matchingIndex =
+          actualCopy.findIndex(actualEntry => !findDifference(keyPath, actualEntry, expectedEntry));
+        if (matchingIndex !== -1) {
+          actualCopy.splice(matchingIndex, 1);
+          continue;
+        }
+
+        return {
+          path,
+          actual: 'Item not found in array',
+          expected: expectedEntry,
+        };
+      }
+
+      continue;
+    }
+
     const actualValue = actual[key];
     const subDifference = findDifference(keyPath, actualValue, expectedValue);
 
@@ -305,6 +334,12 @@ function collateResults(localConsole, actual, expected) {
     return makeComparison(auditName + ' audit', actualResult, expectedResult);
   });
 
+  const timingAssertions = [];
+  if (expected.lhr.timing) {
+    const comparison = makeComparison('timing', actual.lhr.timing, expected.lhr.timing);
+    timingAssertions.push(comparison);
+  }
+
   /** @type {Comparison[]} */
   const requestCountAssertion = [];
   if (expected.networkRequests) {
@@ -322,6 +357,7 @@ function collateResults(localConsole, actual, expected) {
     ...requestCountAssertion,
     ...artifactAssertions,
     ...auditAssertions,
+    ...timingAssertions,
   ];
 }
 

package/lighthouse-core/audits/autocomplete.js

@@ -195,12 +195,12 @@ class AutocompleteAudit extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      requiredArtifacts: ['FormElements'],
+      requiredArtifacts: ['Inputs'],
     };
   }
 
   /**
-   * @param {LH.Artifacts.FormInput} input
+   * @param {LH.Artifacts.InputElement} input
    * @return {{hasValidTokens: boolean, isValidOrder?: boolean}}
    */
   static checkAttributeValidity(input) {
@@ -224,47 +224,44 @@ class AutocompleteAudit extends Audit {
    * @return {LH.Audit.Product}
    */
   static audit(artifacts) {
-    const forms = artifacts.FormElements;
     const failingFormsData = [];
     const warnings = [];
     let foundPrediction = false;
-    for (const form of forms) {
-      for (const input of form.inputs) {
-        const validity = this.checkAttributeValidity(input);
-        if (validity.hasValidTokens && validity.isValidOrder) continue;
-        if (!input.autocomplete.prediction) continue;
-        if (noPrediction.includes(input.autocomplete.prediction) &&
-          !input.autocomplete.attribute) continue;
+    for (const input of artifacts.Inputs.inputs) {
+      const validity = this.checkAttributeValidity(input);
+      if (validity.hasValidTokens && validity.isValidOrder) continue;
+      if (!input.autocomplete.prediction) continue;
+      if (noPrediction.includes(input.autocomplete.prediction) &&
+        !input.autocomplete.attribute) continue;
 
-        foundPrediction = true;
+      foundPrediction = true;
 
-        // @ts-ignore
-        let suggestion = predictionTypesToTokens[input.autocomplete.prediction];
-        // This is here to satisfy typescript because the possible null value of autocomplete.attribute is not compatible with Audit details.
-        if (!input.autocomplete.attribute) input.autocomplete.attribute = '';
-        // Warning is created because while there is an autocomplete attribute, the autocomplete property does not exsist, thus the attribute's value is invalid.
-        if (input.autocomplete.attribute) {
-          warnings.push(str_(UIStrings.warningInvalid, {token: input.autocomplete.attribute,
-            snippet: input.node.snippet}));
-        }
-        if (validity.isValidOrder === false) {
-          warnings.push(str_(UIStrings.warningOrder, {tokens: input.autocomplete.attribute,
-            snippet: input.node.snippet}));
-          suggestion = UIStrings.reviewOrder;
-        }
-        // If the autofill prediction is not in our autofill suggestion mapping, then we warn
-        if (!(input.autocomplete.prediction in predictionTypesToTokens) &&
-            validity.isValidOrder) {
-          log.warn(`Autocomplete prediction (${input.autocomplete.prediction})
-             not found in our mapping`);
-          continue;
-        }
-        failingFormsData.push({
-          node: Audit.makeNodeItem(input.node),
-          suggestion: suggestion,
-          current: input.autocomplete.attribute,
-        });
+      // @ts-ignore
+      let suggestion = predictionTypesToTokens[input.autocomplete.prediction];
+      // This is here to satisfy typescript because the possible null value of autocomplete.attribute is not compatible with Audit details.
+      if (!input.autocomplete.attribute) input.autocomplete.attribute = '';
+      // Warning is created because while there is an autocomplete attribute, the autocomplete property does not exsist, thus the attribute's value is invalid.
+      if (input.autocomplete.attribute) {
+        warnings.push(str_(UIStrings.warningInvalid, {token: input.autocomplete.attribute,
+          snippet: input.node.snippet}));
       }
+      if (validity.isValidOrder === false) {
+        warnings.push(str_(UIStrings.warningOrder, {tokens: input.autocomplete.attribute,
+          snippet: input.node.snippet}));
+        suggestion = UIStrings.reviewOrder;
+      }
+      // If the autofill prediction is not in our autofill suggestion mapping, then we warn
+      if (!(input.autocomplete.prediction in predictionTypesToTokens) &&
+          validity.isValidOrder) {
+        log.warn(`Autocomplete prediction (${input.autocomplete.prediction})
+            not found in our mapping`);
+        continue;
+      }
+      failingFormsData.push({
+        node: Audit.makeNodeItem(input.node),
+        suggestion: suggestion,
+        current: input.autocomplete.attribute,
+      });
     }
 
     /** @type {LH.Audit.Details.Table['headings']} */

package/lighthouse-core/audits/byte-efficiency/uses-long-cache-ttl.js

@@ -181,6 +181,7 @@ class CacheHeaders extends Audit {
         cacheControl['must-revalidate'] ||
         cacheControl['no-cache'] ||
         cacheControl['no-store'] ||
+        cacheControl['stale-while-revalidate'] ||
         cacheControl['private'])) {
       return true;
     }

package/lighthouse-core/audits/seo/hreflang.js

@@ -11,9 +11,8 @@
 
 const Audit = require('../audit.js');
 const i18n = require('../../lib/i18n/i18n.js');
-const axeLibSource = require('../../lib/axe.js').source;
+const {isValidLang} = require('../../../third-party/axe/valid-langs.js');
 
-const VALID_LANGS = importValidLangs();
 const NO_LANGUAGE = 'x-default';
 
 const UIStrings = {
@@ -33,20 +32,6 @@ const UIStrings = {
 
 const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
 
-/**
- * Import list of valid languages from axe core.
- * This is a huge array of language codes that can be stored more efficiently if we will need to
- * shrink the bundle size.
- * @return {Array<string>}
- */
-function importValidLangs() {
-  // Define a window-ish object so axe will export to it.
-  const window = {getComputedStyle: () => {}};
-  eval(axeLibSource);
-  // @ts-expect-error
-  return window.axe.utils.validLangs();
-}
-
 /**
  * @param {string} href
  * @return {boolean}
@@ -66,7 +51,7 @@ function isExpectedLanguageCode(hreflang) {
 
   // hreflang can consist of language-script-region, we are validating only language
   const [lang] = hreflang.split('-');
-  return VALID_LANGS.includes(lang.toLowerCase());
+  return isValidLang(lang.toLowerCase());
 }
 
 class Hreflang extends Audit {

package/lighthouse-core/config/default-config.js

@@ -39,7 +39,7 @@ const UIStrings = {
   /** Title of the Accessibility category of audits. This section contains audits focused on making web content accessible to all users. Also used as a label of a score gauge; try to limit to 20 characters. */
   a11yCategoryTitle: 'Accessibility',
   /** Description of the Accessibility category. This is displayed at the top of a list of audits focused on making web content accessible to all users. No character length limits. 'improve the accessibility of your web app' becomes link text to additional documentation. */
-  a11yCategoryDescription: 'These checks highlight opportunities to [improve the accessibility of your web app](https://developers.google.com/web/fundamentals/accessibility). Only a subset of accessibility issues can be automatically detected so manual testing is also encouraged.',
+  a11yCategoryDescription: 'These checks highlight opportunities to [improve the accessibility of your web app](https://web.dev/lighthouse-accessibility/). Only a subset of accessibility issues can be automatically detected so manual testing is also encouraged.',
   /** Description of the Accessibility manual checks category. This description is displayed above a list of accessibility audits that currently have no automated test and so must be verified manually by the user. No character length limits. 'conducting an accessibility review' becomes link text to additional documentation. */
   a11yCategoryManualDescription: 'These items address areas which an automated testing tool cannot cover. Learn more in our guide on [conducting an accessibility review](https://developers.google.com/web/fundamentals/accessibility/how-to-review).',
   /** Title of the best practices section of the Accessibility category. Within this section are audits with descriptive titles that highlight common accessibility best practices. */
@@ -144,7 +144,7 @@ const defaultConfig = {
       'meta-elements',
       'script-elements',
       'iframe-elements',
-      'form-elements',
+      'inputs',
       'main-document-content',
       'global-listeners',
       'dobetterweb/doctype',

package/lighthouse-core/fraggle-rock/config/default-config.js

@@ -46,7 +46,7 @@ const artifacts = {
   DOMStats: '',
   EmbeddedContent: '',
   FontSize: '',
-  FormElements: '',
+  Inputs: '',
   FullPageScreenshot: '',
   GlobalListeners: '',
   IFrameElements: '',
@@ -96,7 +96,7 @@ const defaultConfig = {
     {id: artifacts.DOMStats, gatherer: 'dobetterweb/domstats'},
     {id: artifacts.EmbeddedContent, gatherer: 'seo/embedded-content'},
     {id: artifacts.FontSize, gatherer: 'seo/font-size'},
-    {id: artifacts.FormElements, gatherer: 'form-elements'},
+    {id: artifacts.Inputs, gatherer: 'inputs'},
     {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
     {id: artifacts.GlobalListeners, gatherer: 'global-listeners'},
     {id: artifacts.IFrameElements, gatherer: 'iframe-elements'},
@@ -148,7 +148,7 @@ const defaultConfig = {
         artifacts.DOMStats,
         artifacts.EmbeddedContent,
         artifacts.FontSize,
-        artifacts.FormElements,
+        artifacts.Inputs,
         artifacts.GlobalListeners,
         artifacts.IFrameElements,
         artifacts.ImageElements,

package/lighthouse-core/fraggle-rock/gather/navigation-runner.js

@@ -35,7 +35,7 @@ const NetworkRecords = require('../../computed/network-records.js');
  * @property {Driver} driver
  * @property {LH.Config.FRConfig} config
  * @property {LH.Config.NavigationDefn} navigation
- * @property {string} requestedUrl
+ * @property {LH.NavigationRequestor} requestor
  * @property {LH.FRBaseArtifacts} baseArtifacts
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
  * @property {InternalOptions} [options]
@@ -44,17 +44,17 @@ const NetworkRecords = require('../../computed/network-records.js');
 /** @typedef {Omit<Parameters<typeof collectPhaseArtifacts>[0], 'phase'>} PhaseState */
 
 /**
- * @param {{driver: Driver, config: LH.Config.FRConfig, requestedUrl: string, options?: InternalOptions}} args
+ * @param {{driver: Driver, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor, options?: InternalOptions}} args
  * @return {Promise<{baseArtifacts: LH.FRBaseArtifacts}>}
  */
-async function _setup({driver, config, requestedUrl, options}) {
+async function _setup({driver, config, requestor, options}) {
   await driver.connect();
   if (!options?.skipAboutBlank) {
     await gotoURL(driver, defaultNavigationConfig.blankPage, {waitUntil: ['navigated']});
   }
 
   const baseArtifacts = await getBaseArtifacts(config, driver, {gatherMode: 'navigation'});
-  baseArtifacts.URL.requestedUrl = requestedUrl;
+  if (typeof requestor === 'string') baseArtifacts.URL.requestedUrl = requestor;
 
   await prepare.prepareTargetForNavigationMode(driver, config.settings);
 
@@ -65,7 +65,7 @@ async function _setup({driver, config, requestedUrl, options}) {
  * @param {NavigationContext} navigationContext
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function _setupNavigation({requestedUrl, driver, navigation, config, options}) {
+async function _setupNavigation({requestor, driver, navigation, config, options}) {
   if (!options?.skipAboutBlank) {
     await gotoURL(driver, navigation.blankPage, {...navigation, waitUntil: ['navigated']});
   }
@@ -74,7 +74,7 @@ async function _setupNavigation({requestedUrl, driver, navigation, config, optio
     config.settings,
     {
       ...navigation,
-      url: requestedUrl,
+      requestor,
     }
   );
 
@@ -90,25 +90,25 @@ async function _cleanupNavigation({driver}) {
 
 /**
  * @param {NavigationContext} navigationContext
- * @return {Promise<{finalUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ * @return {Promise<{requestedUrl: string, finalUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
  */
 async function _navigate(navigationContext) {
-  const {driver, config, requestedUrl} = navigationContext;
+  const {driver, config, requestor} = navigationContext;
 
   try {
-    const {finalUrl, warnings} = await gotoURL(driver, requestedUrl, {
+    const {requestedUrl, finalUrl, warnings} = await gotoURL(driver, requestor, {
       ...navigationContext.navigation,
       debugNavigation: config.settings.debugNavigation,
       maxWaitForFcp: config.settings.maxWaitForFcp,
       maxWaitForLoad: config.settings.maxWaitForLoad,
       waitUntil: navigationContext.navigation.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
     });
-
-    return {finalUrl, navigationError: undefined, warnings};
+    return {requestedUrl, finalUrl, navigationError: undefined, warnings};
   } catch (err) {
     if (!(err instanceof LighthouseError)) throw err;
     if (err.code !== 'NO_FCP' && err.code !== 'PAGE_HUNG') throw err;
-    return {finalUrl: requestedUrl, navigationError: err, warnings: []};
+    if (typeof requestor !== 'string') throw err;
+    return {requestedUrl: requestor, finalUrl: requestor, navigationError: err, warnings: []};
   }
 }
 
@@ -152,7 +152,7 @@ async function _collectDebugData(navigationContext, phaseState) {
  * @param {PhaseState} phaseState
  * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
  * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
- * @return {Promise<{finalUrl: string, artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ * @return {Promise<{requestedUrl: string, finalUrl: string, artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
  */
 async function _computeNavigationResult(
   navigationContext,
@@ -174,7 +174,7 @@ async function _computeNavigationResult(
   if (pageLoadError) {
     const locale = navigationContext.config.settings.locale;
     const localizedMessage = format.getFormatted(pageLoadError.friendlyMessage, locale);
-    log.error('NavigationRunner', localizedMessage, navigationContext.requestedUrl);
+    log.error('NavigationRunner', localizedMessage, navigateResult.requestedUrl);
 
     /** @type {Partial<LH.GathererArtifacts>} */
     const artifacts = {};
@@ -183,6 +183,7 @@ async function _computeNavigationResult(
     if (debugData.trace) artifacts.traces = {[pageLoadErrorId]: debugData.trace};
 
     return {
+      requestedUrl: navigateResult.requestedUrl,
       finalUrl,
       pageLoadError,
       artifacts,
@@ -192,7 +193,13 @@ async function _computeNavigationResult(
     await collectPhaseArtifacts({phase: 'getArtifact', ...phaseState});
 
     const artifacts = await awaitArtifacts(phaseState.artifactState);
-    return {finalUrl, artifacts, warnings, pageLoadError: undefined};
+    return {
+      requestedUrl: navigateResult.requestedUrl,
+      finalUrl,
+      artifacts,
+      warnings,
+      pageLoadError: undefined,
+    };
   }
 }
 
@@ -224,10 +231,10 @@ async function _navigation(navigationContext) {
 }
 
 /**
- * @param {{driver: Driver, config: LH.Config.FRConfig, requestedUrl: string; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache'], options?: InternalOptions}} args
+ * @param {{driver: Driver, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache'], options?: InternalOptions}} args
  * @return {Promise<{artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>}>}
  */
-async function _navigations({driver, config, requestedUrl, baseArtifacts, computedCache, options}) {
+async function _navigations({driver, config, requestor, baseArtifacts, computedCache, options}) {
   if (!config.navigations) throw new Error('No navigations configured');
 
   /** @type {Partial<LH.FRArtifacts & LH.FRBaseArtifacts>} */
@@ -239,7 +246,7 @@ async function _navigations({driver, config, requestedUrl, baseArtifacts, comput
     const navigationContext = {
       driver,
       navigation,
-      requestedUrl,
+      requestor,
       config,
       baseArtifacts,
       computedCache,
@@ -254,7 +261,10 @@ async function _navigations({driver, config, requestedUrl, baseArtifacts, comput
         shouldHaltNavigations = true;
       }
 
-      artifacts.URL = {requestedUrl, finalUrl: navigationResult.finalUrl};
+      artifacts.URL = {
+        requestedUrl: navigationResult.requestedUrl,
+        finalUrl: navigationResult.finalUrl,
+      };
     }
 
     LighthouseRunWarnings.push(...navigationResult.warnings);
@@ -266,43 +276,52 @@ async function _navigations({driver, config, requestedUrl, baseArtifacts, comput
 }
 
 /**
- * @param {{requestedUrl: string, driver: Driver, config: LH.Config.FRConfig}} args
+ * @param {{requestedUrl?: string, driver: Driver, config: LH.Config.FRConfig}} args
  */
 async function _cleanup({requestedUrl, driver, config}) {
-  const didResetStorage = !config.settings.disableStorageReset;
+  const didResetStorage = !config.settings.disableStorageReset && requestedUrl;
   if (didResetStorage) await storage.clearDataForOrigin(driver.defaultSession, requestedUrl);
 
   await driver.disconnect();
 }
 
 /**
- * @param {{url: string, page: import('puppeteer').Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
+ * @param {LH.NavigationRequestor} requestor
+ * @param {{page: import('puppeteer').Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
  * @return {Promise<LH.RunnerResult|undefined>}
  */
-async function navigation(options) {
-  const {url, page, configContext = {}} = options;
+async function navigation(requestor, options) {
+  const {page, configContext = {}} = options;
   const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
   const computedCache = new Map();
   const internalOptions = {
     skipAboutBlank: configContext.skipAboutBlank,
   };
 
-  return Runner.run(
+  // We can't trigger the navigation through user interaction if we reset the page before starting.
+  if (typeof requestor !== 'string') {
+    internalOptions.skipAboutBlank = true;
+  }
+
+  const runnerOptions = {config, computedCache};
+  const artifacts = await Runner.gather(
     async () => {
       const driver = new Driver(page);
-      const requestedUrl = URL.normalizeUrl(url);
-      const context = {driver, config, requestedUrl, options: internalOptions};
+      const context = {
+        driver,
+        config,
+        requestor: typeof requestor === 'string' ? URL.normalizeUrl(requestor) : requestor,
+        options: internalOptions,
+      };
       const {baseArtifacts} = await _setup(context);
       const {artifacts} = await _navigations({...context, baseArtifacts, computedCache});
       await _cleanup(context);
 
       return finalizeArtifacts(baseArtifacts, artifacts);
     },
-    {
-      config,
-      computedCache: new Map(),
-    }
+    runnerOptions
   );
+  return Runner.audit(artifacts, runnerOptions);
 }
 
 module.exports = {

package/lighthouse-core/fraggle-rock/gather/snapshot-runner.js

@@ -26,7 +26,8 @@ async function snapshot(options) {
   const computedCache = new Map();
   const url = await options.page.url();
 
-  return Runner.run(
+  const runnerOptions = {config, computedCache};
+  const artifacts = await Runner.gather(
     async () => {
       const baseArtifacts = await getBaseArtifacts(config, driver, {gatherMode: 'snapshot'});
       baseArtifacts.URL.requestedUrl = url;
@@ -50,11 +51,9 @@ async function snapshot(options) {
       const artifacts = await awaitArtifacts(artifactState);
       return finalizeArtifacts(baseArtifacts, artifacts);
     },
-    {
-      config,
-      computedCache,
-    }
+    runnerOptions
   );
+  return Runner.audit(artifacts, runnerOptions);
 }
 
 module.exports = {

package/lighthouse-core/fraggle-rock/gather/timespan-runner.js

@@ -50,7 +50,8 @@ async function startTimespan(options) {
   return {
     async endTimespan() {
       const finalUrl = await options.page.url();
-      return Runner.run(
+      const runnerOptions = {config, computedCache};
+      const artifacts = await Runner.gather(
         async () => {
           baseArtifacts.URL.requestedUrl = requestedUrl;
           baseArtifacts.URL.finalUrl = finalUrl;
@@ -63,11 +64,9 @@ async function startTimespan(options) {
           const artifacts = await awaitArtifacts(artifactState);
           return finalizeArtifacts(baseArtifacts, artifacts);
         },
-        {
-          config,
-          computedCache,
-        }
+        runnerOptions
       );
+      return Runner.audit(artifacts, runnerOptions);
     },
   };
 }