lighthouse 9.5.0-dev.20220424 → 9.5.0-dev.20220427

package/lighthouse-cli/cli-flags.js

@@ -177,7 +177,7 @@ function getFlags(manualArgv, options = {}) {
         },
         'enable-error-reporting': {
           type: 'boolean',
-          describe: 'Enables error reporting, overriding any saved preference. --no-enable-error-reporting will do the opposite. More: https://git.io/vFFTO',
+          describe: 'Enables error reporting, overriding any saved preference. --no-enable-error-reporting will do the opposite. More: https://github.com/GoogleChrome/lighthouse/blob/master/docs/error-reporting.md',
         },
         'gather-mode': {
           alias: 'G',

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

@@ -12,13 +12,11 @@
 
 /* eslint-disable no-console */
 
-import _ from 'lodash';
+import cloneDeep from 'lodash/cloneDeep.js';
 
 import smokeTests from '../core-tests.js';
 import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 
-const {cloneDeep} = _;
-
 /**
  * @param {Smokehouse.SmokehouseLibOptions} options
  */

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

@@ -16,7 +16,7 @@ import path from 'path';
 import fs from 'fs';
 import url from 'url';
 
-import _ from 'lodash';
+import cloneDeep from 'lodash/cloneDeep.js';
 import yargs from 'yargs';
 import * as yargsHelpers from 'yargs/helpers';
 import log from 'lighthouse-logger';
@@ -25,8 +25,6 @@ import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../root.js';
 
-const {cloneDeep} = _;
-
 const coreTestDefnsPath =
   path.join(LH_ROOT, 'lighthouse-cli/test/smokehouse/core-tests.js');
 

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

@@ -9,14 +9,12 @@
  * against the results actually collected from Lighthouse.
  */
 
-import _ from 'lodash';
+import cloneDeep from 'lodash/cloneDeep.js';
 import log from 'lighthouse-logger';
 
 import {LocalConsole} from './lib/local-console.js';
 import {chromiumVersionCheck} from './version-check.js';
 
-const {cloneDeep} = _;
-
 /**
  * @typedef Difference
  * @property {string} path

package/lighthouse-core/audits/deprecations.js

@@ -7,12 +7,8 @@
 
 /**
  * @fileoverview Audits a page to determine if it is calling deprecated APIs.
- * This is done by collecting console log messages and filtering them by ones
- * that contain deprecated API warnings sent by Chrome.
  */
 
-// TODO: when M97 is sufficiently old, drop support for console messages
-
 const Audit = require('./audit.js');
 const JsBundles = require('../computed/js-bundles.js');
 const i18n = require('../lib/i18n/i18n.js');
@@ -48,7 +44,7 @@ class Deprecations extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      requiredArtifacts: ['ConsoleMessages', 'InspectorIssues', 'SourceMaps', 'Scripts'],
+      requiredArtifacts: ['InspectorIssues', 'SourceMaps', 'Scripts'],
     };
   }
 
@@ -58,36 +54,21 @@ class Deprecations extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
-    const entries = artifacts.ConsoleMessages;
     const bundles = await JsBundles.request(artifacts, context);
 
