lighthouse 9.5.0-dev.20220607 → 9.6.2

package/lighthouse-core/audits/server-response-time.js

@@ -8,6 +8,8 @@
 const Audit = require('./audit.js');
 const i18n = require('../lib/i18n/i18n.js');
 const MainResource = require('../computed/main-resource.js');
+const NetworkRecords = require('../computed/network-records.js');
+const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides detail on how long it took from starting a request to when the server started responding. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -37,7 +39,7 @@ class ServerResponseTime extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
+      supportedModes: ['timespan', 'navigation'],
       requiredArtifacts: ['devtoolsLogs', 'URL', 'GatherContext'],
     };
   }
@@ -59,7 +61,20 @@ class ServerResponseTime extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
 
     /** @type {LH.Artifacts.NetworkRequest} */
-    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    let mainResource;
+    if (artifacts.GatherContext.gatherMode === 'timespan') {
+      const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+      const optionalMainResource = NetworkAnalyzer.findOptionalMainDocument(
+        networkRecords,
+        artifacts.URL.finalUrl
+      );
+      if (!optionalMainResource) {
+        return {score: null, notApplicable: true};
+      }
+      mainResource = optionalMainResource;
+    } else {
+      mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    }
 
     const responseTime = ServerResponseTime.calculateResponseTime(mainResource);
     const passed = responseTime < TOO_SLOW_THRESHOLD_MS;

package/lighthouse-core/audits/service-worker.js

@@ -51,7 +51,6 @@ class ServiceWorker extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['URL', 'ServiceWorker', 'WebAppManifest'],
     };
   }
