lighthouse 9.5.0-dev.20220607 → 9.5.0-dev.20220610

package/esm-utils.mjs

@@ -0,0 +1,40 @@
+/**
+ * @license Copyright 2021 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';
+// TODO(esmodules): rename to .js when root is type: module
+
+import module from 'module';
+import url from 'url';
+import path from 'path';
+
+/**
+ * Commonjs equivalent of `require.resolve`.
+ * @param {string} packageName
+ */
+function resolveModulePath(packageName) {
+  const require = module.createRequire(import.meta.url);
+  return require.resolve(packageName);
+}
+
+/**
+ * @param {ImportMeta} importMeta
+ */
+function getModulePath(importMeta) {
+  return url.fileURLToPath(importMeta.url);
+}
+
+/**
+ * @param {ImportMeta} importMeta
+ */
+function getModuleDirectory(importMeta) {
+  return path.dirname(getModulePath(importMeta));
+}
+
+export {
+  resolveModulePath,
+  getModulePath,
+  getModuleDirectory,
+};

package/flow-report/tsconfig.json

@@ -1,8 +1,6 @@
 {
   "extends": "../tsconfig-base.json",
   "compilerOptions": {
-    "outDir": "../.tmp/tsbuildinfo/flow-report",
-
     // Limit to base JS and DOM defs.
     "lib": ["es2020", "dom", "dom.iterable"],
     // Selectively include types from node_modules/.

package/lighthouse-cli/bin.js

@@ -120,7 +120,7 @@ async function begin() {
   }
 
   if (cliFlags.printConfig) {
-    const config = lighthouse.generateConfig(configJson, cliFlags);
+    const config = await lighthouse.generateConfig(configJson, cliFlags);
     process.stdout.write(config.getPrintString());
     return;
   }

package/lighthouse-cli/index.js

@@ -7,7 +7,4 @@
 
 import {begin} from './bin.js';
 
-begin().catch(err => {
-  process.stderr.write(err.stack);
-  process.exit(1);
-});
+await begin();

package/lighthouse-cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -255,7 +255,4 @@ async function begin() {
   process.exit(exitCode);
 }
 
-begin().catch(e => {
-  console.error(e);
-  process.exit(1);
-});
+await begin();

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

@@ -211,7 +211,8 @@ const bundledModules = new Map(/* BUILD_REPLACE_BUNDLED_MODULES */);
  * See build-bundle.js
  * @param {string} requirePath
  */
-function requireWrapper(requirePath) {
+async function requireWrapper(requirePath) {
+  // This is async because eventually this function needs to do async dynamic imports.
   return bundledModules.get(requirePath) || require(requirePath);
 }
 
@@ -219,9 +220,9 @@ function requireWrapper(requirePath) {
  * @param {string} gathererPath
  * @param {Array<string>} coreGathererList
  * @param {string=} configDir
- * @return {LH.Config.GathererDefn}
+ * @return {Promise<LH.Config.GathererDefn>}
  */
-function requireGatherer(gathererPath, coreGathererList, configDir) {
+async function requireGatherer(gathererPath, coreGathererList, configDir) {
   const coreGatherer = coreGathererList.find(a => a === `${gathererPath}.js`);
 
   let requirePath = `../gather/gatherers/${gathererPath}`;
@@ -230,7 +231,7 @@ function requireGatherer(gathererPath, coreGathererList, configDir) {
     requirePath = resolveModulePath(gathererPath, configDir, 'gatherer');
   }
 
-  const GathererClass = /** @type {GathererConstructor} */ (requireWrapper(requirePath));
+  const GathererClass = /** @type {GathererConstructor} */ (await requireWrapper(requirePath));
 
   return {
     instance: new GathererClass(),
@@ -243,7 +244,7 @@ function requireGatherer(gathererPath, coreGathererList, configDir) {
  * @param {string} auditPath
  * @param {Array<string>} coreAuditList
  * @param {string=} configDir
- * @return {LH.Config.AuditDefn['implementation']}
+ * @return {Promise<LH.Config.AuditDefn['implementation']>}
  */
 function requireAudit(auditPath, coreAuditList, configDir) {
   // See if the audit is a Lighthouse core audit.
@@ -328,9 +329,9 @@ function resolveSettings(settingsJson = {}, overrides = undefined) {
  * @param {LH.Config.Json} configJSON
  * @param {string | undefined} configDir
  * @param {{plugins?: string[]} | undefined} flags
- * @return {LH.Config.Json}
+ * @return {Promise<LH.Config.Json>}
  */
-function mergePlugins(configJSON, configDir, flags) {
+async function mergePlugins(configJSON, configDir, flags) {
   const configPlugins = configJSON.plugins || [];
   const flagPlugins = flags?.plugins || [];
   const pluginNames = new Set([...configPlugins, ...flagPlugins]);
@@ -342,7 +343,7 @@ function mergePlugins(configJSON, configDir, flags) {
     const pluginPath = isBundledEnvironment() ?
         pluginName :
         resolveModulePath(pluginName, configDir, 'plugin');
-    const rawPluginJson = requireWrapper(pluginPath);
+    const rawPluginJson = await requireWrapper(pluginPath);
     const pluginJson = ConfigPlugin.parsePlugin(rawPluginJson, pluginName);
 
     configJSON = mergeConfigFragment(configJSON, pluginJson);
@@ -360,9 +361,9 @@ function mergePlugins(configJSON, configDir, flags) {
  * @param {LH.Config.GathererJson} gathererJson
  * @param {Array<string>} coreGathererList
  * @param {string=} configDir
- * @return {LH.Config.GathererDefn}
+ * @return {Promise<LH.Config.GathererDefn>}
  */
-function resolveGathererToDefn(gathererJson, coreGathererList, configDir) {
+async function resolveGathererToDefn(gathererJson, coreGathererList, configDir) {
   const gathererDefn = expandGathererShorthand(gathererJson);
   if (gathererDefn.instance) {
     return {
@@ -391,21 +392,21 @@ function resolveGathererToDefn(gathererJson, coreGathererList, configDir) {
  * leaving only an array of AuditDefns.
  * @param {LH.Config.Json['audits']} audits
  * @param {string=} configDir
- * @return {Array<LH.Config.AuditDefn>|null}
+ * @return {Promise<Array<LH.Config.AuditDefn>|null>}
  */
-function resolveAuditsToDefns(audits, configDir) {
+async function resolveAuditsToDefns(audits, configDir) {
   if (!audits) {
     return null;
   }
 
   const coreList = Runner.getAuditList();
-  const auditDefns = audits.map(auditJson => {
+  const auditDefnsPromises = audits.map(async (auditJson) => {
     const auditDefn = expandAuditShorthand(auditJson);
     let implementation;
     if ('implementation' in auditDefn) {
       implementation = auditDefn.implementation;
     } else {
-      implementation = requireAudit(auditDefn.path, coreList, configDir);
+      implementation = await requireAudit(auditDefn.path, coreList, configDir);
     }
 
     return {
@@ -414,6 +415,7 @@ function resolveAuditsToDefns(audits, configDir) {
       options: auditDefn.options || {},
     };
   });
+  const auditDefns = await Promise.all(auditDefnsPromises);
 
   const mergedAuditDefns = mergeOptionsOfItems(auditDefns);
   mergedAuditDefns.forEach(audit => validation.assertValidAudit(audit));

package/lighthouse-core/config/config.js

@@ -38,6 +38,7 @@ const BASE_ARTIFACT_BLANKS = {
   HostUserAgent: '',
   NetworkUserAgent: '',
   BenchmarkIndex: '',
+  BenchmarkIndexes: '',
   WebAppManifest: '',
   GatherContext: '',
   InstallabilityErrors: '',
@@ -148,17 +149,18 @@ function assertValidFlags(flags) {
   }
 }
 
-
 /**
  * @implements {LH.Config.Config}
  */
 class Config {
   /**
-   * @constructor
-   * @param {LH.Config.Json=} configJSON
+   * Resolves the provided config (inherits from extended config, if set), resolves
+   * all referenced modules, and validates.
+   * @param {LH.Config.Json=} configJSON If not provided, uses the default config.
    * @param {LH.Flags=} flags
+   * @return {Promise<Config>}
    */
-  constructor(configJSON, flags) {
+  static async fromJson(configJSON, flags) {
     const status = {msg: 'Create config', id: 'lh:init:config'};
     log.time(status, 'verbose');
     let configPath = flags?.configPath;
@@ -187,7 +189,7 @@ class Config {
     const configDir = configPath ? path.dirname(configPath) : undefined;
 
     // Validate and merge in plugins (if any).
-    configJSON = mergePlugins(configJSON, configDir, flags);
+    configJSON = await mergePlugins(configJSON, configDir, flags);
 
     if (flags) {
       assertValidFlags(flags);
@@ -197,14 +199,28 @@ class Config {
     // Augment passes with necessary defaults and require gatherers.
     const passesWithDefaults = Config.augmentPassesWithDefaults(configJSON.passes);
     Config.adjustDefaultPassForThrottling(settings, passesWithDefaults);
-    const passes = Config.requireGatherers(passesWithDefaults, configDir);
+    const passes = await Config.requireGatherers(passesWithDefaults, configDir);
 
+    const audits = await Config.requireAudits(configJSON.audits, configDir);
+
+    const config = new Config(configJSON, {settings, passes, audits});
+    log.timeEnd(status);
+    return config;
+  }
+
+  /**
+   * @deprecated `Config.fromJson` should be used instead.
+   * @constructor
+   * @param {LH.Config.Json} configJSON
+   * @param {{settings: LH.Config.Settings, passes: ?LH.Config.Pass[], audits: ?LH.Config.AuditDefn[]}} opts
+   */
+  constructor(configJSON, opts) {
     /** @type {LH.Config.Settings} */
-    this.settings = settings;
+    this.settings = opts.settings;
     /** @type {?Array<LH.Config.Pass>} */
-    this.passes = passes;
+    this.passes = opts.passes;
     /** @type {?Array<LH.Config.AuditDefn>} */
-    this.audits = Config.requireAudits(configJSON.audits, configDir);
+    this.audits = opts.audits;
     /** @type {?Record<string, LH.Config.Category>} */
     this.categories = configJSON.categories || null;
     /** @type {?Record<string, LH.Config.Group>} */
@@ -214,8 +230,6 @@ class Config {
 
     assertValidPasses(this.passes, this.audits);
     validation.assertValidCategories(this.categories, this.audits, this.groups);
-
-    log.timeEnd(status);
   }
 
   /**
@@ -498,12 +512,12 @@ class Config {
    * leaving only an array of AuditDefns.
    * @param {LH.Config.Json['audits']} audits
    * @param {string=} configDir
-   * @return {Config['audits']}
+   * @return {Promise<Config['audits']>}
    */
-  static requireAudits(audits, configDir) {
+  static async requireAudits(audits, configDir) {
     const status = {msg: 'Requiring audits', id: 'lh:config:requireAudits'};
     log.time(status, 'verbose');
-    const auditDefns = resolveAuditsToDefns(audits, configDir);
+    const auditDefns = await resolveAuditsToDefns(audits, configDir);
     log.timeEnd(status);
     return auditDefns;
   }
@@ -514,9 +528,9 @@ class Config {
    * provided) using `resolveModulePath`, returning an array of full Passes.
    * @param {?Array<Required<LH.Config.PassJson>>} passes
    * @param {string=} configDir
-   * @return {Config['passes']}
+   * @return {Promise<Config['passes']>}
    */
-  static requireGatherers(passes, configDir) {
+  static async requireGatherers(passes, configDir) {
     if (!passes) {
       return null;
     }
@@ -524,9 +538,11 @@ class Config {
     log.time(status, 'verbose');
 
     const coreList = Runner.getGathererList();
-    const fullPasses = passes.map(pass => {
-      const gathererDefns = pass.gatherers
-        .map(gatherer => resolveGathererToDefn(gatherer, coreList, configDir));
+    const fullPassesPromises = passes.map(async (pass) => {
+      const gathererDefns = await Promise.all(
+        pass.gatherers
+          .map(gatherer => resolveGathererToDefn(gatherer, coreList, configDir))
+      );
 
       // De-dupe gatherers by artifact name because artifact IDs must be unique at runtime.
       const uniqueDefns = Array.from(
@@ -536,6 +552,8 @@ class Config {
 
       return Object.assign(pass, {gatherers: uniqueDefns});
     });
+    const fullPasses = await Promise.all(fullPassesPromises);
+
     log.timeEnd(status);
     return fullPasses;
   }

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

@@ -121,9 +121,9 @@ function resolveArtifactDependencies(artifact, gatherer, artifactDefnsBySymbol)
  *
  * @param {LH.Config.ArtifactJson[]|null|undefined} artifacts
  * @param {string|undefined} configDir
- * @return {LH.Config.AnyArtifactDefn[] | null}
+ * @return {Promise<LH.Config.AnyArtifactDefn[] | null>}
  */
-function resolveArtifactsToDefns(artifacts, configDir) {
+async function resolveArtifactsToDefns(artifacts, configDir) {
   if (!artifacts) return null;
 
   const status = {msg: 'Resolve artifact definitions', id: 'lh:config:resolveArtifactsToDefns'};
@@ -133,12 +133,12 @@ function resolveArtifactsToDefns(artifacts, configDir) {
   const artifactDefnsBySymbol = new Map();
 
   const coreGathererList = Runner.getGathererList();
-  const artifactDefns = artifacts.map(artifactJson => {
+  const artifactDefnsPromises = artifacts.map(async (artifactJson) => {
     /** @type {LH.Config.GathererJson} */
     // @ts-expect-error - remove when legacy runner path is removed.
     const gathererJson = artifactJson.gatherer;
 
-    const gatherer = resolveGathererToDefn(gathererJson, coreGathererList, configDir);
+    const gatherer = await resolveGathererToDefn(gathererJson, coreGathererList, configDir);
     if (!isFRGathererDefn(gatherer)) {
       throw new Error(`${gatherer.instance.name} gatherer does not have a Fraggle Rock meta obj`);
     }
@@ -156,6 +156,7 @@ function resolveArtifactsToDefns(artifacts, configDir) {
     if (symbol) artifactDefnsBySymbol.set(symbol, artifact);
     return artifact;
   });
+  const artifactDefns = await Promise.all(artifactDefnsPromises);
 
   log.timeEnd(status);
   return artifactDefns;
@@ -242,28 +243,28 @@ function resolveNavigationsToDefns(navigations, artifactDefns, settings) {
 /**
  * @param {LH.Config.Json|undefined} configJSON
  * @param {ConfigContext} context
- * @return {{config: LH.Config.FRConfig, warnings: string[]}}
+ * @return {Promise<{config: LH.Config.FRConfig, warnings: string[]}>}
  */
-function initializeConfig(configJSON, context) {
+async function initializeConfig(configJSON, context) {
   const status = {msg: 'Initialize config', id: 'lh:config'};
   log.time(status, 'verbose');
 
   let {configWorkingCopy, configDir} = resolveWorkingCopy(configJSON, context); // eslint-disable-line prefer-const
 
   configWorkingCopy = resolveExtensions(configWorkingCopy);
-  configWorkingCopy = mergePlugins(configWorkingCopy, configDir, context.settingsOverrides);
+  configWorkingCopy = await mergePlugins(configWorkingCopy, configDir, context.settingsOverrides);
 
   const settings = resolveSettings(configWorkingCopy.settings || {}, context.settingsOverrides);
   overrideSettingsForGatherMode(settings, context);
 
-  const artifacts = resolveArtifactsToDefns(configWorkingCopy.artifacts, configDir);
+  const artifacts = await resolveArtifactsToDefns(configWorkingCopy.artifacts, configDir);
   const navigations = resolveNavigationsToDefns(configWorkingCopy.navigations, artifacts, settings);
 
   /** @type {LH.Config.FRConfig} */
   let config = {
     artifacts,
     navigations,
-    audits: resolveAuditsToDefns(configWorkingCopy.audits, configDir),
+    audits: await resolveAuditsToDefns(configWorkingCopy.audits, configDir),
     categories: configWorkingCopy.categories || null,
     groups: configWorkingCopy.groups || null,
     settings,

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

@@ -14,6 +14,7 @@ const baseArtifactKeySource = {
   fetchTime: '',
   LighthouseRunWarnings: '',
   BenchmarkIndex: '',
+  BenchmarkIndexes: '',
   settings: '',
   Timing: '',
   URL: '',

package/lighthouse-core/fraggle-rock/gather/driver.js

@@ -16,7 +16,7 @@ const throwNotConnectedFn = () => {
 };
 
 /** @type {LH.Gatherer.FRProtocolSession} */
-const defaultSession = {
+const throwingSession = {
   setTargetInfo: throwNotConnectedFn,
   hasNextProtocolTimeout: throwNotConnectedFn,
   getNextProtocolTimeout: throwNotConnectedFn,
@@ -26,8 +26,6 @@ const defaultSession = {
   off: throwNotConnectedFn,
   addProtocolMessageListener: throwNotConnectedFn,
   removeProtocolMessageListener: throwNotConnectedFn,
-  addSessionAttachedListener: throwNotConnectedFn,
-  removeSessionAttachedListener: throwNotConnectedFn,
   sendCommand: throwNotConnectedFn,
   dispose: throwNotConnectedFn,
 };
@@ -39,14 +37,12 @@ class Driver {
    */
   constructor(page) {
     this._page = page;
-    /** @type {LH.Gatherer.FRProtocolSession|undefined} */
-    this._session = undefined;
     /** @type {ExecutionContext|undefined} */
     this._executionContext = undefined;
     /** @type {Fetcher|undefined} */
     this._fetcher = undefined;
 
-    this.defaultSession = defaultSession;
+    this.defaultSession = throwingSession;
   }
 
   /** @return {LH.Gatherer.FRTransitionalDriver['executionContext']} */
@@ -68,20 +64,20 @@ class Driver {
 
   /** @return {Promise<void>} */
   async connect() {
-    if (this._session) return;
+    if (this.defaultSession !== throwingSession) return;
     const status = {msg: 'Connecting to browser', id: 'lh:driver:connect'};
     log.time(status);
     const session = await this._page.target().createCDPSession();
-    this._session = this.defaultSession = new ProtocolSession(session);
-    this._executionContext = new ExecutionContext(this._session);
-    this._fetcher = new Fetcher(this._session);
+    this.defaultSession = new ProtocolSession(session);
+    this._executionContext = new ExecutionContext(this.defaultSession);
+    this._fetcher = new Fetcher(this.defaultSession);
     log.timeEnd(status);
   }
 
   /** @return {Promise<void>} */
   async disconnect() {
-    if (!this._session) return;
-    await this._session.dispose();
+    if (this.defaultSession === throwingSession) return;
+    await this.defaultSession.dispose();
   }
 }
 

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

@@ -310,7 +310,8 @@ async function navigationGather(requestor, options) {
   const {configContext = {}} = options;
   log.setLevel(configContext.logLevel || 'error');
 
-  const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
+  const {config} =
+    await initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
   const computedCache = new Map();
   const internalOptions = {
     skipAboutBlank: configContext.skipAboutBlank,

package/lighthouse-core/fraggle-rock/gather/session.js

@@ -13,10 +13,10 @@ const DEFAULT_PROTOCOL_TIMEOUT = 30000;
 /** @implements {LH.Gatherer.FRProtocolSession} */
 class ProtocolSession {
   /**
-   * @param {LH.Puppeteer.CDPSession} session
+   * @param {LH.Puppeteer.CDPSession} cdpSession
    */
-  constructor(session) {
-    this._session = session;
+  constructor(cdpSession) {
+    this._cdpSession = cdpSession;
     /** @type {LH.Crdp.Target.TargetInfo|undefined} */
     this._targetInfo = undefined;
     /** @type {number|undefined} */
@@ -27,6 +27,7 @@ class ProtocolSession {
 
   sessionId() {
     return this._targetInfo && this._targetInfo.type === 'iframe' ?
+      // TODO: use this._session.id() for real session id.
       this._targetInfo.targetId :
       undefined;
   }
@@ -64,7 +65,7 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   on(eventName, callback) {
-    this._session.on(eventName, /** @type {*} */ (callback));
+    this._cdpSession.on(eventName, /** @type {*} */ (callback));
   }
 
   /**
@@ -74,28 +75,7 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   once(eventName, callback) {
-    this._session.once(eventName, /** @type {*} */ (callback));
-  }
-
-  /**
-   * Bind to the puppeteer `sessionattached` listener and return an LH ProtocolSession.
-   * @param {(session: ProtocolSession) => void} callback
-   */
-  addSessionAttachedListener(callback) {
-    /** @param {LH.Puppeteer.CDPSession} session */
-    const listener = session => callback(new ProtocolSession(session));
-    this._callbackMap.set(callback, listener);
-    this._getConnection().on('sessionattached', listener);
-  }
-
-  /**
-   * Unbind to the puppeteer `sessionattached` listener.
-   * @param {(session: ProtocolSession) => void} callback
-   */
-  removeSessionAttachedListener(callback) {
-    const listener = this._callbackMap.get(callback);
-    if (!listener) return;
-    this._getConnection().off('sessionattached', listener);
+    this._cdpSession.once(eventName, /** @type {*} */ (callback));
   }
 
   /**
@@ -114,7 +94,7 @@ class ProtocolSession {
       sessionId: this.sessionId(),
     });
     this._callbackMap.set(callback, listener);
-    this._session.on('*', /** @type {*} */ (listener));
+    this._cdpSession.on('*', /** @type {*} */ (listener));
   }
 
   /**
@@ -123,7 +103,7 @@ class ProtocolSession {
   removeProtocolMessageListener(callback) {
     const listener = this._callbackMap.get(callback);
     if (!listener) return;
-    this._session.off('*', /** @type {*} */ (listener));
+    this._cdpSession.off('*', /** @type {*} */ (listener));
   }
 
   /**
@@ -133,7 +113,7 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   off(eventName, callback) {
-    this._session.off(eventName, /** @type {*} */ (callback));
+    this._cdpSession.off(eventName, /** @type {*} */ (callback));
   }
 
   /**
@@ -156,7 +136,7 @@ class ProtocolSession {
       }));
     });
 
-    const resultPromise = this._session.send(method, ...params);
+    const resultPromise = this._cdpSession.send(method, ...params);
     const resultWithTimeoutPromise = Promise.race([resultPromise, timeoutPromise]);
 
     return resultWithTimeoutPromise.finally(() => {
@@ -169,14 +149,8 @@ class ProtocolSession {
    * @return {Promise<void>}
    */
   async dispose() {
-    this._session.removeAllListeners();
-    await this._session.detach();
-  }
-
-  _getConnection() {
-    const connection = this._session.connection();
-    if (!connection) throw new Error('Connection has been closed.');
-    return connection;
+    this._cdpSession.removeAllListeners();
+    await this._cdpSession.detach();
   }
 }
 

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

@@ -24,7 +24,8 @@ async function snapshotGather(options) {
   const {configContext = {}} = options;
   log.setLevel(configContext.logLevel || 'error');
 
-  const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'snapshot'});
+  const {config} =
+    await initializeConfig(options.config, {...configContext, gatherMode: 'snapshot'});
   const driver = new Driver(options.page);
   await driver.connect();
 

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

@@ -25,7 +25,8 @@ async function startTimespanGather(options) {
   const {configContext = {}} = options;
   log.setLevel(configContext.logLevel || 'error');
 
-  const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'timespan'});
+  const {config} =
+    await initializeConfig(options.config, {...configContext, gatherMode: 'timespan'});
   const driver = new Driver(options.page);
   await driver.connect();
 

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

@@ -205,7 +205,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} = initializeConfig(configJson, {...configContext, gatherMode});
+      const {config} = await initializeConfig(configJson, {...configContext, gatherMode});
       runnerOptions = {
         config,
         computedCache: new Map(),

package/lighthouse-core/gather/connections/cri.js

@@ -33,23 +33,9 @@ class CriConnection extends Connection {
    * @override
    * @return {Promise<void>}
    */
-  connect() {
-    return this._runJsonCommand('new')
-      .then(response => this._connectToSocket(/** @type {LH.DevToolsJsonTarget} */(response)))
-      .catch(_ => {
-        // COMPAT: headless didn't support `/json/new` before m59. (#970, crbug.com/699392)
-        // If no support, we fallback and reuse an existing open tab
-        log.warn('CriConnection', 'Cannot create new tab; reusing open tab.');
-        return this._runJsonCommand('list').then(tabs => {
-          if (!Array.isArray(tabs) || tabs.length === 0) {
-            return Promise.reject(new Error('Cannot create new tab, and no tabs already open.'));
-          }
-          const firstTab = tabs[0];
-          // first, we activate it to a foreground tab, then we connect
-          return this._runJsonCommand(`activate/${firstTab.id}`)
-              .then(() => this._connectToSocket(firstTab));
-        });
-      });
+  async connect() {
+    const response = await this._runJsonCommand('new');
+    return this._connectToSocket(/** @type {LH.DevToolsJsonTarget} */(response));
   }
 
   /**