lighthouse 9.5.0-dev.20220509 → 9.6.1

package/lighthouse-core/computed/metrics/lantern-speed-index.js

@@ -146,5 +146,5 @@ class LanternSpeedIndex extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternSpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/metrics/lantern-total-blocking-time.js

@@ -122,5 +122,5 @@ class LanternTotalBlockingTime extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternTotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/metrics/largest-contentful-paint-all-frames.js

@@ -41,5 +41,5 @@ class LargestContentfulPaintAllFrames extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   LargestContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/metrics/largest-contentful-paint.js

@@ -48,5 +48,5 @@ class LargestContentfulPaint extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   LargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/metrics/max-potential-fid.js

@@ -41,5 +41,5 @@ class MaxPotentialFID extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   MaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

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

@@ -34,7 +34,6 @@ class Metric {
       devtoolsLog: data.devtoolsLog,
       gatherContext: data.gatherContext,
       settings: data.settings,
-      URL: data.URL,
     };
   }
 

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

@@ -25,11 +25,14 @@
  * @property {number} interactionId
  */
 /** @typedef {LH.Trace.AsyncEvent & {name: 'EventTiming', args: {data: EventTimingData}}} EventTimingEvent */
-
+/**
+ * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
+ * TODO: Remove once 103.0.5052.0 is sufficiently released.
+ * @typedef {{name: 'FallbackTiming', duration: number}} FallbackTimingEvent
+ */
 
 const makeComputedArtifact = require('../computed-artifact.js');
 const ProcessedTrace = require('../processed-trace.js');
