lighthouse 12.4.0-dev.20250317 → 12.4.0-dev.20250319

package/core/audits/metrics/total-blocking-time.js

@@ -27,7 +27,7 @@ class TotalBlockingTime extends Audit {
       title: str_(i18n.UIStrings.totalBlockingTimeMetric),
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL', 'SourceMaps'],
     };
   }
 
@@ -89,7 +89,7 @@ class TotalBlockingTime extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
     const metricComputationData = {trace, devtoolsLog, gatherContext,
-      settings: context.settings, URL: artifacts.URL};
+      settings: context.settings, URL: artifacts.URL, SourceMaps: artifacts.SourceMaps};
     if (
       gatherContext.gatherMode === 'timespan' &&
       context.settings.throttlingMethod === 'simulate'

package/core/audits/metrics.js

@@ -26,7 +26,7 @@ class Metrics extends Audit {
       title: 'Metrics',
       description: 'Collects all available metrics.',
       supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL', 'SourceMaps'],
     };
   }
 
@@ -36,12 +36,13 @@ class Metrics extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
+    const settings = context.settings;
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    const URL = artifacts.URL;
+    const {URL, SourceMaps} = artifacts;
     const summary = await TimingSummary
-      .request({trace, devtoolsLog, gatherContext, settings: context.settings, URL}, context);
+      .request({trace, devtoolsLog, gatherContext, settings, URL, SourceMaps}, context);
     const metrics = summary.metrics;
     const debugInfo = summary.debugInfo;
 

package/core/audits/predictive-perf.js

@@ -33,7 +33,7 @@ class PredictivePerf extends Audit {
         'a cellular connection on a mobile device.',
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
       supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL', 'SourceMaps'],
     };
   }
 
@@ -46,10 +46,10 @@ class PredictivePerf extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    const URL = artifacts.URL;
+    const {URL, SourceMaps} = artifacts;
     /** @type {LH.Config.Settings} */
     const settings = JSON.parse(JSON.stringify(defaultSettings)); // Use default settings.
-    const computationData = {trace, devtoolsLog, gatherContext, settings, URL};
+    const computationData = {trace, devtoolsLog, gatherContext, settings, URL, SourceMaps};
     const fcp = await LanternFirstContentfulPaint.request(computationData, context);
     const tti = await LanternInteractive.request(computationData, context);
     const si = await LanternSpeedIndex.request(computationData, context);

package/core/audits/prioritize-lcp-image.js

@@ -38,7 +38,8 @@ class PrioritizeLcpImage extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 4,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL', 'TraceElements'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL', 'TraceElements',
+        'SourceMaps'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }
@@ -237,9 +238,9 @@ class PrioritizeLcpImage extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[PrioritizeLcpImage.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[PrioritizeLcpImage.DEFAULT_PASS];
-    const URL = artifacts.URL;
+    const {URL, SourceMaps} = artifacts;
     const settings = context.settings;
-    const metricData = {trace, devtoolsLog, gatherContext, settings, URL};
+    const metricData = {trace, devtoolsLog, gatherContext, settings, URL, SourceMaps};
     const lcpElement = artifacts.TraceElements
       .find(element => element.traceEventType === 'largest-contentful-paint');
 

package/core/audits/redirects.js

@@ -31,7 +31,7 @@ class Redirects extends Audit {
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
       supportedModes: ['navigation'],
       guidanceLevel: 2,
-      requiredArtifacts: ['URL', 'GatherContext', 'devtoolsLogs', 'traces'],
+      requiredArtifacts: ['URL', 'GatherContext', 'devtoolsLogs', 'traces', 'SourceMaps'],
     };
   }
 
@@ -87,12 +87,13 @@ class Redirects extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
+    const {URL, SourceMaps} = artifacts;
 
     const processedTrace = await ProcessedTrace.request(trace, context);
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
     const documentRequests = Redirects.getDocumentRequestChain(networkRecords, processedTrace);
 
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL, SourceMaps};
     const metricResult = await LanternInteractive.request(metricComputationData, context);
 
     /** @type {Map<string, LH.Gatherer.Simulation.NodeTiming>} */

package/core/audits/script-treemap-data.js