@@ -129,12 +128,8 @@ class ServiceWorker extends Audit {
    * @return {LH.Audit.Product}
    */
   static audit(artifacts) {
-    // Match against `artifacts.URL.mainDocumentUrl` so audit accounts for any redirects.
-    // Service workers won't control network requests if the page uses `history.pushState` to "enter" the SW scope.
-    // For this reason it is better to evaluate the SW in relation to the main document url rather than the final frame url.
-    const {mainDocumentUrl} = artifacts.URL;
-    if (!mainDocumentUrl) throw new Error('mainDocumentUrl must exist in navigation mode');
-    const pageUrl = new URL(mainDocumentUrl);
+    // Match against artifacts.URL.finalUrl so audit accounts for any redirects.
+    const pageUrl = new URL(artifacts.URL.finalUrl);
     const {versions, registrations} = artifacts.ServiceWorker;
 
     const versionsForOrigin = ServiceWorker.getVersionsForOrigin(versions, pageUrl);

package/lighthouse-core/audits/timing-budget.js

@@ -140,9 +140,8 @@ class TimingBudget extends Audit {
     const gatherContext = artifacts.GatherContext;
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    const URL = artifacts.URL;
-    const mainResource = await MainResource.request({URL, devtoolsLog}, context);
-    const data = {trace, devtoolsLog, gatherContext, settings: context.settings, URL};
+    const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
+    const data = {trace, devtoolsLog, gatherContext, settings: context.settings};
     const summary = (await TimingSummary.request(data, context)).metrics;
     const budget = Budget.getMatchingBudget(context.settings.budgets, mainResource.url);
 

package/lighthouse-core/audits/uses-rel-preconnect.js

@@ -123,7 +123,7 @@ class UsesRelPreconnectAudit extends Audit {
         MainResource.request({devtoolsLog, URL: artifacts.URL}, context),
         LoadSimulator.request({devtoolsLog, settings}, context),
         ProcessedNavigation.request(processedTrace, context),
-        PageDependencyGraph.request({trace, devtoolsLog, URL: artifacts.URL}, context),
+        PageDependencyGraph.request({trace, devtoolsLog}, context),
       ]);
 
     const {rtt, additionalRttByOrigin} = loadSimulator.getOptions();

package/lighthouse-core/audits/uses-rel-preload.js

@@ -217,7 +217,7 @@ class UsesRelPreloadAudit extends Audit {
 
     const [mainResource, graph, simulator] = await Promise.all([
       MainResource.request({devtoolsLog, URL}, context),
-      PageDependencyGraph.request({trace, devtoolsLog, URL}, context),
+      PageDependencyGraph.request({trace, devtoolsLog}, context),
       LoadSimulator.request(simulatorOptions, context),
     ]);
 

package/lighthouse-core/audits/valid-source-maps.js

@@ -44,22 +44,22 @@ class ValidSourceMaps extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      requiredArtifacts: ['Scripts', 'SourceMaps', 'URL'],
+      requiredArtifacts: ['ScriptElements', 'SourceMaps', 'URL'],
     };
   }
 
   /**
    * Returns true if the size of the script exceeds a static threshold.
-   * @param {LH.Artifacts.Script} script
+   * @param {LH.Artifacts.ScriptElement} scriptElement
    * @param {string} finalURL
    * @return {boolean}
    */
-  static isLargeFirstPartyJS(script, finalURL) {
-    if (!script.length) return false;
+  static isLargeFirstPartyJS(scriptElement, finalURL) {
+    if (scriptElement.content === null) return false;
 
-    const isLargeJS = script.length >= LARGE_JS_BYTE_THRESHOLD;
-    const isFirstPartyJS = script.url ?
-      thirdPartyWeb.isFirstParty(script.url, thirdPartyWeb.getEntity(finalURL)) : false;
+    const isLargeJS = scriptElement.content.length >= LARGE_JS_BYTE_THRESHOLD;
+    const isFirstPartyJS = scriptElement.src ?
+      thirdPartyWeb.isFirstParty(scriptElement.src, thirdPartyWeb.getEntity(finalURL)) : false;
 
     return isLargeJS && isFirstPartyJS;
   }
@@ -75,14 +75,16 @@ class ValidSourceMaps extends Audit {
 
     let missingMapsForLargeFirstPartyFile = false;
     const results = [];
-    for (const script of artifacts.Scripts) {
-      const sourceMap = SourceMaps.find(m => m.scriptId === script.scriptId);
+    for (const scriptElement of artifacts.ScriptElements) {
+      if (!scriptElement.src) continue; // TODO: inline scripts, how do they work?
+
+      const sourceMap = SourceMaps.find(m => m.scriptUrl === scriptElement.src);
       const errors = [];
-      const isLargeFirstParty = this.isLargeFirstPartyJS(script, artifacts.URL.finalUrl);
+      const isLargeFirstParty = this.isLargeFirstPartyJS(scriptElement, artifacts.URL.finalUrl);
 
       if (isLargeFirstParty && (!sourceMap || !sourceMap.map)) {
         missingMapsForLargeFirstPartyFile = true;
-        isMissingMapForLargeFirstPartyScriptUrl.add(script.url);
+        isMissingMapForLargeFirstPartyScriptUrl.add(scriptElement.src);
         errors.push({error: str_(UIStrings.missingSourceMapErrorMessage)});
       }
 
@@ -105,7 +107,7 @@ class ValidSourceMaps extends Audit {
 
       if (sourceMap || errors.length) {
         results.push({
-          scriptUrl: script.url,
+          scriptUrl: scriptElement.src,
           sourceMapUrl: sourceMap?.sourceMapUrl,
           subItems: {
             type: /** @type {const} */ ('subitems'),

package/lighthouse-core/audits/violation-audit.js

@@ -31,7 +31,7 @@ class ViolationAudit extends Audit {
     return artifacts.ConsoleMessages
         .filter(entry => entry.url && entry.source === 'violation' && pattern.test(entry.text))
         .map(entry => {
-          const bundle = bundles.find(bundle => bundle.script.scriptId === entry.scriptId);
+          const bundle = bundles.find(bundle => bundle.script.src === entry.url);
           return Audit.makeSourceLocationFromConsoleMessage(entry, bundle);
         })
         .filter(filterUndefined)

package/lighthouse-core/audits/work-during-interaction.js

@@ -32,7 +32,7 @@ const UIStrings = {
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before responding to user input. Ideally fits within a ~40 character limit. */
   inputDelay: 'Input delay',
   /** Label for a column in a data table; entries will be information on the time taken by code processing user input that delays a response to the user. Ideally fits within a ~40 character limit. */
-  processingTime: 'Processing time',
+  processingDelay: 'Processing delay',
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before presenting a response to user input on screen. Ideally fits within a ~40 character limit. */
   presentationDelay: 'Presentation delay',
   /**
@@ -116,7 +116,7 @@ class WorkDuringInteraction extends Audit {
     const endTs = startTs + interactionData.duration * 1000;
     return {
       inputDelay: {startTs, endTs: processingStartTs},
-      processingTime: {startTs: processingStartTs, endTs: processingEndTs},
+      processingDelay: {startTs: processingStartTs, endTs: processingEndTs},
       presentationDelay: {startTs: processingEndTs, endTs},
     };
   }

package/lighthouse-core/computed/critical-request-chains.js

@@ -117,9 +117,6 @@ class CriticalRequestChains {
       // Ignore if some ancestor is not a critical request.
       if (networkPath.some(r => !CriticalRequestChains.isCritical(r, mainResource))) return;
 
-      // Ignore non-network things (like data urls).
-      if (NetworkRequest.isNonNetworkRequest(node.record)) return;
-
       addChain(networkPath);
     }, getNextNodes);
 
@@ -132,8 +129,15 @@ class CriticalRequestChains {
    * @return {Promise<LH.Artifacts.CriticalRequestNode>}
    */
   static async compute_(data, context) {
-    const mainResource = await MainResource.request(data, context);
-    const graph = await PageDependencyGraph.request(data, context);
+    const mainResource = await MainResource.request({
+      URL: data.URL,
+      devtoolsLog: data.devtoolsLog,
+    }, context);
+
+    const graph = await PageDependencyGraph.request({
+      trace: data.trace,
+      devtoolsLog: data.devtoolsLog,
+    }, context);
 
     return CriticalRequestChains.extractChainsFromGraph(mainResource, graph);
   }

package/lighthouse-core/computed/js-bundles.js

@@ -12,15 +12,14 @@ const SDK = require('../lib/cdt/SDK.js');
 /**
  * Calculate the number of bytes contributed by each source file
  * @param {LH.Artifacts.Bundle['map']} map
- * @param {number} contentLength
  * @param {string} content
  * @return {LH.Artifacts.Bundle['sizes']}
  */
-function computeGeneratedFileSizes(map, contentLength, content) {
+function computeGeneratedFileSizes(map, content) {
   const lines = content.split('\n');
   /** @type {Record<string, number>} */
   const files = {};
-  const totalBytes = contentLength;
+  const totalBytes = content.length;
   let unmappedBytes = totalBytes;
 
   // @ts-expect-error: This function is added in SDK.js. This will eventually be added to CDT.
@@ -79,10 +78,10 @@ function computeGeneratedFileSizes(map, contentLength, content) {
 
 class JSBundles {
   /**
-   * @param {Pick<LH.Artifacts, 'SourceMaps'|'Scripts'>} artifacts
+   * @param {Pick<LH.Artifacts, 'SourceMaps'|'ScriptElements'>} artifacts
    */
   static async compute_(artifacts) {
-    const {SourceMaps, Scripts} = artifacts;
+    const {SourceMaps, ScriptElements} = artifacts;
 
     /** @type {LH.Artifacts.Bundle[]} */
     const bundles = [];
@@ -90,22 +89,23 @@ class JSBundles {
     // Collate map and script, compute file sizes.
     for (const SourceMap of SourceMaps) {
       if (!SourceMap.map) continue;
-      const {scriptId, map: rawMap} = SourceMap;
+      const {scriptUrl, map: rawMap} = SourceMap;
 
       if (!rawMap.mappings) continue;
 
-      const script = Scripts.find(s => s.scriptId === scriptId);
-      if (!script) continue;
+      const scriptElement = ScriptElements.find(s => s.src === scriptUrl);
+      if (!scriptElement) continue;
 
       const compiledUrl = SourceMap.scriptUrl || 'compiled.js';
       const mapUrl = SourceMap.sourceMapUrl || 'compiled.js.map';
       const map = new SDK.TextSourceMap(compiledUrl, mapUrl, rawMap);
 
-      const sizes = computeGeneratedFileSizes(map, script.length || 0, script.content || '');
+      const content = scriptElement?.content ? scriptElement.content : '';
+      const sizes = computeGeneratedFileSizes(map, content);
 
       const bundle = {
         rawMap,
-        script,
+        script: scriptElement,
         map,
         sizes,
       };
@@ -116,4 +116,4 @@ class JSBundles {
   }
 }
 
-module.exports = makeComputedArtifact(JSBundles, ['Scripts', 'SourceMaps']);
+module.exports = makeComputedArtifact(JSBundles, ['ScriptElements', 'SourceMaps']);

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

@@ -20,10 +20,9 @@ class MainResource {
    * @return {Promise<LH.Artifacts.NetworkRequest>}
    */
   static async compute_(data, context) {
-    const {mainDocumentUrl} = data.URL;
-    if (!mainDocumentUrl) throw new Error('mainDocumentUrl must exist to get the main resource');
+    const finalUrl = data.URL.finalUrl;
     const requests = await NetworkRecords.request(data.devtoolsLog, context);
-    const mainResource = NetworkAnalyzer.findResourceForUrl(requests, mainDocumentUrl);
+    const mainResource = NetworkAnalyzer.findMainDocument(requests, finalUrl);
     if (!mainResource) {
       throw new Error('Unable to identify the main resource');
     }

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

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

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

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

package/lighthouse-core/computed/metrics/first-meaningful-paint.js

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

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

@@ -183,7 +183,7 @@ class Interactive extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   Interactive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
 );
 
 /**

package/lighthouse-core/computed/metrics/lantern-first-contentful-paint.js

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

package/lighthouse-core/computed/metrics/lantern-first-meaningful-paint.js

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

package/lighthouse-core/computed/metrics/lantern-interactive.js

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

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

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

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

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

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

@@ -101,15 +101,17 @@ class LanternMetricArtifact {
   static async computeMetricWithGraphs(data, context, extras) {
     // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
     const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
+    const {trace, devtoolsLog, settings} = data;
     if (gatherContext.gatherMode !== 'navigation') {
       throw new Error(`Lantern metrics can only be computed on navigations`);
     }
 
     const metricName = this.name.replace('Lantern', '');
-    const graph = await PageDependencyGraph.request(data, context);
-    const processedTrace = await ProcessedTrace.request(data.trace, context);
+    const graph = await PageDependencyGraph.request({trace, devtoolsLog}, context);
+    const processedTrace = await ProcessedTrace.request(trace, context);
     const processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-    const simulator = data.simulator || (await LoadSimulator.request(data, context));
+    const simulator = data.simulator ||
+        (await LoadSimulator.request({devtoolsLog, settings}, context));
 
     const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
     const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);

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/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']);