-const LHError = require('../../lib/lh-error.js');
 
 const KEYBOARD_EVENTS = new Set(['keydown', 'keypress', 'keyup']);
 const CLICK_TAP_DRAG_EVENTS = new Set([
@@ -77,7 +80,7 @@ class Responsiveness {
    * one interaction had this duration by returning the first found.
    * @param {ResponsivenessEvent} responsivenessEvent
    * @param {LH.Trace} trace
-   * @return {EventTimingEvent}
+   * @return {EventTimingEvent|FallbackTimingEvent}
    */
   static findInteractionEvent(responsivenessEvent, {traceEvents}) {
     const candidates = traceEvents.filter(/** @return {evt is EventTimingEvent} */ evt => {
@@ -85,12 +88,12 @@ class Responsiveness {
       return evt.name === 'EventTiming' && evt.ph !== 'e';
     });
 
-    if (candidates.length && !candidates[0].args.data.frame) {
+    if (candidates.length && !candidates.some(candidate => candidate.args.data?.frame)) {
       // Full EventTiming data added in https://crrev.com/c/3632661
-      throw new LHError(
-        LHError.errors.UNSUPPORTED_OLD_CHROME,
-        {featureName: 'detailed EventTiming trace events'}
-      );
+      return {
+        name: 'FallbackTiming',
+        duration: responsivenessEvent.args.data.maxDuration,
+      };
     }
 
     const {maxDuration, interactionType} = responsivenessEvent.args.data;
@@ -131,7 +134,7 @@ class Responsiveness {
   /**
    * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<EventTimingEvent|null>}
+   * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
    */
   static async compute_(data, context) {
     const {settings, trace} = data;

package/lighthouse-core/computed/metrics/speed-index.js

@@ -36,5 +36,5 @@ class SpeedIndex extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   SpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/metrics/timing-summary.js

@@ -26,12 +26,11 @@ class TimingSummary {
      * @param {LH.DevtoolsLog} devtoolsLog
      * @param {LH.Artifacts['GatherContext']} gatherContext
      * @param {ImmutableObject<LH.Config.Settings>} settings
-     * @param {LH.Artifacts['URL']} URL
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
      */
-  static async summarize(trace, devtoolsLog, gatherContext, settings, URL, context) {
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL};
+  static async summarize(trace, devtoolsLog, gatherContext, settings, context) {
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings};
     /**
      * @template TArtifacts
      * @template TReturn
@@ -135,23 +134,17 @@ class TimingSummary {
     return {metrics, debugInfo};
   }
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: ImmutableObject<LH.Config.Settings>}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
    */
   static async compute_(data, context) {
-    return TimingSummary.summarize(
-      data.trace,
-      data.devtoolsLog,
-      data.gatherContext,
-      data.settings,
-      data.URL,
-      context
-    );
+    return TimingSummary.summarize(data.trace, data.devtoolsLog, data.gatherContext, data.settings,
+      context);
   }
 }
 
 module.exports = makeComputedArtifact(
   TimingSummary,
-  ['devtoolsLog', 'gatherContext', 'settings', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'trace']
 );

package/lighthouse-core/computed/metrics/total-blocking-time.js

@@ -70,5 +70,5 @@ class TotalBlockingTime extends ComputedMetric {
 
 module.exports = makeComputedArtifact(
   TotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );

package/lighthouse-core/computed/module-duplication.js

@@ -43,7 +43,7 @@ class ModuleDuplication {
   }
 
   /**
-   * @param {Map<string, Array<{scriptId: string, resourceSize: number}>>} moduleNameToSourceData
+   * @param {Map<string, Array<{scriptUrl: string, resourceSize: number}>>} moduleNameToSourceData
    */
   static _normalizeAggregatedData(moduleNameToSourceData) {
     for (const [key, originalSourceData] of moduleNameToSourceData.entries()) {
@@ -74,7 +74,7 @@ class ModuleDuplication {
   }
 
   /**
-   * @param {Pick<LH.Artifacts, 'Scripts'|'SourceMaps'>} artifacts
+   * @param {Pick<LH.Artifacts, 'ScriptElements'|'SourceMaps'>} artifacts
    * @param {LH.Artifacts.ComputedContext} context
    */
   static async compute_(artifacts, context) {
@@ -109,7 +109,7 @@ class ModuleDuplication {
       }
     }
 
-    /** @type {Map<string, Array<{scriptId: string, scriptUrl: string, resourceSize: number}>>} */
+    /** @type {Map<string, Array<{scriptUrl: string, resourceSize: number}>>} */
     const moduleNameToSourceData = new Map();
     for (const {rawMap, script} of bundles) {
       const sourceDataArray = sourceDatasMap.get(rawMap);
@@ -122,8 +122,7 @@ class ModuleDuplication {
           moduleNameToSourceData.set(sourceData.source, data);
         }
         data.push({
-          scriptId: script.scriptId,
-          scriptUrl: script.url,
+          scriptUrl: script.src || '',
           resourceSize: sourceData.resourceSize,
         });
       }
@@ -134,4 +133,4 @@ class ModuleDuplication {
   }
 }
 
-module.exports = makeComputedArtifact(ModuleDuplication, ['Scripts', 'SourceMaps']);
+module.exports = makeComputedArtifact(ModuleDuplication, ['ScriptElements', 'SourceMaps']);

package/lighthouse-core/computed/page-dependency-graph.js

@@ -8,14 +8,13 @@
 const makeComputedArtifact = require('./computed-artifact.js');
 const NetworkNode = require('../lib/dependency-graph/network-node.js');
 const CPUNode = require('../lib/dependency-graph/cpu-node.js');
+const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 const TracingProcessor = require('../lib/tracehouse/trace-processor.js');
 const NetworkRequest = require('../lib/network-request.js');
 const ProcessedTrace = require('./processed-trace.js');
 const NetworkRecords = require('./network-records.js');
-const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 
 /** @typedef {import('../lib/dependency-graph/base-node.js').Node} Node */
-/** @typedef {Omit<LH.Artifacts['URL'], 'initialUrl'|'finalUrl'>} URLArtifact */
 
 // Shorter tasks have negligible impact on simulation results.
 const SIGNIFICANT_DUR_THRESHOLD_MS = 10;
@@ -389,25 +388,34 @@ class PageDependencyGraph {
   /**
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @param {URLArtifact} URL
    * @return {Node}
    */
-  static createGraph(processedTrace, networkRecords, URL) {
+  static createGraph(processedTrace, networkRecords) {
     const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
     const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
-    const {requestedUrl, mainDocumentUrl} = URL;
-    if (!requestedUrl) throw new Error('requestedUrl is required to get the root request');
-    if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');
-
-    const rootRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
-    if (!rootRequest) throw new Error('rootRequest not found');
-    const rootNode = networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
-    if (!rootNode) throw new Error('rootNode not found');
 
-    const mainDocumentRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, mainDocumentUrl);
-    if (!mainDocumentRequest) throw new Error('mainDocumentRequest not found');
+    // The main document request is the earliest network request *of type document*.
+    // This will be different from the root request when there are server redirects.
+    const mainDocumentRequest = NetworkAnalyzer.findMainDocument(networkRecords);
     const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
-    if (!mainDocumentNode) throw new Error('mainDocumentNode not found');
+    if (!mainDocumentNode) {
+      // mainDocumentNode should always be found.
+      throw new Error('mainDocumentNode not found.');
+    }
+
+    // The root request is the earliest request in the main document redirect chain.
+    // Will be undefined if there were no redirects.
+    const rootRequest = mainDocumentNode.record.redirects?.[0];
+
+    let rootNode;
+    if (rootRequest) {
+      // rootNode should always be found.
+      rootNode = rootRequest && networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
+      if (!rootNode) throw new Error('rootNode not found');
+    } else {
+      // Use main document as root if there were no redirects.
+      rootNode = mainDocumentNode;
+    }
 
     PageDependencyGraph.linkNetworkNodes(rootNode, networkNodeOutput);
     PageDependencyGraph.linkCPUNodes(rootNode, networkNodeOutput, cpuNodes);
@@ -453,58 +461,23 @@ class PageDependencyGraph {
   }
 
   /**
-   * Recalculate `artifacts.URL` for clients that don't provide it.
-   *
-   * @param {LH.DevtoolsLog} devtoolsLog
-   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @return {URLArtifact}
-   */
-  static getDocumentUrls(devtoolsLog, networkRecords, processedTrace) {
-    const mainFrameId = processedTrace.mainFrameIds.frameId;
-
-    /** @type {string|undefined} */
-    let requestedUrl;
-    /** @type {string|undefined} */
-    let mainDocumentUrl;
-    for (const event of devtoolsLog) {
-      if (event.method === 'Page.frameNavigated' && event.params.frame.id === mainFrameId) {
-        const {url} = event.params.frame;
-        // Only set requestedUrl on the first main frame navigation.
-        if (!requestedUrl) requestedUrl = url;
-        mainDocumentUrl = url;
-      }
-    }
-    if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
-
-    const initialRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
-    if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
-
-    return {requestedUrl, mainDocumentUrl};
-  }
-
-  /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
-    const {trace, devtoolsLog} = data;
+    const trace = data.trace;
+    const devtoolsLog = data.devtoolsLog;
     const [processedTrace, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    // COMPAT: Backport for pre-10.0 clients that don't pass the URL artifact here (e.g. pubads).
-    // Calculates the URL artifact from the processed trace and DT log.
-    const URL = data.URL ||
-      PageDependencyGraph.getDocumentUrls(devtoolsLog, networkRecords, processedTrace);
-
-    return PageDependencyGraph.createGraph(processedTrace, networkRecords, URL);
+    return PageDependencyGraph.createGraph(processedTrace, networkRecords);
   }
 }
 
-module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL']);
+module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace']);
 
 /**
  * @typedef {Object} NetworkNodeOutput

package/lighthouse-core/computed/resource-summary.js

@@ -35,11 +35,11 @@ class ResourceSummary {
 
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @param {LH.Artifacts.URL} URLArtifact
+   * @param {string} mainResourceURL
    * @param {ImmutableObject<LH.Budget[]|null>} budgets
    * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
    */
-  static summarize(networkRecords, URLArtifact, budgets) {
+  static summarize(networkRecords, mainResourceURL, budgets) {
     /** @type {Record<LH.Budget.ResourceType, ResourceEntry>} */
     const resourceSummary = {
       'stylesheet': {count: 0, resourceSize: 0, transferSize: 0},
@@ -52,13 +52,13 @@ class ResourceSummary {
       'total': {count: 0, resourceSize: 0, transferSize: 0},
       'third-party': {count: 0, resourceSize: 0, transferSize: 0},
     };
-    const budget = Budget.getMatchingBudget(budgets, URLArtifact.mainDocumentUrl);
+    const budget = Budget.getMatchingBudget(budgets, mainResourceURL);
     /** @type {ReadonlyArray<string>} */
     let firstPartyHosts = [];
     if (budget?.options?.firstPartyHostnames) {
       firstPartyHosts = budget.options.firstPartyHostnames;
     } else {
-      const rootDomain = Util.getRootDomain(URLArtifact.finalUrl);
+      const rootDomain = Util.getRootDomain(mainResourceURL);
       firstPartyHosts = [`*.${rootDomain}`];
     }
 
@@ -107,7 +107,7 @@ class ResourceSummary {
    */
   static async compute_(data, context) {
     const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
-    return ResourceSummary.summarize(networkRecords, data.URL, data.budgets);
+    return ResourceSummary.summarize(networkRecords, data.URL.finalUrl, data.budgets);
   }
 }
 

package/lighthouse-core/computed/unused-css.js

@@ -120,11 +120,12 @@ class UnusedCSS {
 
   /**
    * @param {StyleSheetInfo} stylesheetInfo The stylesheetInfo object.
+   * @param {string} pageUrl The URL of the page, used to identify inline styles.
    * @return {LH.Audit.ByteEfficiencyItem}
    */
-  static mapSheetToResult(stylesheetInfo) {
+  static mapSheetToResult(stylesheetInfo, pageUrl) {
     let url = stylesheetInfo.header.sourceURL;
-    if (!url || stylesheetInfo.header.isInline) {
+    if (!url || url === pageUrl) {
       const contentPreview = UnusedCSS.determineContentPreview(stylesheetInfo.content);
       url = contentPreview;
     }
@@ -134,20 +135,20 @@ class UnusedCSS {
   }
 
   /**
-   * @param {{CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
+   * @param {{CSSUsage: LH.Artifacts['CSSUsage'], URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Audit.ByteEfficiencyItem[]>}
   */
   static async compute_(data, context) {
-    const {CSSUsage, devtoolsLog} = data;
+    const {CSSUsage, URL, devtoolsLog} = data;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
     const indexedSheets = UnusedCSS.indexStylesheetsById(CSSUsage.stylesheets, networkRecords);
     UnusedCSS.indexUsedRules(CSSUsage.rules, indexedSheets);
 
     const items = Object.keys(indexedSheets)
-      .map(sheetId => UnusedCSS.mapSheetToResult(indexedSheets[sheetId]));
+      .map(sheetId => UnusedCSS.mapSheetToResult(indexedSheets[sheetId], URL.finalUrl));
     return items;
   }
 }
 
-module.exports = makeComputedArtifact(UnusedCSS, ['CSSUsage', 'devtoolsLog']);
+module.exports = makeComputedArtifact(UnusedCSS, ['CSSUsage', 'URL', 'devtoolsLog']);

package/lighthouse-core/computed/unused-javascript-summary.js

@@ -16,14 +16,14 @@ const makeComputedArtifact = require('./computed-artifact.js');
 
 /**
  * @typedef ComputeInput
- * @property {string} scriptId
- * @property {Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>} scriptCoverage
+ * @property {string} url
+ * @property {Array<Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>>} scriptCoverages
  * @property {LH.Artifacts.Bundle=} bundle
  */
 
 /**
  * @typedef Summary
- * @property {string} scriptId
+ * @property {string} url
  * @property {number} wastedBytes
  * @property {number} totalBytes
  * @property {number} wastedBytes
@@ -68,24 +68,43 @@ class UnusedJavascriptSummary {
   }
 
   /**
-   * @param {string} scriptId
-   * @param {WasteData} wasteData
+   * @param {string} url
+   * @param {ReturnType<typeof UnusedJavascriptSummary.determineLengths>} lengths
    * @return {Summary}
    */
-  static createItem(scriptId, wasteData) {
-    const wastedRatio = (wasteData.unusedLength / wasteData.contentLength) || 0;
-    const wastedBytes = Math.round(wasteData.contentLength * wastedRatio);
+  static createItem(url, lengths) {
+    const wastedRatio = (lengths.unused / lengths.content) || 0;
+    const wastedBytes = Math.round(lengths.content * wastedRatio);
 
     return {
-      scriptId,
-      totalBytes: wasteData.contentLength,
+      url,
+      totalBytes: lengths.content,
       wastedBytes,
       wastedPercent: 100 * wastedRatio,
     };
   }
 
   /**
-   * @param {WasteData} wasteData
+   * @param {WasteData[]} wasteData
+   */
+  static determineLengths(wasteData) {
+    let unused = 0;
+    let content = 0;
+    // TODO: this is right for multiple script tags in an HTML document,
+    // but may be wrong for multiple frames using the same script resource.
+    for (const usage of wasteData) {
+      unused += usage.unusedLength;
+      content += usage.contentLength;
+    }
+
+    return {
+      content,
+      unused,
+    };
+  }
+
+  /**
+   * @param {WasteData[]} wasteData
    * @param {LH.Artifacts.Bundle} bundle
    */
   static createSourceWastedBytes(wasteData, bundle) {
@@ -112,7 +131,7 @@ class UnusedJavascriptSummary {
         mapping.lastColumnNumber - 1 :
         lineLengths[mapping.lineNumber];
       for (let i = mapping.columnNumber; i <= lastColumnOfMapping; i++) {
-        if (wasteData.unusedByIndex[offset] === 1) {
+        if (wasteData.every(data => data.unusedByIndex[offset] === 1)) {
           const key = mapping.sourceURL || '(unmapped)';
           files[key] = (files[key] || 0) + 1;
         }
@@ -136,10 +155,11 @@ class UnusedJavascriptSummary {
    * @return {Promise<Summary>}
    */
   static async compute_(data) {
-    const {scriptId, scriptCoverage, bundle} = data;
+    const {url, scriptCoverages, bundle} = data;
 
-    const wasteData = UnusedJavascriptSummary.computeWaste(scriptCoverage);
-    const item = UnusedJavascriptSummary.createItem(scriptId, wasteData);
+    const wasteData = scriptCoverages.map(UnusedJavascriptSummary.computeWaste);
+    const lengths = UnusedJavascriptSummary.determineLengths(wasteData);
+    const item = UnusedJavascriptSummary.createItem(url, lengths);
     if (!bundle) return item;
 
     return {
@@ -151,5 +171,5 @@ class UnusedJavascriptSummary {
 
 module.exports = makeComputedArtifact(
   UnusedJavascriptSummary,
-  ['bundle', 'scriptCoverage', 'scriptId']
+  ['bundle', 'scriptCoverages', 'url']
 );

package/lighthouse-core/config/budget.js

@@ -137,11 +137,11 @@ class Budget {
    * If multiple budgets match based on thier 'path' property,
    * then the last-listed of those budgets is returned.
    * @param {Immutable<Array<LH.Budget>>|null} budgets
-   * @param {string|undefined} url
+   * @param {string} url
    * @return {Immutable<LH.Budget> | undefined} budget
    */
   static getMatchingBudget(budgets, url) {
-    if (budgets === null || url === undefined) return;
+    if (budgets === null) return;
 
     // Applies the LAST matching budget.
     for (let i = budgets.length - 1; i >= 0; i--) {

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

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

package/lighthouse-core/config/metrics-to-audits.js

@@ -48,9 +48,14 @@ const clsRelevantAudits = [
   // 'preload-fonts', // actually in BP, rather than perf
 ];
 
+const inpRelevantAudits = [
+  'work-during-interaction',
+];
+
 module.exports = {
   fcpRelevantAudits,
   lcpRelevantAudits,
   tbtRelevantAudits,
   clsRelevantAudits,
+  inpRelevantAudits,
 };

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

@@ -13,7 +13,7 @@ const {generateFlowReportHtml} = require('../../report/generator/report-generato
 const Runner = require('../runner.js');
 
 /**
- * @param {LH.Puppeteer.Page} page
+ * @param {import('puppeteer').Page} page
  * @param {ConstructorParameters<LH.UserFlow>[1]} [options]
  */
 async function startFlow(page, options) {

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

@@ -6,19 +6,23 @@
 'use strict';
 
 const legacyDefaultConfig = require('../../config/default-config.js');
+const m2a = require('../../config/metrics-to-audits.js');
 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',
+  'work-during-interaction',
 ];
 
 /** @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'},
+    {id: 'experimental-interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP',
+      relevantAudits: m2a.inpRelevantAudits},
+    {id: 'work-during-interaction', weight: 0},
   ],
 };
 
@@ -66,7 +70,6 @@ const artifacts = {
   RobotsTxt: '',
   ServiceWorker: '',
   ScriptElements: '',
-  Scripts: '',
   SourceMaps: '',
   Stacks: '',
   TagsBlockingFirstPaint: '',
@@ -100,7 +103,6 @@ const defaultConfig = {
     {id: artifacts.EmbeddedContent, gatherer: 'seo/embedded-content'},
     {id: artifacts.FontSize, gatherer: 'seo/font-size'},
     {id: artifacts.Inputs, gatherer: 'inputs'},
-    {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
     {id: artifacts.GlobalListeners, gatherer: 'global-listeners'},
     {id: artifacts.IFrameElements, gatherer: 'iframe-elements'},
     {id: artifacts.ImageElements, gatherer: 'image-elements'},
@@ -117,7 +119,6 @@ const defaultConfig = {
     {id: artifacts.RobotsTxt, gatherer: 'seo/robots-txt'},
     {id: artifacts.ServiceWorker, gatherer: 'service-worker'},
     {id: artifacts.ScriptElements, gatherer: 'script-elements'},
-    {id: artifacts.Scripts, gatherer: 'scripts'},
     {id: artifacts.SourceMaps, gatherer: 'source-maps'},
     {id: artifacts.Stacks, gatherer: 'stacks'},
     {id: artifacts.TagsBlockingFirstPaint, gatherer: 'dobetterweb/tags-blocking-first-paint'},
@@ -130,6 +131,9 @@ const defaultConfig = {
     // Artifact copies are renamed for compatibility with legacy artifacts.
     {id: artifacts.devtoolsLogs, gatherer: 'devtools-log-compat'},
     {id: artifacts.traces, gatherer: 'trace-compat'},
+
+    // FullPageScreenshot comes at the very end so all other node analysis is captured.
+    {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
   ],
   navigations: [
     {
@@ -169,7 +173,6 @@ const defaultConfig = {
         artifacts.RobotsTxt,
         artifacts.ServiceWorker,
         artifacts.ScriptElements,
-        artifacts.Scripts,
         artifacts.SourceMaps,
         artifacts.Stacks,
         artifacts.TagsBlockingFirstPaint,