-    let deprecations;
-    if (artifacts.InspectorIssues.deprecationIssue.length) {
-      deprecations = artifacts.InspectorIssues.deprecationIssue
-        // TODO: translate these strings.
-        // see https://github.com/GoogleChrome/lighthouse/issues/13895
-        // @ts-expect-error: .type hasn't released to npm yet
-        .filter(deprecation => !deprecation.type || deprecation.type === 'Untranslated')
-        .map(deprecation => {
-          const {scriptId, url, lineNumber, columnNumber} = deprecation.sourceCodeLocation;
-          const bundle = bundles.find(bundle => bundle.script.scriptId === scriptId);
-          return {
-            value: deprecation.message || '',
-            // Protocol.Audits.SourceCodeLocation.columnNumber is 1-indexed, but we use 0-indexed.
-            source: Audit.makeSourceLocation(url, lineNumber, columnNumber - 1, bundle),
-          };
-        });
-    } else {
-      // Backcompat for <M97.
-      // https://bugs.chromium.org/p/chromium/issues/detail?id=1248484
-      deprecations = entries.filter(log => log.source === 'deprecation')
-        .map(log => {
-          return {
-            value: log.text,
-            source: Audit.makeSourceLocationFromConsoleMessage(log),
-          };
-        });
-    }
+    const deprecations = artifacts.InspectorIssues.deprecationIssue
+      // TODO: translate these strings.
+      // see https://github.com/GoogleChrome/lighthouse/issues/13895
+      .filter(deprecation => !deprecation.type || deprecation.type === 'Untranslated')
+      .map(deprecation => {
+        const {scriptId, url, lineNumber, columnNumber} = deprecation.sourceCodeLocation;
+        const bundle = bundles.find(bundle => bundle.script.scriptId === scriptId);
+        return {
+          value: deprecation.message || '',
+          // Protocol.Audits.SourceCodeLocation.columnNumber is 1-indexed, but we use 0-indexed.
+          source: Audit.makeSourceLocation(url, lineNumber, columnNumber - 1, bundle),
+        };
+      });
 
     /** @type {LH.Audit.Details.Table['headings']} */
     const headings = [

package/lighthouse-core/audits/dobetterweb/doctype.js

@@ -19,12 +19,14 @@ const UIStrings = {
     '[Learn more](https://web.dev/doctype/).',
   /** Explanatory message stating that the document has no doctype. */
   explanationNoDoctype: 'Document must contain a doctype',
+  /** Explanatory message stating that the document has wrong doctype */
+  explanationWrongDoctype: 'Document contains a doctype that triggers quirks-mode',
   /** Explanatory message stating that the publicId field is not empty. */
   explanationPublicId: 'Expected publicId to be an empty string',
   /** Explanatory message stating that the systemId field is not empty. */
   explanationSystemId: 'Expected systemId to be an empty string',
   /** Explanatory message stating that the doctype is set, but is not "html" and is therefore invalid. */
-  explanationBadDoctype: 'Doctype name must be the lowercase string `html`',
+  explanationBadDoctype: 'Doctype name must be the string `html`',
 };
 
 const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
@@ -56,9 +58,10 @@ class Doctype extends Audit {
     }
 
     // only set constants once we know there is a doctype
-    const doctypeName = artifacts.Doctype.name.trim();
+    const doctypeName = artifacts.Doctype.name;
     const doctypePublicId = artifacts.Doctype.publicId;
     const doctypeSystemId = artifacts.Doctype.systemId;
+    const compatMode = artifacts.Doctype.documentCompatMode;
 
     if (doctypePublicId !== '') {
       return {
@@ -74,17 +77,25 @@ class Doctype extends Audit {
       };
     }
 
-    /* Note that the value for name is case sensitive,
-       and must be the string `html`. For details see:
-       https://html.spec.whatwg.org/multipage/parsing.html#the-initial-insertion-mode */
-    if (doctypeName === 'html') {
+    /* Note that the casing of this property is normalized to be lowercase.
+       see: https://html.spec.whatwg.org/#doctype-name-state */
+    if (doctypeName !== 'html') {
       return {
-        score: 1,
+        score: 0,
+        explanation: str_(UIStrings.explanationBadDoctype),
       };
-    } else {
+    }
+
+    // Catch-all for any quirks-mode situations the above checks didn't get.
+    // https://github.com/GoogleChrome/lighthouse/issues/10030
+    if (compatMode === 'BackCompat') {
       return {
         score: 0,
-        explanation: str_(UIStrings.explanationBadDoctype),
+        explanation: str_(UIStrings.explanationWrongDoctype),
+      };
+    } else {
+      return {
+        score: 1,
       };
     }
   }

package/lighthouse-core/audits/metrics/experimental-interaction-to-next-paint.js

@@ -0,0 +1,84 @@
+/**
+ * @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';
+
+const Audit = require('../audit.js');
+const ComputedResponsivenes = require('../../computed/metrics/responsiveness.js');
+const i18n = require('../../lib/i18n/i18n.js');
+
+const UIStrings = {
+  /** Description of the Interaction to Next Paint metric. This description is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
+  description: 'Interaction to Next Paint measures page responsiveness, how long it ' +
+               'takes the page to visibly respond to user input. [Learn more](https://web.dev/inp/).',
+};
+
+const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
+
+/**
+ * @fileoverview This metric gives a high-percentile measure of responsiveness to input.
+ */
+class ExperimentalInteractionToNextPaint extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'experimental-interaction-to-next-paint',
+      title: str_(i18n.UIStrings.interactionToNextPaint),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['timespan'],
+      requiredArtifacts: ['traces'],
+    };
+  }
+
+  /**
+   * @return {LH.Audit.ScoreOptions}
+   */
+  static get defaultOptions() {
+    return {
+      // https://web.dev/inp/
+      // This is using the same threshold as field tools since only supported in
+      // unsimulated user flows for now.
+      // see https://www.desmos.com/calculator/4xtrhg51th
+      p10: 200,
+      median: 500,
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const {settings} = context;
+    // TODO: responsiveness isn't yet supported by lantern.
+    if (settings.throttlingMethod === 'simulate') {
+      return {score: null, notApplicable: true};
+    }
+
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const metricData = {trace, settings};
+    const metricResult = await ComputedResponsivenes.request(metricData, context);
+
+    // TODO: include the no-interaction state in the report instead of using n/a.
+    if (metricResult === null) {
+      return {score: null, notApplicable: true};
+    }
+
+    return {
+      score: Audit.computeLogNormalScore({p10: context.options.p10, median: context.options.median},
+        metricResult.timing),
+      numericValue: metricResult.timing,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: metricResult.timing}),
+    };
+  }
+}
+
+module.exports = ExperimentalInteractionToNextPaint;
+module.exports.UIStrings = UIStrings;

