lighthouse 9.5.0-dev.20220608 → 9.5.0-dev.20220611

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/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

@@ -149,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;
@@ -188,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);
@@ -198,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>} */
@@ -215,8 +230,6 @@ class Config {
 
     assertValidPasses(this.passes, this.audits);
     validation.assertValidCategories(this.categories, this.audits, this.groups);
-
-    log.timeEnd(status);
   }
 
   /**
@@ -499,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;
   }
@@ -515,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;
     }
@@ -525,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(
@@ -537,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/gather/driver.js

@@ -26,8 +26,6 @@ const throwingSession = {
   off: throwNotConnectedFn,
   addProtocolMessageListener: throwNotConnectedFn,
   removeProtocolMessageListener: throwNotConnectedFn,
-  addSessionAttachedListener: throwNotConnectedFn,
-  removeSessionAttachedListener: throwNotConnectedFn,
   sendCommand: throwNotConnectedFn,
   dispose: throwNotConnectedFn,
 };

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

@@ -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;
   }
@@ -77,27 +78,6 @@ class ProtocolSession {
     this._cdpSession.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);
-  }
-
   /**
    * Bind to puppeteer's '*' event that fires for *any* protocol event,
    * and wrap it with data about the protocol message instead of just the event.
@@ -172,12 +152,6 @@ class ProtocolSession {
     this._cdpSession.removeAllListeners();
     await this._cdpSession.detach();
   }
-
-  _getConnection() {
-    const connection = this._cdpSession.connection();
-    if (!connection) throw new Error('Connection has been closed.');
-    return connection;
-  }
 }
 
 module.exports = ProtocolSession;

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));
   }
 
   /**

package/lighthouse-core/gather/driver/network-monitor.js

@@ -90,7 +90,10 @@ class NetworkMonitor {
     this._frameNavigations = [];
     this._sessions = new Map();
     this._networkRecorder = new NetworkRecorder();
-    this._targetManager = new TargetManager(this._session);
+    /** @type {LH.Puppeteer.CDPSession} */
+    // @ts-expect-error - temporarily reach in to get CDPSession
+    const rootCdpSession = this._session._cdpSession;
+    this._targetManager = new TargetManager(rootCdpSession);
 
     /**
      * Reemit the same network recorder events.

package/lighthouse-core/gather/driver/target-manager.js

@@ -11,21 +11,23 @@
   */
 
 const log = require('lighthouse-logger');