@@ -31,7 +31,7 @@ class ScriptTreemapDataAudit extends Audit {
       title: 'Script Treemap Data',
       description: 'Used for treemap app',
       requiredArtifacts:
-        ['traces', 'devtoolsLogs', 'SourceMaps', 'Scripts', 'JsUsage', 'URL'],
+        ['traces', 'devtoolsLogs', 'SourceMaps', 'Scripts', 'JsUsage', 'URL', 'SourceMaps'],
     };
   }
 

package/core/audits/third-party-facades.js

@@ -87,7 +87,7 @@ class ThirdPartyFacades extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 3,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'GatherContext', 'SourceMaps'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }

package/core/audits/third-party-summary.js

@@ -67,7 +67,7 @@ class ThirdPartySummary extends Audit {
       description: str_(UIStrings.description),
       guidanceLevel: 1,
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'GatherContext', 'SourceMaps'],
     };
   }
 

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

@@ -62,7 +62,7 @@ class UsesRelPreconnectAudit extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 3,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'LinkElements'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'LinkElements', 'SourceMaps'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }
@@ -125,6 +125,7 @@ class UsesRelPreconnectAudit extends Audit {
     const trace = artifacts.traces[UsesRelPreconnectAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreconnectAudit.DEFAULT_PASS];
     const settings = context.settings;
+    const {URL, SourceMaps} = artifacts;
 
     let maxWastedLcp = 0;
     let maxWastedFcp = 0;
@@ -134,15 +135,15 @@ class UsesRelPreconnectAudit extends Audit {
     const [networkRecords, mainResource, loadSimulator, processedNavigation, pageGraph] =
       await Promise.all([
         NetworkRecords.request(devtoolsLog, context),
-        MainResource.request({devtoolsLog, URL: artifacts.URL}, context),
+        MainResource.request({devtoolsLog, URL}, context),
         LoadSimulator.request({devtoolsLog, settings}, context),
         ProcessedNavigation.request(trace, context),
-        PageDependencyGraph.request({settings, trace, devtoolsLog, URL: artifacts.URL}, context),
+        PageDependencyGraph.request({settings, trace, devtoolsLog, URL, SourceMaps}, context),
       ]);
 
     const {rtt, additionalRttByOrigin} = loadSimulator.getOptions();
     const lcpGraph =
-      await LanternLargestContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
+      LanternLargestContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
     /** @type {Set<string>} */
     const lcpGraphURLs = new Set();
     lcpGraph.traverse(node => {
@@ -150,7 +151,7 @@ class UsesRelPreconnectAudit extends Audit {
     });
 
     const fcpGraph =
-      await LanternFirstContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
+      LanternFirstContentfulPaint.getPessimisticGraph(pageGraph, processedNavigation);
     const fcpGraphURLs = new Set();
     fcpGraph.traverse(node => {
       if (node.type === 'network') fcpGraphURLs.add(node.request.url);

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

@@ -44,7 +44,7 @@ class UsesRelPreloadAudit extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 3,
-      requiredArtifacts: ['devtoolsLogs', 'traces', 'URL'],
+      requiredArtifacts: ['devtoolsLogs', 'traces', 'URL', 'SourceMaps'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }
@@ -215,12 +215,12 @@ class UsesRelPreloadAudit extends Audit {
     const settings = context.settings;
     const trace = artifacts.traces[UsesRelPreloadAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreloadAudit.DEFAULT_PASS];
-    const URL = artifacts.URL;
+    const {URL, SourceMaps} = artifacts;
     const simulatorOptions = {devtoolsLog, settings: context.settings};
 
     const [mainResource, graph, simulator] = await Promise.all([
       MainResource.request({devtoolsLog, URL}, context),
-      PageDependencyGraph.request({settings, trace, devtoolsLog, URL}, context),
+      PageDependencyGraph.request({settings, trace, devtoolsLog, URL, SourceMaps}, context),
       LoadSimulator.request(simulatorOptions, context),
     ]);
 

package/core/computed/critical-request-chains.d.ts

@@ -2,6 +2,7 @@ export { CriticalRequestChainsComputed as CriticalRequestChains };
 declare const CriticalRequestChainsComputed: typeof CriticalRequestChains & {
     request: (dependencies: {
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
         devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
         settings: LH.Audit.Context["settings"];
@@ -25,12 +26,13 @@ declare class CriticalRequestChains {
      */
     static extractChainsFromGraph(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode): LH.Artifacts.CriticalRequestNode;
     /**
-     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
+     * @param {{URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Artifacts.CriticalRequestNode>}
      */
     static compute_(data: {
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
         devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
         settings: LH.Audit.Context["settings"];

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

@@ -126,7 +126,7 @@ class CriticalRequestChains {
   }
 
   /**
-   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
+   * @param {{URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.CriticalRequestNode>}
    */
@@ -138,6 +138,6 @@ class CriticalRequestChains {
   }
 }
 
-const CriticalRequestChainsComputed =
-  makeComputedArtifact(CriticalRequestChains, ['URL', 'devtoolsLog', 'trace', 'settings']);
+const CriticalRequestChainsComputed = makeComputedArtifact(CriticalRequestChains,
+  ['URL', 'SourceMaps', 'devtoolsLog', 'trace', 'settings']);
 export {CriticalRequestChainsComputed as CriticalRequestChains};

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

@@ -32,6 +32,6 @@ class FirstContentfulPaintAllFrames extends NavigationMetric {
 
 const FirstContentfulPaintAllFramesComputed = makeComputedArtifact(
   FirstContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {FirstContentfulPaintAllFramesComputed as FirstContentfulPaintAllFrames};

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

@@ -35,6 +35,6 @@ class FirstContentfulPaint extends NavigationMetric {
 
 const FirstContentfulPaintComputed = makeComputedArtifact(
   FirstContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {FirstContentfulPaintComputed as FirstContentfulPaint};

package/core/computed/metrics/interactive.js

@@ -181,7 +181,7 @@ class Interactive extends NavigationMetric {
 
 const InteractiveComputed = makeComputedArtifact(
   Interactive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {InteractiveComputed as Interactive};
 

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

@@ -32,6 +32,6 @@ class LanternFirstContentfulPaint extends Lantern.Metrics.FirstContentfulPaint {
 
 const LanternFirstContentfulPaintComputed = makeComputedArtifact(
   LanternFirstContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint};

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

@@ -34,6 +34,6 @@ class LanternInteractive extends Lantern.Metrics.Interactive {
 
 const LanternInteractiveComputed = makeComputedArtifact(
   LanternInteractive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternInteractiveComputed as LanternInteractive};

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

@@ -34,6 +34,6 @@ class LanternLargestContentfulPaint extends Lantern.Metrics.LargestContentfulPai
 
 const LanternLargestContentfulPaintComputed = makeComputedArtifact(
   LanternLargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternLargestContentfulPaintComputed as LanternLargestContentfulPaint};

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

@@ -34,6 +34,6 @@ class LanternMaxPotentialFID extends Lantern.Metrics.MaxPotentialFID {
 
 const LanternMaxPotentialFIDComputed = makeComputedArtifact(
   LanternMaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternMaxPotentialFIDComputed as LanternMaxPotentialFID};

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

@@ -40,6 +40,6 @@ class LanternSpeedIndex extends Lantern.Metrics.SpeedIndex {
 
 const LanternSpeedIndexComputed = makeComputedArtifact(
   LanternSpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternSpeedIndexComputed as LanternSpeedIndex};

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

@@ -35,6 +35,6 @@ class LanternTotalBlockingTime extends Lantern.Metrics.TotalBlockingTime {
 
 const LanternTotalBlockingTimeComputed = makeComputedArtifact(
   LanternTotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LanternTotalBlockingTimeComputed as LanternTotalBlockingTime};

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

@@ -40,6 +40,6 @@ class LargestContentfulPaintAllFrames extends NavigationMetric {
 
 const LargestContentfulPaintAllFramesComputed = makeComputedArtifact(
   LargestContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LargestContentfulPaintAllFramesComputed as LargestContentfulPaintAllFrames};

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

@@ -47,6 +47,6 @@ class LargestContentfulPaint extends NavigationMetric {
 
 const LargestContentfulPaintComputed = makeComputedArtifact(
   LargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LargestContentfulPaintComputed as LargestContentfulPaint};

package/core/computed/metrics/lcp-breakdown.js

@@ -52,7 +52,7 @@ class LCPBreakdown {
 
 const LCPBreakdownComputed = makeComputedArtifact(
   LCPBreakdown,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {LCPBreakdownComputed as LCPBreakdown};
 

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

@@ -40,6 +40,6 @@ class MaxPotentialFID extends NavigationMetric {
 
 const MaxPotentialFIDComputed = makeComputedArtifact(
   MaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {MaxPotentialFIDComputed as MaxPotentialFID};

package/core/computed/metrics/metric.js

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

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

@@ -35,6 +35,6 @@ class SpeedIndex extends NavigationMetric {
 
 const SpeedIndexComputed = makeComputedArtifact(
   SpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {SpeedIndexComputed as SpeedIndex};

package/core/computed/metrics/time-to-first-byte.js

@@ -58,6 +58,6 @@ class TimeToFirstByte extends NavigationMetric {
 
 const TimeToFirstByteComputed = makeComputedArtifact(
   TimeToFirstByte,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {TimeToFirstByteComputed as TimeToFirstByte};

package/core/computed/metrics/timing-summary.d.ts

@@ -6,6 +6,7 @@ declare const TimingSummaryComputed: typeof TimingSummary & {
         gatherContext: LH.Artifacts["GatherContext"];
         settings: LH.Util.ImmutableObject<LH.Config.Settings>;
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof TimingSummary.compute_>;
 };
 declare class TimingSummary {
@@ -15,15 +16,16 @@ declare class TimingSummary {
        * @param {LH.Artifacts['GatherContext']} gatherContext
        * @param {LH.Util.ImmutableObject<LH.Config.Settings>} settings
        * @param {LH.Artifacts['URL']} URL
+       * @param {LH.Artifacts['SourceMaps']} SourceMaps
        * @param {LH.Artifacts.ComputedContext} context
        * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
        */
-    static summarize(trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts["GatherContext"], settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts["URL"], context: LH.Artifacts.ComputedContext): Promise<{
+    static summarize(trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts["GatherContext"], settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts["URL"], SourceMaps: LH.Artifacts["SourceMaps"], context: LH.Artifacts.ComputedContext): Promise<{
         metrics: LH.Artifacts.TimingSummary;
         debugInfo: Record<string, boolean>;
     }>;
     /**
-     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps']}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
      */
@@ -33,6 +35,7 @@ declare class TimingSummary {
         gatherContext: LH.Artifacts["GatherContext"];
         settings: LH.Util.ImmutableObject<LH.Config.Settings>;
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext): Promise<{
         metrics: LH.Artifacts.TimingSummary;
         debugInfo: Record<string, boolean>;

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

@@ -27,11 +27,12 @@ class TimingSummary {
      * @param {LH.Artifacts['GatherContext']} gatherContext
      * @param {LH.Util.ImmutableObject<LH.Config.Settings>} settings
      * @param {LH.Artifacts['URL']} URL
+     * @param {LH.Artifacts['SourceMaps']} SourceMaps
      * @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, URL, SourceMaps, context) {
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL, SourceMaps};
     /**
      * @template TArtifacts
      * @template TReturn
@@ -135,7 +136,7 @@ class TimingSummary {
     return {metrics, debugInfo};
   }
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
    */
@@ -146,6 +147,7 @@ class TimingSummary {
       data.gatherContext,
       data.settings,
       data.URL,
+      data.SourceMaps,
       context
     );
   }
@@ -153,6 +155,6 @@ class TimingSummary {
 
 const TimingSummaryComputed = makeComputedArtifact(
   TimingSummary,
-  ['devtoolsLog', 'gatherContext', 'settings', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'trace', 'URL', 'SourceMaps']
 );
 export {TimingSummaryComputed as TimingSummary};

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

@@ -71,6 +71,6 @@ class TotalBlockingTime extends ComputedMetric {
 
 const TotalBlockingTimeComputed = makeComputedArtifact(
   TotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL', 'SourceMaps']
 );
 export {TotalBlockingTimeComputed as TotalBlockingTime};

package/core/computed/navigation-insights.d.ts

@@ -3,6 +3,7 @@ declare const NavigationInsightsComputed: typeof NavigationInsights & {
     request: (dependencies: {
         trace: LH.Trace;
         settings: LH.Audit.Context["settings"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationInsights.compute_>;
 };
 /**
@@ -11,12 +12,13 @@ declare const NavigationInsightsComputed: typeof NavigationInsights & {
  */
 declare class NavigationInsights {
     /**
-      * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
+      * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings'], SourceMaps: LH.Artifacts['SourceMaps']}} data
       * @param {LH.Artifacts.ComputedContext} context
      */
     static compute_(data: {
         trace: LH.Trace;
         settings: LH.Audit.Context["settings"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext): Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").InsightSet>;
 }
 //# sourceMappingURL=navigation-insights.d.ts.map

package/core/computed/navigation-insights.js

@@ -14,13 +14,14 @@ import {TraceEngineResult} from './trace-engine-result.js';
  */
 class NavigationInsights {
   /**
-    * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
+    * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings'], SourceMaps: LH.Artifacts['SourceMaps']}} data
     * @param {LH.Artifacts.ComputedContext} context
    */
   static async compute_(data, context) {
-    const {trace, settings} = data;
+    const {trace, settings, SourceMaps} = data;
     const processedTrace = await ProcessedTrace.request(trace, context);
-    const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
+    const traceEngineResult =
+      await TraceEngineResult.request({trace, settings, SourceMaps}, context);
 
     const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
     if (!navigationId) throw new Error('No navigationId found');
@@ -32,5 +33,6 @@ class NavigationInsights {
   }
 }
 
-const NavigationInsightsComputed = makeComputedArtifact(NavigationInsights, ['trace', 'settings']);
+const NavigationInsightsComputed =
+  makeComputedArtifact(NavigationInsights, ['trace', 'settings', 'SourceMaps']);
 export {NavigationInsightsComputed as NavigationInsights};

package/core/computed/page-dependency-graph.d.ts

@@ -5,12 +5,13 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
         devtoolsLog: LH.DevtoolsLog;
         settings: LH.Audit.Context["settings"];
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
         fromTrace?: boolean;
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof PageDependencyGraph.compute_>;
 };
 declare class PageDependencyGraph {
     /**
-     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings'], URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings'], URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps'], fromTrace?: boolean}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Gatherer.Simulation.GraphNode>}
      */
@@ -19,6 +20,7 @@ declare class PageDependencyGraph {
         devtoolsLog: LH.DevtoolsLog;
         settings: LH.Audit.Context["settings"];
         URL: LH.Artifacts["URL"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
         fromTrace?: boolean;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Gatherer.Simulation.GraphNode>;
 }

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

@@ -13,19 +13,20 @@ import {TraceEngineResult} from './trace-engine-result.js';
 
 class PageDependencyGraph {
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings'], URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings'], URL: LH.Artifacts['URL'], SourceMaps: LH.Artifacts['SourceMaps'], fromTrace?: boolean}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Gatherer.Simulation.GraphNode>}
    */
   static async compute_(data, context) {
-    const {trace, settings, devtoolsLog, URL} = data;
+    const {trace, settings, devtoolsLog, URL, SourceMaps} = data;
     const [{mainThreadEvents}, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
     if (data.fromTrace) {
-      const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
+      const traceEngineResult =
+        await TraceEngineResult.request({trace, settings, SourceMaps}, context);
       const traceEngineData = traceEngineResult.data;
       const requests =
         Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
@@ -41,5 +42,5 @@ class PageDependencyGraph {
 }
 
 const PageDependencyGraphComputed = makeComputedArtifact(PageDependencyGraph,
-  ['devtoolsLog', 'settings', 'trace', 'URL', 'fromTrace']);
+  ['devtoolsLog', 'settings', 'trace', 'URL', 'SourceMaps', 'fromTrace']);
 export {PageDependencyGraphComputed as PageDependencyGraph};

package/core/computed/tbt-impact-tasks.js

@@ -239,6 +239,6 @@ class TBTImpactTasks {
 
 const TBTImpactTasksComputed = makeComputedArtifact(
   TBTImpactTasks,
-  ['trace', 'devtoolsLog', 'URL', 'gatherContext', 'settings', 'simulator']
+  ['trace', 'devtoolsLog', 'URL', 'SourceMaps', 'gatherContext', 'settings', 'simulator']
 );
 export {TBTImpactTasksComputed as TBTImpactTasks};