package/lighthouse-core/computed/metrics/responsiveness.js

@@ -0,0 +1,64 @@
+/**
+ * @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';
+
+/**
+ * @fileoverview Returns a high-percentle (usually 98th) measure of how long it
+ * takes the page to visibly respond to user input (or null, if there was no
+ * user input in the provided trace).
+ */
+
+const makeComputedArtifact = require('../computed-artifact.js');
+const ProcessedTrace = require('../processed-trace.js');
+
+class Responsiveness {
+  /**
+   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @return {{timing: number}|null}
+   */
+  static getHighPercentileResponsiveness(processedTrace) {
+    const durations = processedTrace.frameTreeEvents
+      // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/timing/responsiveness_metrics.cc;l=146-150;drc=a1a2302f30b0a58f7669a41c80acdf1fa11958dd
+      .filter(e => e.name === 'Responsiveness.Renderer.UserInteraction')
+      .map(evt => evt.args.data?.maxDuration)
+      .filter(/** @return {duration is number} */duration => duration !== undefined)
+      .sort((a, b) => b - a);
+
+    // If there were no interactions with the page, the metric is N/A.
+    if (durations.length === 0) {
+      return null;
+    }
+
+    // INP is the "nearest-rank"/inverted_cdf 98th percentile, except Chrome only
+    // keeps the 10 worst events around, so it can never be more than the 10th from
+    // last array element. To keep things simpler, sort desc and pick from front.
+    // See https://source.chromium.org/chromium/chromium/src/+/main:components/page_load_metrics/browser/responsiveness_metrics_normalization.cc;l=45-59;drc=cb0f9c8b559d9c7c3cb4ca94fc1118cc015d38ad
+    const index = Math.min(9, Math.floor(durations.length / 50));
+
+    return {
+      timing: durations[index],
+    };
+  }
+
+  /**
+   * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.Metric|null>}
+   */
+  static async compute_(data, context) {
+    if (data.settings.throttlingMethod === 'simulate') {
+      throw new Error('Responsiveness currently unsupported by simulated throttling');
+    }
+
+    const processedTrace = await ProcessedTrace.request(data.trace, context);
+    return Responsiveness.getHighPercentileResponsiveness(processedTrace);
+  }
+}
+
+module.exports = makeComputedArtifact(Responsiveness, [
+  'trace',
+  'settings',
+]);

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