+const ProtocolSession = require('../../fraggle-rock/gather/session.js');
 
 /** @typedef {{target: LH.Crdp.Target.TargetInfo, session: LH.Gatherer.FRProtocolSession}} TargetWithSession */
 
 class TargetManager {
-  /** @param {LH.Gatherer.FRProtocolSession} session */
-  constructor(session) {
+  /** @param {LH.Puppeteer.CDPSession} cdpSession */
+  constructor(cdpSession) {
     this._enabled = false;
-    this._session = session;
+    this._rootCdpSession = cdpSession;
+
     /** @type {Array<(targetWithSession: TargetWithSession) => Promise<void>|void>} */
     this._listeners = [];
 
     this._onSessionAttached = this._onSessionAttached.bind(this);
 
     /** @type {Map<string, TargetWithSession>} */
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
 
     /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
     this._onFrameNavigated = async event => {
@@ -35,7 +37,7 @@ class TargetManager {
       // It's not entirely clear when this is necessary, but when the page switches processes on
       // navigating from about:blank to the `requestedUrl`, resetting `setAutoAttach` has been
       // necessary in the past.
-      await this._session.sendCommand('Target.setAutoAttach', {
+      await this._rootCdpSession.send('Target.setAutoAttach', {
         autoAttach: true,
         flatten: true,
         waitForDebuggerOnStart: true,
@@ -44,9 +46,11 @@ class TargetManager {
   }
 
   /**
-   * @param {LH.Gatherer.FRProtocolSession} session
+   * @param {LH.Puppeteer.CDPSession} cdpSession
    */
-  async _onSessionAttached(session) {
+  async _onSessionAttached(cdpSession) {
+    const session = new ProtocolSession(cdpSession);
+
     try {
       const target = await session.sendCommand('Target.getTargetInfo').catch(() => null);
       const targetType = target?.targetInfo?.type;
@@ -55,13 +59,13 @@ class TargetManager {
 
       const targetId = target.targetInfo.targetId;
       session.setTargetInfo(target.targetInfo);
-      if (this._targets.has(targetId)) return;
+      if (this._targetIdToTargets.has(targetId)) return;
 
       const targetName = target.targetInfo.url || target.targetInfo.targetId;
       log.verbose('target-manager', `target ${targetName} attached`);
 
       const targetWithSession = {target: target.targetInfo, session};
-      this._targets.set(targetId, targetWithSession);
+      this._targetIdToTargets.set(targetId, targetWithSession);
       for (const listener of this._listeners) await listener(targetWithSession);
 
       await session.sendCommand('Target.setAutoAttach', {
@@ -87,24 +91,32 @@ class TargetManager {
     if (this._enabled) return;
 
     this._enabled = true;
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
+
+    this._rootCdpSession.on('Page.frameNavigated', this._onFrameNavigated);
+
+    const rootConnection = this._rootCdpSession.connection();
+    if (!rootConnection) {
+      throw new Error('Connection has been closed.');
+    }
+    rootConnection.on('sessionattached', this._onSessionAttached);
 
-    this._session.on('Page.frameNavigated', this._onFrameNavigated);
-    this._session.addSessionAttachedListener(this._onSessionAttached);
+    await this._rootCdpSession.send('Page.enable');
 
-    await this._session.sendCommand('Page.enable');
-    await this._onSessionAttached(this._session);
+    // Start with the already attached root session.
+    await this._onSessionAttached(this._rootCdpSession);
   }
 
   /**
    * @return {Promise<void>}
    */
   async disable() {
-    this._session.off('Page.frameNavigated', this._onFrameNavigated);
-    this._session.removeSessionAttachedListener(this._onSessionAttached);
+    this._rootCdpSession.off('Page.frameNavigated', this._onFrameNavigated);
+    // No need to remove listener if connection is already closed.
+    this._rootCdpSession.connection()?.off('sessionattached', this._onSessionAttached);
 
     this._enabled = false;
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
   }
 
   /**

package/lighthouse-core/gather/driver.js

@@ -12,7 +12,7 @@ const {fetchResponseBodyFromCache} = require('../gather/driver/network.js');
 const EventEmitter = require('events').EventEmitter;
 
 const log = require('lighthouse-logger');
-const DevtoolsLog = require('./devtools-log.js');
+const DevtoolsMessageLog = require('./gatherers/devtools-log.js').DevtoolsMessageLog;
 const TraceGatherer = require('./gatherers/trace.js');
 
 // Pulled in for Connection type checking.
@@ -41,7 +41,7 @@ class Driver {
    * @private
    * Used to save network and lifecycle protocol traffic. Just Page and Network are needed.
    */
-  _devtoolsLog = new DevtoolsLog(/^(Page|Network)\./);
+  _devtoolsLog = new DevtoolsMessageLog(/^(Page|Network)\./);
 
   /**
    * @private
@@ -208,16 +208,6 @@ class Driver {
     // OOPIF handling in legacy driver is implicit.
   }
 
-  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
-  addSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
-    // OOPIF handling in legacy driver is implicit.
-  }
-
-  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
-  removeSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
-    // OOPIF handling in legacy driver is implicit.
-  }
-
   /**
    * Debounce enabling or disabling domains to prevent driver users from
    * stomping on each other. Maintains an internal count of the times a domain

package/lighthouse-core/gather/gatherers/devtools-log.js

@@ -12,7 +12,6 @@
  */
 
 const NetworkMonitor = require('../driver/network-monitor.js');
-const MessageLog = require('../devtools-log.js');
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 
 class DevtoolsLog extends FRGatherer {
@@ -30,7 +29,7 @@ class DevtoolsLog extends FRGatherer {
     /** @type {NetworkMonitor|undefined} */
     this._networkMonitor = undefined;
 
-    this._messageLog = new MessageLog(/^(Page|Network|Target|Runtime)\./);
+    this._messageLog = new DevtoolsMessageLog(/^(Page|Network|Target|Runtime)\./);
 
     /** @param {LH.Protocol.RawEventMessage} e */
     this._onProtocolMessage = e => this._messageLog.record(e);
@@ -63,4 +62,59 @@ class DevtoolsLog extends FRGatherer {
   }
 }
 
+
+/**
+ * This class saves all protocol messages whose method match a particular
+ * regex filter. Used when saving assets for later analysis by another tool such as
+ * Webpagetest.
+ */
+class DevtoolsMessageLog {
+  /**
+   * @param {RegExp=} regexFilter
+   */
+  constructor(regexFilter) {
+    this._filter = regexFilter;
+
+    /** @type {LH.DevtoolsLog} */
+    this._messages = [];
+    this._isRecording = false;
+  }
+
+  /**
+   * @return {LH.DevtoolsLog}
+   */
+  get messages() {
+    return this._messages;
+  }
+
+  reset() {
+    this._messages = [];
+  }
+
+  beginRecording() {
+    this._isRecording = true;
+  }
+
+  endRecording() {
+    this._isRecording = false;
+  }
+
+  /**
+   * Records a message if method matches filter and recording has been started.
+   * @param {LH.Protocol.RawEventMessage} message
+   */
+  record(message) {
+    // We're not recording, skip the rest of the checks.
+    if (!this._isRecording) return;
+    // The event was likely an internal puppeteer method that uses Symbols.
+    if (typeof message.method !== 'string') return;
+    // The event didn't pass our filter, do not record it.
+    if (this._filter && !this._filter.test(message.method)) return;
+
+    // We passed all the checks, record the message.
+    this._messages.push(message);
+  }
+}
+
 module.exports = DevtoolsLog;
+module.exports.DevtoolsMessageLog = DevtoolsMessageLog;

package/lighthouse-core/index.js

@@ -64,7 +64,7 @@ async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
   flags.logLevel = flags.logLevel || 'error';
   log.setLevel(flags.logLevel);
 
-  const config = generateConfig(configJSON, flags);
+  const config = await generateConfig(configJSON, flags);
   const computedCache = new Map();
   const options = {config, computedCache};
   const connection = userConnection || new ChromeProtocol(flags.port, flags.hostname);
@@ -83,10 +83,10 @@ async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
  *   not present, the default config is used.
  * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
  *   they will override any settings in the config.
- * @return {Config}
+ * @return {Promise<Config>}
  */
 function generateConfig(configJson, flags) {
-  return new Config(configJson, flags);
+  return Config.fromJson(configJson, flags);
 }
 
 lighthouse.legacyNavigation = legacyNavigation;

package/lighthouse-core/lib/asset-saver.js

@@ -288,10 +288,9 @@ async function saveAssets(artifacts, audits, pathWithBasename) {
     fs.writeFileSync(devtoolsLogFilename, JSON.stringify(passAssets.devtoolsLog, null, 2));
     log.log('saveAssets', 'devtools log saved to disk: ' + devtoolsLogFilename);
 
-    const streamTraceFilename = `${pathWithBasename}-${index}${traceSuffix}`;
-    log.log('saveAssets', 'streaming trace file to disk: ' + streamTraceFilename);
-    await saveTrace(passAssets.traceData, streamTraceFilename);
-    log.log('saveAssets', 'trace file streamed to disk: ' + streamTraceFilename);
+    const traceFilename = `${pathWithBasename}-${index}${traceSuffix}`;
+    await saveTrace(passAssets.traceData, traceFilename);
+    log.log('saveAssets', 'trace file streamed to disk: ' + traceFilename);
   });
 
   await Promise.all(saveAll);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse",
-  "version": "9.5.0-dev.20220608",
+  "version": "9.5.0-dev.20220611",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./lighthouse-core/index.js",
   "bin": {
@@ -125,8 +125,8 @@
     "@types/ws": "^7.0.0",
     "@types/yargs": "^17.0.8",
     "@types/yargs-parser": "^20.2.1",
-    "@typescript-eslint/eslint-plugin": "^5.26.0",
-    "@typescript-eslint/parser": "^5.26.0",
+    "@typescript-eslint/eslint-plugin": "^5.27.1",
+    "@typescript-eslint/parser": "^5.27.1",
     "acorn": "^8.5.0",
     "angular": "^1.7.4",
     "archiver": "^3.0.0",
@@ -175,7 +175,7 @@
     "terser": "^5.3.8",
     "ts-jest": "^27.0.4",
     "typed-query-selector": "^2.6.1",
-    "typescript": "^4.7.2",
+    "typescript": "^4.7.3",
     "wait-for-expect": "^3.0.2",
     "webtreemap-cdt": "^3.2.1"
   },

package/tsconfig-base.json

@@ -12,7 +12,7 @@
     "rootDir": ".",
 
     "target": "es2020",
-    "module": "es2020",
+    "module": "es2022",
     "moduleResolution": "node",
     "esModuleInterop": true,
 

package/tsconfig.json

@@ -30,6 +30,7 @@
     "third-party/snyk/snapshot.json",
     "lighthouse-core/audits/byte-efficiency/polyfill-graph-data.json",
     "shared/localization/locales/en-US.json",
+    "esm-utils.mjs",
   ],
   "exclude": [
     "lighthouse-core/test/audits/**/*.js",
@@ -46,11 +47,11 @@
     "lighthouse-core/test/config/config-test.js",
     "lighthouse-core/test/config/default-config-test.js",
     "lighthouse-core/test/create-test-trace.js",
-    "lighthouse-core/test/gather/devtools-log-test.js",
     "lighthouse-core/test/gather/driver/wait-for-condition-test.js",
     "lighthouse-core/test/gather/gatherers/accessibility-test.js",
     "lighthouse-core/test/gather/gatherers/cache-contents-test.js",
     "lighthouse-core/test/gather/gatherers/console-messages-test.js",
+    "lighthouse-core/test/gather/gatherers/devtools-log-test.js",
     "lighthouse-core/test/gather/gatherers/dobetterweb/optimized-images-test.js",
     "lighthouse-core/test/gather/gatherers/dobetterweb/password-inputs-with-prevented-paste-test.js",
     "lighthouse-core/test/gather/gatherers/dobetterweb/response-compression-test.js",

package/types/gatherer.d.ts

@@ -30,8 +30,6 @@ declare module Gatherer {
     once<TEvent extends keyof LH.CrdpEvents>(event: TEvent, callback: (...args: LH.CrdpEvents[TEvent]) => void): void;
     addProtocolMessageListener(callback: (payload: Protocol.RawEventMessage) => void): void
     removeProtocolMessageListener(callback: (payload: Protocol.RawEventMessage) => void): void
-    addSessionAttachedListener(callback: (session: FRProtocolSession) => void): void
-    removeSessionAttachedListener(callback: (session: FRProtocolSession) => void): void
     off<TEvent extends keyof LH.CrdpEvents>(event: TEvent, callback: (...args: LH.CrdpEvents[TEvent]) => void): void;
     sendCommand<TMethod extends keyof LH.CrdpCommands>(method: TMethod, ...params: LH.CrdpCommands[TMethod]['paramsType']): Promise<LH.CrdpCommands[TMethod]['returnType']>;
     dispose(): Promise<void>;

package/lighthouse-core/gather/devtools-log.js

@@ -1,61 +0,0 @@
-/**
- * @license Copyright 2017 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';
-
-/**
- * @fileoverview This class saves all protocol messages whose method match a particular
- *    regex filter. Used when saving assets for later analysis by another tool such as
- *    Webpagetest.
- */
-class DevtoolsLog {
-  /**
-   * @param {RegExp=} regexFilter
-   */
-  constructor(regexFilter) {
-    this._filter = regexFilter;
-
-    /** @type {LH.DevtoolsLog} */
-    this._messages = [];
-    this._isRecording = false;
-  }
-
-  /**
-   * @return {LH.DevtoolsLog}
-   */
-  get messages() {
-    return this._messages;
-  }
-
-  reset() {
-    this._messages = [];
-  }
-
-  beginRecording() {
-    this._isRecording = true;
-  }
-
-  endRecording() {
-    this._isRecording = false;
-  }
-
-  /**
-   * Records a message if method matches filter and recording has been started.
-   * @param {LH.Protocol.RawEventMessage} message
-   */
-  record(message) {
-    // We're not recording, skip the rest of the checks.
-    if (!this._isRecording) return;
-    // The event was likely an internal puppeteer method that uses Symbols.
-    if (typeof message.method !== 'string') return;
-    // The event didn't pass our filter, do not record it.
-    if (this._filter && !this._filter.test(message.method)) return;
-
-    // We passed all the checks, record the message.
-    this._messages.push(message);
-  }
-}
-
-module.exports = DevtoolsLog;