lighthouse 12.4.0 → 12.5.0-dev.20250325

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

@@ -126,18 +126,18 @@ class CriticalRequestChains {
   }
 
   /**
-   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace}} 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 async compute_(data, context) {
     const mainResource = await MainResource.request(data, context);
-    const graph = await PageDependencyGraph.request(data, context);
+    const graph = await PageDependencyGraph.request({...data, fromTrace: false}, context);
 
     return CriticalRequestChains.extractChainsFromGraph(mainResource, graph);
   }
 }
 
-const CriticalRequestChainsComputed =
-  makeComputedArtifact(CriticalRequestChains, ['URL', 'devtoolsLog', 'trace']);
+const CriticalRequestChainsComputed = makeComputedArtifact(CriticalRequestChains,
+  ['URL', 'SourceMaps', 'devtoolsLog', 'trace', 'settings']);
 export {CriticalRequestChainsComputed as CriticalRequestChains};

package/core/computed/js-bundles.d.ts

@@ -1,6 +1,6 @@
 export { JSBundlesComputed as JSBundles };
 declare const JSBundlesComputed: typeof JSBundles & {
-    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: LH.Artifacts.ComputedContext) => ReturnType<typeof JSBundles.compute_>;
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: LH.Artifacts.ComputedContext) => ReturnType<typeof JSBundles.compute_>;
 };
 declare class JSBundles {
     /**

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-metric.js

@@ -20,7 +20,7 @@ async function getComputationDataParamsFromDevtoolsLog(data, context) {
     throw new Error(`Lantern metrics can only be computed on navigations`);
   }
 
-  const graph = await PageDependencyGraph.request(data, context);
+  const graph = await PageDependencyGraph.request({...data, fromTrace: false}, context);
   const processedNavigation = await ProcessedNavigation.request(data.trace, context);
   const simulator = data.simulator || (await LoadSimulator.request(data, context));
 

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,8 @@ class Metric {
       gatherContext: data.gatherContext,
       settings: data.settings,
       URL: data.URL,
+      SourceMaps: data.SourceMaps,
+      simulator: null,
     };
   }
 

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,14 @@ 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, simulator: null};
+
     /**
      * @template TArtifacts
      * @template TReturn
@@ -135,7 +138,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 +149,7 @@ class TimingSummary {
       data.gatherContext,
       data.settings,
       data.URL,
+      data.SourceMaps,
       context
     );
   }
@@ -153,6 +157,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/module-duplication.d.ts

@@ -1,6 +1,6 @@
 export { ModuleDuplicationComputed as ModuleDuplication };
 declare const ModuleDuplicationComputed: typeof ModuleDuplication & {
-    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: LH.Artifacts.ComputedContext) => ReturnType<typeof ModuleDuplication.compute_>;
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: LH.Artifacts.ComputedContext) => ReturnType<typeof ModuleDuplication.compute_>;
 };
 declare class ModuleDuplication {
     /**

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

@@ -1,6 +1,10 @@
 export { NavigationInsightsComputed as NavigationInsights };
 declare const NavigationInsightsComputed: typeof NavigationInsights & {
-    request: (dependencies: import("../index.js").Trace, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationInsights.compute_>;
+    request: (dependencies: {
+        trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationInsights.compute_>;
 };
 /**
  * @fileoverview Gets insights from the shared trace engine for the navigation audited by Lighthouse.
@@ -8,9 +12,13 @@ declare const NavigationInsightsComputed: typeof NavigationInsights & {
  */
 declare class NavigationInsights {
     /**
-      * @param {LH.Trace} trace
+      * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings'], SourceMaps: LH.Artifacts['SourceMaps']}} data
       * @param {LH.Artifacts.ComputedContext} context
      */
-    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").InsightSet>;
+    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,12 +14,14 @@ import {TraceEngineResult} from './trace-engine-result.js';
  */
 class NavigationInsights {
   /**
-    * @param {LH.Trace} trace
+    * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings'], SourceMaps: LH.Artifacts['SourceMaps']}} data
     * @param {LH.Artifacts.ComputedContext} context
    */
-  static async compute_(trace, context) {
+  static async compute_(data, context) {
+    const {trace, settings, SourceMaps} = data;
     const processedTrace = await ProcessedTrace.request(trace, context);
-    const traceEngineResult = await TraceEngineResult.request({trace}, 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');
@@ -31,5 +33,6 @@ class NavigationInsights {
   }
 }
 
-const NavigationInsightsComputed = makeComputedArtifact(NavigationInsights, null);
+const NavigationInsightsComputed =
+  makeComputedArtifact(NavigationInsights, ['trace', 'settings', 'SourceMaps']);
 export {NavigationInsightsComputed as NavigationInsights};

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

@@ -3,21 +3,25 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     request: (dependencies: {
         trace: LH.Trace;
         devtoolsLog: LH.DevtoolsLog;
+        settings: LH.Audit.Context["settings"];
         URL: LH.Artifacts["URL"];
-        fromTrace?: boolean;
+        SourceMaps: LH.Artifacts["SourceMaps"];
+        fromTrace: boolean;
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof PageDependencyGraph.compute_>;
 };
 declare class PageDependencyGraph {
     /**
-     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, 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 compute_(data: {
         trace: LH.Trace;
         devtoolsLog: LH.DevtoolsLog;
+        settings: LH.Audit.Context["settings"];
         URL: LH.Artifacts["URL"];
-        fromTrace?: boolean;
+        SourceMaps: LH.Artifacts["SourceMaps"];
+        fromTrace: boolean;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Gatherer.Simulation.GraphNode>;
 }
 //# sourceMappingURL=page-dependency-graph.d.ts.map

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, 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, 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}, context);
+      const traceEngineResult =
+        await TraceEngineResult.request({trace, settings, SourceMaps}, context);
       const traceEngineData = traceEngineResult.data;
       const requests =
         Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
@@ -40,6 +41,6 @@ class PageDependencyGraph {
   }
 }
 
-const PageDependencyGraphComputed =
-  makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL', 'fromTrace']);
+const PageDependencyGraphComputed = makeComputedArtifact(PageDependencyGraph,
+  ['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};

package/core/computed/trace-engine-result.d.ts

@@ -2,6 +2,8 @@ export { TraceEngineResultComputed as TraceEngineResult };
 declare const TraceEngineResultComputed: typeof TraceEngineResult & {
     request: (dependencies: {
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof TraceEngineResult.compute_>;
 };
 /**
@@ -10,21 +12,53 @@ declare const TraceEngineResultComputed: typeof TraceEngineResult & {
 declare class TraceEngineResult {
     /**
      * @param {LH.TraceEvent[]} traceEvents
+     * @param {LH.Audit.Context['settings']} settings
+     * @param {LH.Artifacts['SourceMaps']} SourceMaps
      * @return {Promise<LH.Artifacts.TraceEngineResult>}
      */
-    static runTraceEngine(traceEvents: LH.TraceEvent[]): Promise<LH.Artifacts.TraceEngineResult>;
+    static runTraceEngine(traceEvents: LH.TraceEvent[], settings: LH.Audit.Context["settings"], SourceMaps: LH.Artifacts["SourceMaps"]): Promise<LH.Artifacts.TraceEngineResult>;
+    /**
+     * Adapts the given DevTools function that returns a localized string to one
+     * that returns a LH.IcuMessage.
+     *
+     * @template {any[]} Args
+     * @template {import('../lib/trace-engine.js').DevToolsIcuMessage} Ret
+     * @param {ReturnType<i18n.createIcuMessageFn>} str_
+     * @param {(...args: Args) => Ret} fn
+     * @return {(...args: Args) => LH.IcuMessage}
+     */
+    static localizeFunction<Args extends any[], Ret extends import("../lib/trace-engine.js").DevToolsIcuMessage>(str_: ReturnType<typeof i18n.createIcuMessageFn>, fn: (...args: Args) => Ret): (...args: Args) => LH.IcuMessage;
+    /**
+     * Converts the input parameters given to `i18nString` usages in DevTools to a
+     * LH.IcuMessage.
+     *
+     * @param {ReturnType<i18n.createIcuMessageFn>} str_
+     * @param {import('../lib/trace-engine.js').DevToolsIcuMessage} traceEngineI18nObject
+     * @return {LH.IcuMessage}
+     */
+    static localize(str_: ReturnType<typeof i18n.createIcuMessageFn>, traceEngineI18nObject: import("../lib/trace-engine.js").DevToolsIcuMessage): LH.IcuMessage;
+    /**
+     * Recursively finds all DevToolsIcuMessage objects and replaces them with LH.IcuMessage.
+     *
+     * @param {ReturnType<i18n.createIcuMessageFn>} str_
+     * @param {object} object
+     */
+    static localizeObject(str_: ReturnType<typeof i18n.createIcuMessageFn>, object: object): void;
     /**
      * @param {import('@paulirish/trace_engine/models/trace/insights/types.js').TraceInsightSets} insightSets
      */
     static localizeInsights(insightSets: import("@paulirish/trace_engine/models/trace/insights/types.js").TraceInsightSets): void;
     /**
-     * @param {{trace: LH.Trace}} data
+     * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings'], SourceMaps: LH.Artifacts['SourceMaps']}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Artifacts.TraceEngineResult>}
      */
     static compute_(data: {
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
+        SourceMaps: LH.Artifacts["SourceMaps"];
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.TraceEngineResult>;
 }
 import * as LH from '../../types/lh.js';
+import * as i18n from '../lib/i18n/i18n.js';
 //# sourceMappingURL=trace-engine-result.d.ts.map