@@ -6,7 +6,7 @@
 'use strict';
 
 const path = require('path');
-const {isEqual: isDeepEqual} = require('lodash');
+const isDeepEqual = require('lodash/isEqual.js');
 const constants = require('./constants.js');
 const Budget = require('./budget.js');
 const ConfigPlugin = require('./config-plugin.js');

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

@@ -11,12 +11,14 @@ const {deepClone} = require('../../config/config-helpers.js');
 /** @type {LH.Config.AuditJson[]} */
 const frAudits = [
   'byte-efficiency/uses-responsive-images-snapshot',
+  'metrics/experimental-interaction-to-next-paint',
 ];
 
 /** @type {Record<string, LH.Config.AuditRefJson[]>} */
 const frCategoryAuditRefExtensions = {
   'performance': [
     {id: 'uses-responsive-images-snapshot', weight: 0},
+    {id: 'experimental-interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP'},
   ],
 };
 

package/lighthouse-core/fraggle-rock/gather/base-artifacts.js

@@ -6,7 +6,7 @@
 'use strict';
 
 const log = require('lighthouse-logger');
-const {isEqual} = require('lodash');
+const isDeepEqual = require('lodash/isEqual.js');
 const {
   getBrowserVersion,
   getBenchmarkIndex,
@@ -61,7 +61,7 @@ function deduplicateWarnings(warnings) {
   const unique = [];
 
   for (const warning of warnings) {
-    if (unique.some(existing => isEqual(warning, existing))) continue;
+    if (unique.some(existing => isDeepEqual(warning, existing))) continue;
     unique.push(warning);
   }
 

package/lighthouse-core/gather/gatherers/accessibility.js

@@ -12,9 +12,6 @@ const axeLibSource = require('../../lib/axe.js').source;
 const pageFunctions = require('../../lib/page-functions.js');
 
 /**
- * This is run in the page, not Lighthouse itself.
- * axe.run returns a promise which fulfills with a results object
- * containing any violations.
  * @return {Promise<LH.Artifacts.Accessibility>}
  */
 /* c8 ignore start */
@@ -38,8 +35,11 @@ async function runA11yChecks() {
         'wcag2aa',
       ],
     },
+    // resultTypes doesn't limit the output of the axeResults object. Instead, if it's defined,
+    // some expensive element identification is done only for the respective types. https://github.com/dequelabs/axe-core/blob/f62f0cf18f7b69b247b0b6362cf1ae71ffbf3a1b/lib/core/reporters/helpers/process-aggregate.js#L61-L97
     resultTypes: ['violations', 'inapplicable'],
     rules: {
+      // Consider http://go/prcpg for expert review of the aXe rules.
       'tabindex': {enabled: true},
       'accesskeys': {enabled: true},
       'heading-order': {enabled: true},
@@ -60,6 +60,12 @@ async function runA11yChecks() {
       // https://github.com/dequelabs/axe-core/issues/2958
       'nested-interactive': {enabled: false},
       'frame-focusable-content': {enabled: false},
+      'aria-roledescription': {enabled: false},
+      'scrollable-region-focusable': {enabled: false},
+      // TODO(paulirish): create audits and enable these 3.
+      'input-button-name': {enabled: false},
+      'role-img-alt': {enabled: false},
+      'select-name': {enabled: false},
     },
   });
 
