lighthouse 9.5.0-dev.20220815 → 9.5.0-dev.20220816

package/cli/commands/list-locales.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.
  */
 
-import locales from '../../shared/localization/locales.js';
+import {locales} from '../../shared/localization/locales.js';
 
 function listLocales() {
   const localesList = Object.keys(locales);

package/core/config/config-helpers.js

@@ -606,20 +606,6 @@ function deepCloneConfigJson(json) {
   return cloned;
 }
 
-/**
- * @param {LH.Flags} flags
- * @return {LH.Config.FRContext}
- */
-function flagsToFRContext(flags) {
-  return {
-    configPath: flags?.configPath,
-    settingsOverrides: flags,
-    logLevel: flags?.logLevel,
-    hostname: flags?.hostname,
-    port: flags?.port,
-  };
-}
-
 export {
   deepClone,
   deepCloneConfigJson,
@@ -631,5 +617,4 @@ export {
   resolveGathererToDefn,
   resolveModulePath,
   resolveSettings,
-  flagsToFRContext,
 };

package/core/config/config.js

@@ -7,7 +7,7 @@
 
 import legacyDefaultConfig from './legacy-default-config.js';
 import * as constants from './constants.js';
-import format from '../../shared/localization/format.js';
+import * as format from '../../shared/localization/format.js';
 import * as validation from './../fraggle-rock/config/validation.js';
 import log from 'lighthouse-logger';
 import path from 'path';

package/core/config/constants.js

@@ -119,6 +119,7 @@ const defaultSettings = {
   onlyAudits: null,
   onlyCategories: null,
   skipAudits: null,
+  skipAboutBlank: false,
 };
 
 /** @type {LH.Config.Pass} */

package/core/config/default-config.js

@@ -413,7 +413,6 @@ const defaultConfig = {
     'dobetterweb/geolocation-on-start',
     'dobetterweb/inspector-issues',
     'dobetterweb/no-document-write',
-    'dobetterweb/no-vulnerable-libraries',
     'dobetterweb/js-libraries',
     'dobetterweb/notification-on-start',
     'dobetterweb/password-inputs-can-be-pasted-into',
@@ -666,7 +665,6 @@ const defaultConfig = {
         {id: 'is-on-https', weight: 1, group: 'best-practices-trust-safety'},
         {id: 'geolocation-on-start', weight: 1, group: 'best-practices-trust-safety'},
         {id: 'notification-on-start', weight: 1, group: 'best-practices-trust-safety'},
-        {id: 'no-vulnerable-libraries', weight: 1, group: 'best-practices-trust-safety'},
         {id: 'csp-xss', weight: 0, group: 'best-practices-trust-safety'},
         // User Experience
         {id: 'password-inputs-can-be-pasted-into', weight: 1, group: 'best-practices-ux'},

package/core/fraggle-rock/api.js

@@ -9,7 +9,7 @@ import {UserFlow, auditGatherSteps} from './user-flow.js';
 import {snapshotGather} from './gather/snapshot-runner.js';
 import {startTimespanGather} from './gather/timespan-runner.js';
 import {navigationGather} from './gather/navigation-runner.js';
-import ReportGenerator from '../../report/generator/report-generator.js';
+import {ReportGenerator} from '../../report/generator/report-generator.js';
 import {Runner} from '../runner.js';
 
 /**

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

@@ -40,8 +40,6 @@ const defaultConfigPath = path.join(
   '../../config/default-config.js'
 );
 
-/** @typedef {LH.Config.FRContext & {gatherMode: LH.Gatherer.GatherMode}} ConfigContext */
-
 /**
  * @param {LH.Config.Json|undefined} configJSON
  * @param {{configPath?: string}} context
@@ -176,10 +174,10 @@ async function resolveArtifactsToDefns(artifacts, configDir) {
  * Overrides the settings that may not apply to the chosen gather mode.
  *
  * @param {LH.Config.Settings} settings
- * @param {ConfigContext} context
+ * @param {LH.Gatherer.GatherMode} gatherMode
  */
-function overrideSettingsForGatherMode(settings, context) {
-  if (context.gatherMode === 'timespan') {
+function overrideSettingsForGatherMode(settings, gatherMode) {
+  if (gatherMode === 'timespan') {
     if (settings.throttlingMethod === 'simulate') {
       settings.throttlingMethod = 'devtools';
     }
@@ -251,21 +249,22 @@ function resolveNavigationsToDefns(navigations, artifactDefns, settings) {
 }
 
 /**
- * @param {LH.Config.Json|undefined} configJSON
- * @param {ConfigContext} context
+ * @param {LH.Gatherer.GatherMode} gatherMode
+ * @param {LH.Config.Json=} configJSON
+ * @param {LH.Flags=} flags
  * @return {Promise<{config: LH.Config.FRConfig, warnings: string[]}>}
  */
-async function initializeConfig(configJSON, context) {
+async function initializeConfig(gatherMode, configJSON, flags = {}) {
   const status = {msg: 'Initialize config', id: 'lh:config'};
   log.time(status, 'verbose');
 
-  let {configWorkingCopy, configDir} = resolveWorkingCopy(configJSON, context); // eslint-disable-line prefer-const
+  let {configWorkingCopy, configDir} = resolveWorkingCopy(configJSON, flags);
 
   configWorkingCopy = resolveExtensions(configWorkingCopy);
-  configWorkingCopy = await mergePlugins(configWorkingCopy, configDir, context.settingsOverrides);
+  configWorkingCopy = await mergePlugins(configWorkingCopy, configDir, flags);
 
-  const settings = resolveSettings(configWorkingCopy.settings || {}, context.settingsOverrides);
-  overrideSettingsForGatherMode(settings, context);
+  const settings = resolveSettings(configWorkingCopy.settings || {}, flags);
+  overrideSettingsForGatherMode(settings, gatherMode);
 
   const artifacts = await resolveArtifactsToDefns(configWorkingCopy.artifacts, configDir);
   const navigations = resolveNavigationsToDefns(configWorkingCopy.navigations, artifacts, settings);
@@ -282,7 +281,7 @@ async function initializeConfig(configJSON, context) {
 
   const {warnings} = assertValidConfig(config);
 
-  config = filterConfigByGatherMode(config, context.gatherMode);
+  config = filterConfigByGatherMode(config, gatherMode);
   config = filterConfigByExplicitFilters(config, settings);
 
   log.timeEnd(status);

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

@@ -17,7 +17,7 @@ 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 format from '../../../shared/localization/format.js';
+import * as format from '../../../shared/localization/format.js';
 import {LighthouseError} from '../../lib/lh-error.js';
 import URL from '../../lib/url-shim.js';
 import {getPageLoadError} from '../../lib/navigation-error.js';
@@ -25,8 +25,6 @@ import Trace from '../../gather/gatherers/trace.js';
 import DevtoolsLog from '../../gather/gatherers/devtools-log.js';
 import NetworkRecords from '../../computed/network-records.js';
 
-/** @typedef {{skipAboutBlank?: boolean}} InternalOptions */
-
 /**
  * @typedef NavigationContext
  * @property {Driver} driver
@@ -35,7 +33,6 @@ import NetworkRecords from '../../computed/network-records.js';
  * @property {LH.NavigationRequestor} requestor
  * @property {LH.FRBaseArtifacts} baseArtifacts
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
- * @property {InternalOptions} [options]
  */
 
 /** @typedef {Omit<Parameters<typeof collectPhaseArtifacts>[0], 'phase'>} PhaseState */
@@ -44,12 +41,14 @@ const DEFAULT_HOSTNAME = '127.0.0.1';
 const DEFAULT_PORT = 9222;
 
 /**
- * @param {{driver: Driver, config: LH.Config.FRConfig, options?: InternalOptions}} args
+ * @param {{driver: Driver, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor}} args
  * @return {Promise<{baseArtifacts: LH.FRBaseArtifacts}>}
  */
-async function _setup({driver, config, options}) {
+async function _setup({driver, config, requestor}) {
   await driver.connect();
-  if (!options?.skipAboutBlank) {
+
+  // We can't trigger the navigation through user interaction if we reset the page before starting.
+  if (typeof requestor === 'string' && !config.settings.skipAboutBlank) {
     await gotoURL(driver, defaultNavigationConfig.blankPage, {waitUntil: ['navigated']});
   }
 
@@ -64,10 +63,12 @@ async function _setup({driver, config, options}) {
  * @param {NavigationContext} navigationContext
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function _setupNavigation({requestor, driver, navigation, config, options}) {
-  if (!options?.skipAboutBlank) {
+async function _setupNavigation({requestor, driver, navigation, config}) {
+  // We can't trigger the navigation through user interaction if we reset the page before starting.
+  if (typeof requestor === 'string' && !config.settings.skipAboutBlank) {
     await gotoURL(driver, navigation.blankPage, {...navigation, waitUntil: ['navigated']});
   }
+
   const {warnings} = await prepare.prepareTargetForIndividualNavigation(
     driver.defaultSession,
     config.settings,
@@ -249,10 +250,10 @@ async function _navigation(navigationContext) {
 }
 
 /**
- * @param {{driver: Driver, config: LH.Config.FRConfig, requestor: LH.NavigationRequestor; 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']}} args
  * @return {Promise<{artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>}>}
  */
-async function _navigations({driver, config, requestor, baseArtifacts, computedCache, options}) {
+async function _navigations({driver, config, requestor, baseArtifacts, computedCache}) {
   if (!config.navigations) throw new Error('No navigations configured');
 
   /** @type {Partial<LH.FRArtifacts & LH.FRBaseArtifacts>} */
@@ -268,7 +269,6 @@ async function _navigations({driver, config, requestor, baseArtifacts, computedC
       config,
       baseArtifacts,
       computedCache,
-      options,
     };
 
     let shouldHaltNavigations = false;
@@ -300,25 +300,17 @@ async function _cleanup({requestedUrl, driver, config}) {
 
 /**
  * @param {LH.NavigationRequestor|undefined} requestor
- * @param {{page?: LH.Puppeteer.Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
+ * @param {{page?: LH.Puppeteer.Page, config?: LH.Config.Json, flags?: LH.Flags}} options
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function navigationGather(requestor, options) {
-  const {configContext = {}} = options;
-  log.setLevel(configContext.logLevel || 'error');
+  const {flags = {}} = options;
+  log.setLevel(flags.logLevel || 'error');
 
-  const {config} =
-    await initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
+  const {config} = await initializeConfig('navigation', options.config, flags);
   const computedCache = new Map();
-  const internalOptions = {
-    skipAboutBlank: configContext.skipAboutBlank,
-  };
 
-  // We can't trigger the navigation through user interaction if we reset the page before starting.
   const isCallback = typeof requestor === 'function';
-  if (isCallback) {
-    internalOptions.skipAboutBlank = true;
-  }
 
   const runnerOptions = {config, computedCache};
   const artifacts = await Runner.gather(
@@ -329,7 +321,7 @@ async function navigationGather(requestor, options) {
       // For navigation mode, we shouldn't connect to a browser in audit mode,
       // therefore we connect to the browser in the gatherFn callback.
       if (!page) {
-        const {hostname = DEFAULT_HOSTNAME, port = DEFAULT_PORT} = configContext;
+        const {hostname = DEFAULT_HOSTNAME, port = DEFAULT_PORT} = flags;
         const browser = await puppeteer.connect({browserURL: `http://${hostname}:${port}`});
         page = await browser.newPage();
       }
@@ -339,7 +331,6 @@ async function navigationGather(requestor, options) {
         driver,
         config,
         requestor: normalizedRequestor,
-        options: internalOptions,
       };
       const {baseArtifacts} = await _setup(context);
       const {artifacts} = await _navigations({...context, baseArtifacts, computedCache});

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

@@ -13,15 +13,14 @@ import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 
 /**
- * @param {{page: LH.Puppeteer.Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
+ * @param {{page: LH.Puppeteer.Page, config?: LH.Config.Json, flags?: LH.Flags}} options
  * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
 async function snapshotGather(options) {
-  const {configContext = {}} = options;
-  log.setLevel(configContext.logLevel || 'error');
+  const {flags = {}} = options;
+  log.setLevel(flags.logLevel || 'error');
 
-  const {config} =
-    await initializeConfig(options.config, {...configContext, gatherMode: 'snapshot'});
+  const {config} = await initializeConfig('snapshot', options.config, flags);
   const driver = new Driver(options.page);
   await driver.connect();
 

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

@@ -14,15 +14,14 @@ import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 
 /**
- * @param {{page: LH.Puppeteer.Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
+ * @param {{page: LH.Puppeteer.Page, config?: LH.Config.Json, flags?: LH.Flags}} options
  * @return {Promise<{endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>}>}
  */
 async function startTimespanGather(options) {
-  const {configContext = {}} = options;
-  log.setLevel(configContext.logLevel || 'error');
+  const {flags = {}} = options;
+  log.setLevel(flags.logLevel || 'error');
 
-  const {config} =
-    await initializeConfig(options.config, {...configContext, gatherMode: 'timespan'});
+  const {config} = await initializeConfig('timespan', options.config, flags);
   const driver = new Driver(options.page);
   await driver.connect();
 

package/core/fraggle-rock/replay/stringify-extension.js

@@ -0,0 +1,105 @@
+/**
+ * @license Copyright 2022 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * 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.
+ */
+'use strict';
+
+import * as PuppeteerReplay from '@puppeteer/replay';
+
+/**
+ * @param {PuppeteerReplay.Schema.Step} step
+ * @return {boolean}
+ */
+function isNavigationStep(step) {
+  return Boolean(
+    step.type === 'navigate' ||
+    step.assertedEvents?.some(event => event.type === 'navigation')
+  );
+}
+
+class LighthouseStringifyExtension extends PuppeteerReplay.PuppeteerStringifyExtension {
+  #isProcessingTimespan = false;
+
+  /**
+   * @override
+   * @param {PuppeteerReplay.LineWriter} out
+   * @param {PuppeteerReplay.Schema.UserFlow} flow
+   */
+  async beforeAllSteps(out, flow) {
+    out.appendLine(`const fs = require('fs');`);
+
+    let isMobile = true;
+    for (const step of flow.steps) {
+      if (step.type !== 'setViewport') continue;
+      isMobile = step.isMobile;
+    }
+
+    await super.beforeAllSteps(out, flow);
+
+    const flags = {
+      screenEmulation: {
+        disabled: true,
+      },
+    };
+    out.appendLine(`const flags = ${JSON.stringify(flags)}`);
+    if (isMobile) {
+      out.appendLine(`const config = undefined;`);
+    } else {
+      // eslint-disable-next-line max-len
+      out.appendLine(`const config = (await import('lighthouse/core/config/desktop-config.js')).default;`);
+    }
+
+    out.appendLine(`const lhApi = await import('lighthouse/core/fraggle-rock/api.js');`);
+    // eslint-disable-next-line max-len
+    out.appendLine(`const lhFlow = await lhApi.startFlow(page, {name: ${JSON.stringify(flow.title)}, config, flags});`);
+  }
+
+  /**
+   * @override
+   * @param {PuppeteerReplay.LineWriter} out
+   * @param {PuppeteerReplay.Schema.Step} step
+   * @param {PuppeteerReplay.Schema.UserFlow} flow
+   */
+  async stringifyStep(out, step, flow) {
+    if (step.type === 'setViewport') {
+      await super.stringifyStep(out, step, flow);
+      return;
+    }
+
+    const isNavigation = isNavigationStep(step);
+
+    if (isNavigation) {
+      if (this.#isProcessingTimespan) {
+        out.appendLine(`await lhFlow.endTimespan();`);
+        this.#isProcessingTimespan = false;
+      }
+      out.appendLine(`await lhFlow.startNavigation();`);
+    } else if (!this.#isProcessingTimespan) {
+      out.appendLine(`await lhFlow.startTimespan();`);
+      this.#isProcessingTimespan = true;
+    }
+
+    await super.stringifyStep(out, step, flow);
+
+    if (isNavigation) {
+      out.appendLine(`await lhFlow.endNavigation();`);
+    }
+  }
+
+  /**
+   * @override
+   * @param {PuppeteerReplay.LineWriter} out
+   * @param {PuppeteerReplay.Schema.UserFlow} flow
+   */
+  async afterAllSteps(out, flow) {
+    if (this.#isProcessingTimespan) {
+      out.appendLine(`await lhFlow.endTimespan();`);
+    }
+    out.appendLine(`const lhFlowReport = await lhFlow.generateReport();`);
+    out.appendLine(`fs.writeFileSync(__dirname + '/flow.report.html', lhFlowReport)`);
+    await super.afterAllSteps(out, flow);
+  }
+}
+
+export default LighthouseStringifyExtension;

package/core/fraggle-rock/user-flow.js

@@ -5,7 +5,7 @@
  */
 'use strict';
 
-import ReportGenerator from '../../report/generator/report-generator.js';
+import {ReportGenerator} from '../../report/generator/report-generator.js';
 import {snapshotGather} from './gather/snapshot-runner.js';
 import {startTimespanGather} from './gather/timespan-runner.js';
 import {navigationGather} from './gather/navigation-runner.js';
@@ -63,24 +63,22 @@ class UserFlow {
    */
   _getNextNavigationOptions(stepOptions) {
     const options = {...this.options, ...stepOptions};
-    const configContext = {...options.configContext};
-    const settingsOverrides = {...configContext.settingsOverrides};
+    const flags = {...options.flags};
 
-    if (configContext.skipAboutBlank === undefined) {
-      configContext.skipAboutBlank = true;
+    if (flags.skipAboutBlank === undefined) {
+      flags.skipAboutBlank = true;
     }
 
     // On repeat navigations, we want to disable storage reset by default (i.e. it's not a cold load).
     const isSubsequentNavigation = this._gatherSteps
       .some(step => step.artifacts.GatherContext.gatherMode === 'navigation');
     if (isSubsequentNavigation) {
-      if (settingsOverrides.disableStorageReset === undefined) {
-        settingsOverrides.disableStorageReset = true;
+      if (flags.disableStorageReset === undefined) {
+        flags.disableStorageReset = true;
       }
     }
 
-    configContext.settingsOverrides = settingsOverrides;
-    options.configContext = configContext;
+    options.flags = flags;
 
     return options;
   }
@@ -96,7 +94,7 @@ class UserFlow {
       artifacts: gatherResult.artifacts,
       name: providedName || this._getDefaultStepName(gatherResult.artifacts),
       config: options.config,
-      configContext: options.configContext,
+      flags: options.flags,
     };
     this._gatherSteps.push(gatherStep);
     this._gatherStepRunnerOptions.set(gatherStep, gatherResult.runnerOptions);
@@ -246,7 +244,7 @@ async function auditGatherSteps(gatherSteps, options) {
   /** @type {LH.FlowResult['steps']} */
   const steps = [];
   for (const gatherStep of gatherSteps) {
-    const {artifacts, name, configContext} = gatherStep;
+    const {artifacts, name, flags} = gatherStep;
 
     let runnerOptions = options.gatherStepRunnerOptions?.get(gatherStep);
 
@@ -255,7 +253,7 @@ async function auditGatherSteps(gatherSteps, options) {
       // Step specific configs take precedence over a config for the entire flow.
       const configJson = gatherStep.config || options.config;
       const {gatherMode} = artifacts.GatherContext;
-      const {config} = await initializeConfig(configJson, {...configContext, gatherMode});
+      const {config} = await initializeConfig(gatherMode, configJson, flags);
       runnerOptions = {
         config,
         computedCache: new Map(),

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

@@ -16,6 +16,13 @@ class ExecutionContext {
 
     /** @type {number|undefined} */
     this._executionContextId = undefined;
+    /**
+     * Marks how many execution context ids have been created, for purposes of having a unique
+     * value (that doesn't expose the actual execution context id) to
+     * use for __lighthouseExecutionContextUniqueIdentifier.
+     * @type {number}
+     */
+    this._executionContextIdentifiersCreated = 0;
 
     // We use isolated execution contexts for `evaluateAsync` that can be destroyed through navigation
     // and other page actions. Cleanup our relevant bookkeeping as we see those events.
@@ -64,10 +71,10 @@ class ExecutionContext {
     });
 
     this._executionContextId = isolatedWorldResponse.executionContextId;
+    this._executionContextIdentifiersCreated++;
     return isolatedWorldResponse.executionContextId;
   }
 
-
   /**
    * Evaluate an expression in the given execution context; an undefined contextId implies the main
    * page without isolation.
@@ -82,15 +89,25 @@ class ExecutionContext {
       this._session.getNextProtocolTimeout() :
       60000;
 
+    // `__lighthouseExecutionContextUniqueIdentifier` is only used by the FullPageScreenshot gatherer.
+    // See `getNodeDetails` in page-functions.
+    const uniqueExecutionContextIdentifier = contextId === undefined ?
+      undefined :
+      this._executionContextIdentifiersCreated;
+
     const evaluationParams = {
       // We need to explicitly wrap the raw expression for several purposes:
       // 1. Ensure that the expression will be a native Promise and not a polyfill/non-Promise.
       // 2. Ensure that errors in the expression are captured by the Promise.
       // 3. Ensure that errors captured in the Promise are converted into plain-old JS Objects
       //    so that they can be serialized properly b/c JSON.stringify(new Error('foo')) === '{}'
+      //
+      // `__lighthouseExecutionContextUniqueIdentifier` is only used by the FullPageScreenshot gatherer.
+      // See `getNodeDetails` in page-functions.
       expression: `(function wrapInNativePromise() {
         ${ExecutionContext._cachedNativesPreamble};
-        globalThis.__lighthouseExecutionContextId = ${contextId};
+        globalThis.__lighthouseExecutionContextUniqueIdentifier =
+          ${uniqueExecutionContextIdentifier};
         return new Promise(function (resolve) {
           return Promise.resolve()
             .then(_ => ${expression})

package/core/gather/gather-runner.js

@@ -10,7 +10,7 @@ import NetworkRecords from '../computed/network-records.js';
 import {getPageLoadError} from '../lib/navigation-error.js';
 import * as emulation from '../lib/emulation.js';
 import * as constants from '../config/constants.js';
-import format from '../../shared/localization/format.js';
+import * as format from '../../shared/localization/format.js';
 import {getBenchmarkIndex, getEnvironmentWarnings} from './driver/environment.js';
 import * as prepare from './driver/prepare.js';
 import * as storage from './driver/storage.js';

package/core/index.js

@@ -12,7 +12,6 @@ import {Config} from './config/config.js';
 import URL from './lib/url-shim.js';
 import * as fraggleRock from './fraggle-rock/api.js';
 import {Driver} from './gather/driver.js';
-import {flagsToFRContext} from './config/config-helpers.js';
 import {initializeConfig} from './fraggle-rock/config/config.js';
 
 /** @typedef {import('./gather/connections/connection.js').Connection} Connection */
@@ -41,8 +40,7 @@ import {initializeConfig} from './fraggle-rock/config/config.js';
  * @return {Promise<LH.RunnerResult|undefined>}
  */
 async function lighthouse(url, flags = {}, configJSON, page) {
-  const configContext = flagsToFRContext(flags);
-  return fraggleRock.navigation(url, {page, config: configJSON, configContext});
+  return fraggleRock.navigation(url, {page, config: configJSON, flags});
 }
 
 /**
@@ -86,8 +84,7 @@ async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
  * @return {Promise<LH.Config.FRConfig>}
  */
 async function generateConfig(configJson, flags = {}, gatherMode = 'navigation') {
-  const configContext = flagsToFRContext(flags);
-  const {config} = await initializeConfig(configJson, {...configContext, gatherMode});
+  const {config} = await initializeConfig(gatherMode, configJson, flags);
   return config;
 }
 

package/core/lib/asset-saver.js

@@ -12,7 +12,7 @@ import stream from 'stream';
 import util from 'util';
 import {Simulator} from './dependency-graph/simulator/simulator.js';
 import lanternTraceSaver from './lantern-trace-saver.js';
-import {Metrics} from './traces/pwmetrics-events.js';
+import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import NetworkAnalysisComputed from '../computed/network-analysis.js';
 import LoadSimulatorComputed from '../computed/load-simulator.js';
 import {LighthouseError} from '../lib/lh-error.js';
@@ -164,7 +164,7 @@ async function prepareAssets(artifacts, audits) {
 
     const traceData = Object.assign({}, trace);
     if (audits) {
-      const evts = new Metrics(traceData.traceEvents, audits).generateFakeEvents();
+      const evts = new MetricTraceEvents(traceData.traceEvents, audits).generateFakeEvents();
       traceData.traceEvents = traceData.traceEvents.concat(evts);
     }
 

package/core/lib/page-functions.js

@@ -498,6 +498,18 @@ function getNodeDetails(element) {
   const selector = getNodeSelector(element);
 
   // Create an id that will be unique across all execution contexts.
+  //
+  // Made up of 3 components:
+  //   - prefix unique to specific execution context
+  //   - nth unique node seen by this function for this execution context
+  //   - node tagName
+  //
+  // Every page load only has up to two associated contexts - the page context
+  // (denoted as `__lighthouseExecutionContextUniqueIdentifier` being undefined)
+  // and the isolated context. The id must be unique to distinguish gatherers running
+  // on different page loads that identify the same logical element, for purposes
+  // of the full page screenshot node lookup; hence the prefix.
+  //
   // The id could be any arbitrary string, the exact value is not important.
   // For example, tagName is added only because it might be useful for debugging.
   // But execution id and map size are added to ensure uniqueness.
@@ -507,9 +519,9 @@ function getNodeDetails(element) {
   let lhId = window.__lighthouseNodesDontTouchOrAllVarianceGoesAway.get(element);
   if (!lhId) {
     lhId = [
-      window.__lighthouseExecutionContextId !== undefined ?
-        window.__lighthouseExecutionContextId :
-        'page',
+      window.__lighthouseExecutionContextUniqueIdentifier === undefined ?
+        'page' :
+        window.__lighthouseExecutionContextUniqueIdentifier,
       window.__lighthouseNodesDontTouchOrAllVarianceGoesAway.size,
       element.tagName,
     ].join('-');

package/core/lib/traces/{pwmetrics-events.js → metric-trace-events.js}

@@ -19,7 +19,7 @@ function getUberMetrics(auditResults) {
   return metricsAudit.details.items[0];
 }
 
-class Metrics {
+class MetricTraceEvents {
   /**
    * @param {Array<LH.TraceEvent>} traceEvents
    * @param {LH.Result['audits']} auditResults
@@ -100,7 +100,7 @@ class Metrics {
 
     /** @type {Array<{ts: number, id: string, name: string}>} */
     const resolvedMetrics = [];
-    Metrics.metricsDefinitions.forEach(metric => {
+    MetricTraceEvents.metricsDefinitions.forEach(metric => {
       // Skip if auditResults is missing a particular audit result
       const ts = uberMetrics[metric.tsKey];
       if (ts === undefined) {
@@ -197,5 +197,4 @@ class Metrics {
   }
 }
 
-// TODO(esmodule): rename?
-export {Metrics};
+export {MetricTraceEvents};