@@ -70,7 +76,8 @@ async function runA11yChecks() {
   return {
     violations: axeResults.violations.map(createAxeRuleResultArtifact),
     incomplete: axeResults.incomplete.map(createAxeRuleResultArtifact),
-    notApplicable: axeResults.inapplicable.map(result => ({id: result.id})),
+    notApplicable: axeResults.inapplicable.map(result => ({id: result.id})), // FYI: inapplicable => notApplicable!
+    passes: axeResults.passes.map(result => ({id: result.id})),
     version: axeResults.testEngine.version,
   };
 }
@@ -150,6 +157,11 @@ class Accessibility extends FRGatherer {
     supportedModes: ['snapshot', 'navigation'],
   };
 
+  static pageFns = {
+    runA11yChecks,
+    createAxeRuleResultArtifact,
+  };
+
   /**
    * @param {LH.Gatherer.FRTransitionalContext} passContext
    * @return {Promise<LH.Artifacts.Accessibility>}

package/lighthouse-core/gather/gatherers/dobetterweb/doctype.js

@@ -12,7 +12,8 @@ const FRGatherer = require('../../../fraggle-rock/gather/base-gatherer.js');
 /**
  * Get and return `name`, `publicId`, `systemId` from
  * `document.doctype`
- * @return {{name: string, publicId: string, systemId: string} | null}
+ * and `compatMode` from `document` to check `quirks-mode`
+ * @return {{name: string, publicId: string, systemId: string, documentCompatMode: string} | null}
  */
 function getDoctype() {
   // An example of this is warnerbros.com/archive/spacejam/movie/jam.htm
@@ -20,8 +21,9 @@ function getDoctype() {
     return null;
   }
 
+  const documentCompatMode = document.compatMode;
   const {name, publicId, systemId} = document.doctype;
-  return {name, publicId, systemId};
+  return {name, publicId, systemId, documentCompatMode};
 }
 
 class Doctype extends FRGatherer {

package/lighthouse-core/lib/arbitrary-equality-map.js

@@ -5,7 +5,7 @@
  */
 'use strict';
 
-const {isEqual} = require('lodash');
+const isDeepEqual = require('lodash/isEqual.js');
 
 /**
  * @fileoverview This class is designed to allow maps with arbitrary equality functions.
@@ -74,7 +74,7 @@ class ArbitraryEqualityMap {
    * @return {boolean}
    */
   static deepEquals(objA, objB) {
-    return isEqual(objA, objB);
+    return isDeepEqual(objA, objB);
   }
 }
 

package/lighthouse-core/lib/i18n/i18n.js

@@ -105,6 +105,8 @@ const UIStrings = {
   largestContentfulPaintMetric: 'Largest Contentful Paint',
   /** The name of the metric "Cumulative Layout Shift" that indicates how much the page changes its layout while it loads. If big segments of the page shift their location during load, the Cumulative Layout Shift will be higher. Shown to users as the label for the numeric metric value. Ideally fits within a ~40 character limit. */
   cumulativeLayoutShiftMetric: 'Cumulative Layout Shift',
+  /** The name of the "Interaction to Next Paint" metric that measures the time between a user interaction and when the browser displays a response on screen. Shown to users as the label for the numeric metric value. Ideally fits within a ~40 character limit. */
+  interactionToNextPaint: 'Interaction to Next Paint',
   /** Table item value for the severity of a small, or low impact vulnerability. Part of a ranking scale in the form: low, medium, high. */
   itemSeverityLow: 'Low',
   /** Table item value for the severity of a vulnerability. Part of a ranking scale in the form: low, medium, high. */

package/lighthouse-core/lib/minify-trace.js

@@ -44,6 +44,8 @@ const traceEventsToAlwaysKeep = new Set([
   'EventDispatch',
   'LayoutShift',
   'FrameCommittedInBrowser',
+  'EventTiming',
+  'Responsiveness.Renderer.UserInteraction',
   // Not currently used by Lighthouse but might be used in the future for cross-frame LCP
   'NavStartToLargestContentfulPaint::Invalidate::AllFrames::UKM',
   'NavStartToLargestContentfulPaint::Candidate::AllFrames::UKM',

package/lighthouse-core/lib/tracehouse/trace-processor.js

@@ -612,39 +612,59 @@ class TraceProcessor {
     // Find the inspected frame
     const mainFrameIds = this.findMainFrameIds(keyEvents);
 
-    const frames = keyEvents
+    /** @type {Map<string, {id: string, url: string, parent?: string}>} */
+    const framesById = new Map();
+
+    // Begin collection of frame tree information with TracingStartedInBrowser,
+    // which should be present even without navigations.
+    const tracingStartedFrames = keyEvents
+        .find(e => e.name === 'TracingStartedInBrowser')?.args?.data?.frames;
+    if (tracingStartedFrames) {
+      for (const frame of tracingStartedFrames) {
+        framesById.set(frame.frame, {
+          id: frame.frame,
+          url: frame.url,
+          parent: frame.parent,
+        });
+      }
+    }
+
+    // Update known frames if FrameCommittedInBrowser events come in, typically
+    // with updated `url`, as well as pid, etc. Some traces (like timespans) may
+    // not have any committed frames.
+    keyEvents
       .filter(/** @return {evt is FrameCommittedEvent} */ evt => {
         return Boolean(
           evt.name === 'FrameCommittedInBrowser' &&
           evt.args.data?.frame &&
           evt.args.data.url
         );
-      })
-      .map(evt => {
-        return {
+      }).forEach(evt => {
+        framesById.set(evt.args.data.frame, {
           id: evt.args.data.frame,
           url: evt.args.data.url,
           parent: evt.args.data.parent,
-        };
+        });
       });
+    const frames = [...framesById.values()];
     const frameIdToRootFrameId = this.resolveRootFrames(frames);
 
     // Filter to just events matching the main frame ID, just to make sure.
     const frameEvents = keyEvents.filter(e => e.args.frame === mainFrameIds.frameId);
 
     // Filter to just events matching the main frame ID or any child frame IDs.
-    // In practice, there should always be FrameCommittedInBrowser events to define the frame tree.
-    // Unfortunately, many test traces do not include FrameCommittedInBrowser events due to minification.
-    // This ensures there is always a minimal frame tree and events so those tests don't fail.
     let frameTreeEvents = [];
     if (frameIdToRootFrameId.has(mainFrameIds.frameId)) {
       frameTreeEvents = keyEvents.filter(e => {
         return e.args.frame && frameIdToRootFrameId.get(e.args.frame) === mainFrameIds.frameId;
       });
     } else {
+      // In practice, there should always be TracingStartedInBrowser/FrameCommittedInBrowser events to
+      // define the frame tree. Unfortunately, many test traces do not that frame info due to minification.
+      // This ensures there is always a minimal frame tree and events so those tests don't fail.
       log.warn(
         'trace-of-tab',
-        'frameTreeEvents may be incomplete, make sure the trace has FrameCommittedInBrowser events'
+        'frameTreeEvents may be incomplete, make sure the trace has frame events'
       );
       frameIdToRootFrameId.set(mainFrameIds.frameId, mainFrameIds.frameId);
       frameTreeEvents = frameEvents;

package/lighthouse-core/runner.js

@@ -5,7 +5,7 @@
  */
 'use strict';
 
-const {isEqual: isDeepEqual} = require('lodash');
+const isDeepEqual = require('lodash/isEqual.js');
 const Driver = require('./gather/driver.js');
 const GatherRunner = require('./gather/gather-runner.js');
 const ReportScoring = require('./scoring.js');

package/lighthouse-core/util-commonjs.js

@@ -433,11 +433,9 @@ class Util {
         break;
       case 'devtools': {
         const {cpuSlowdownMultiplier, requestLatencyMs} = throttling;
-        // TODO: better api in i18n formatter such that this isn't needed.
-        const cpuGranularity = Number.isInteger(cpuSlowdownMultiplier) ? 1 : 0.1;
         // eslint-disable-next-line max-len
-        cpuThrottling = `${Util.i18n.formatNumber(cpuSlowdownMultiplier, cpuGranularity)}x slowdown (DevTools)`;
-        networkThrottling = `${Util.i18n.formatMilliseconds(requestLatencyMs, 1)} HTTP RTT, ` +
+        cpuThrottling = `${Util.i18n.formatNumber(cpuSlowdownMultiplier)}x slowdown (DevTools)`;
+        networkThrottling = `${Util.i18n.formatMilliseconds(requestLatencyMs)} HTTP RTT, ` +
           `${Util.i18n.formatKbps(throttling.downloadThroughputKbps)} down, ` +
           `${Util.i18n.formatKbps(throttling.uploadThroughputKbps)} up (DevTools)`;
 
@@ -451,10 +449,8 @@ class Util {
       }
       case 'simulate': {
         const {cpuSlowdownMultiplier, rttMs, throughputKbps} = throttling;
-        // TODO: better api in i18n formatter such that this isn't needed.
-        const cpuGranularity = Number.isInteger(cpuSlowdownMultiplier) ? 1 : 0.1;
         // eslint-disable-next-line max-len
-        cpuThrottling = `${Util.i18n.formatNumber(cpuSlowdownMultiplier, cpuGranularity)}x slowdown (Simulated)`;
+        cpuThrottling = `${Util.i18n.formatNumber(cpuSlowdownMultiplier)}x slowdown (Simulated)`;
         networkThrottling = `${Util.i18n.formatMilliseconds(rttMs)} TCP RTT, ` +
           `${Util.i18n.formatKbps(throughputKbps)} throughput (Simulated)`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse",
-  "version": "9.5.0-dev.20220424",
+  "version": "9.5.0-dev.20220427",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./lighthouse-core/index.js",
   "bin": {
@@ -139,7 +139,7 @@
     "cpy": "^8.1.2",
     "cross-env": "^7.0.2",
     "csv-validator": "^0.0.3",
-    "devtools-protocol": "0.0.975298",
+    "devtools-protocol": "0.0.995287",
     "es-main": "^1.0.2",
     "eslint": "^8.4.1",
     "eslint-config-google": "^0.14.0",
@@ -210,8 +210,8 @@
     "yargs-parser": "^21.0.0"
   },
   "resolutions": {
-    "puppeteer/**/devtools-protocol": "0.0.975298",
-    "puppeteer-core/**/devtools-protocol": "0.0.975298"
+    "puppeteer/**/devtools-protocol": "0.0.995287",
+    "puppeteer-core/**/devtools-protocol": "0.0.995287"
   },
   "repository": "GoogleChrome/lighthouse",
   "keywords": [

package/readme.md

@@ -99,7 +99,7 @@ Configuration:
   --screenEmulation              Sets screen emulation parameters. See also --preset. Use --screenEmulation.disabled to disable. Otherwise set these 4 parameters individually: --screenEmulation.mobile --screenEmulation.width=360 --screenEmulation.height=640 --screenEmulation.deviceScaleFactor=2
   --emulatedUserAgent            Sets useragent emulation  [string]
   --max-wait-for-load            The timeout (in milliseconds) to wait before the page is considered done loading and the run should continue. WARNING: Very high values can lead to large traces and instability  [number]
-  --enable-error-reporting       Enables error reporting, overriding any saved preference. --no-enable-error-reporting will do the opposite. More: https://git.io/vFFTO  [boolean]
+  --enable-error-reporting       Enables error reporting, overriding any saved preference. --no-enable-error-reporting will do the opposite. More: https://github.com/GoogleChrome/lighthouse/blob/master/docs/error-reporting.md  [boolean]
   --gather-mode, -G              Collect artifacts from a connected browser and save to disk. (Artifacts folder path may optionally be provided). If audit-mode is not also enabled, the run will quit early.
   --audit-mode, -A               Process saved artifacts from disk. (Artifacts folder path may be provided, otherwise defaults to ./latest-run/)
   --only-audits                  Only run the specified audits  [array]