lighthouse 12.4.0-dev.20250312 → 12.4.0-dev.20250313

package/core/audits/byte-efficiency/legacy-javascript.d.ts

@@ -2,13 +2,12 @@ export default LegacyJavascript;
 export type Pattern = {
     name: string;
     expression: string;
-    estimateBytes?: (result: PatternMatchResult) => number;
+    estimateBytes?: (content: string) => number;
 };
 export type PatternMatchResult = {
     name: string;
     line: number;
     column: number;
-    count: number;
 };
 export type ByteEfficiencyProduct = import("./byte-efficiency-audit.js").ByteEfficiencyProduct;
 export type Item = LH.Audit.ByteEfficiencyItem & {
@@ -50,10 +49,11 @@ declare class LegacyJavascript extends ByteEfficiencyAudit {
      */
     static detectAcrossScripts(matcher: CodePatternMatcher, scripts: LH.Artifacts["Scripts"], bundles: LH.Artifacts.Bundle[]): Map<LH.Artifacts.Script, PatternMatchResult[]>;
     /**
+     * @param {LH.Artifacts.Script} script
      * @param {PatternMatchResult[]} matches
      * @return {number}
      */
-    static estimateWastedBytes(matches: PatternMatchResult[]): number;
+    static estimateWastedBytes(script: LH.Artifacts.Script, matches: PatternMatchResult[]): number;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
@@ -70,7 +70,8 @@ export namespace UIStrings {
 import { ByteEfficiencyAudit } from './byte-efficiency-audit.js';
 /**
  * Takes a list of patterns (consisting of a name identifier and a RegExp expression string)
- * and returns match results with line / column information for a given code input.
+ * and via `match` returns match results with line / column information for a given code input.
+ * Only returns the first match per pattern given.
  */
 declare class CodePatternMatcher {
     /**

package/core/audits/byte-efficiency/legacy-javascript.js

@@ -11,8 +11,8 @@
  * ./core/scripts/legacy-javascript - verification tool.
  */
 
-/** @typedef {{name: string, expression: string, estimateBytes?: (result: PatternMatchResult) => number}} Pattern */
-/** @typedef {{name: string, line: number, column: number, count: number}} PatternMatchResult */
+/** @typedef {{name: string, expression: string, estimateBytes?: (content: string) => number}} Pattern */
+/** @typedef {{name: string, line: number, column: number}} PatternMatchResult */
 /** @typedef {import('./byte-efficiency-audit.js').ByteEfficiencyProduct} ByteEfficiencyProduct */
 /** @typedef {LH.Audit.ByteEfficiencyItem & {subItems: {type: 'subitems', items: SubItem[]}}} Item */
 /** @typedef {{signal: string, location: LH.Audit.Details.SourceLocationValue}} SubItem */
@@ -55,7 +55,8 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
 /**
  * Takes a list of patterns (consisting of a name identifier and a RegExp expression string)
- * and returns match results with line / column information for a given code input.
+ * and via `match` returns match results with line / column information for a given code input.
+ * Only returns the first match per pattern given.
  */
 class CodePatternMatcher {
   /**
@@ -99,8 +100,6 @@ class CodePatternMatcher {
       const pattern = this.patterns[patternExpressionMatches.findIndex(Boolean)];
 
       if (seen.has(pattern)) {
-        const existingMatch = matches.find(m => m.name === pattern.name);
-        if (existingMatch) existingMatch.count += 1;
         continue;
       }
       seen.add(pattern);
@@ -109,7 +108,6 @@ class CodePatternMatcher {
         name: pattern.name,
         line,
         column: result.index - lineBeginsAtIndex,
-        count: 1,
       });
     }
 
@@ -229,23 +227,74 @@ class LegacyJavascript extends ByteEfficiencyAudit {
    * @return {Pattern[]}
    */
   static getTransformPatterns() {
+    /**
+     * @param {string} content
+     * @param {RegExp|string} pattern
+     * @return {number}
+     */
+    const count = (content, pattern) => {
+      // Split is slightly faster than match.
+      if (typeof pattern === 'string') {
+        return content.split(pattern).length - 1;
+      }
+
+      return (content.match(pattern) ?? []).length;
+    };
+
+    // For expression: prefer a string that is found in the transform runtime support code (those won't ever be minified).
+
     return [
+      // @babel/plugin-transform-classes
+      //
+      // input:
+      //
+      // class MyTestClass {
+      //   log() {
+      //     console.log(1);
+      //   }
+      // };
+      //
+      // output:
+      //
+      // function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+      // function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+      // function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+      // function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+      // function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+      // let MyTestClass = function () {
+      //   function MyTestClass() {
+      //     _classCallCheck(this, MyTestClass);
+      //   }
+      //   return _createClass(MyTestClass, [{
+      //     key: "log",
+      //     value: function log() {
+      //       console.log(1);
+      //     }
+      //   }]);
+      // }();
       {
         name: '@babel/plugin-transform-classes',
         expression: 'Cannot call a class as a function',
-        estimateBytes: result => 150 + result.count * '_classCallCheck()'.length,
+        estimateBytes: content => {
+          return 1000 + (count(content, '_classCallCheck') - 1) * '_classCallCheck()'.length;
+        },
       },
       {
         name: '@babel/plugin-transform-regenerator',
-        expression: /regeneratorRuntime\(?\)?\.a?wrap/.source,
+        expression: 'Generator is already running|regeneratorRuntime',
         // Example of this transform: https://gist.github.com/connorjclark/af8bccfff377ac44efc104a79bc75da2
         // `regeneratorRuntime.awrap` is generated for every usage of `await`, and adds ~80 bytes each.
-        estimateBytes: result => result.count * 80,
+        estimateBytes: content => {
+          return count(content, /regeneratorRuntime\(?\)?\.a?wrap/g) * 80;
+        },
       },
       {
         name: '@babel/plugin-transform-spread',
-        expression: /\.apply\(void 0,\s?_toConsumableArray/.source,
-        estimateBytes: result => 1169 + result.count * '_toConsumableArray()'.length,
+        expression: 'Invalid attempt to spread non-iterable instance',
+        estimateBytes: content => {
+          const per = '_toConsumableArray()'.length;
+          return 1169 + count(content, /\.apply\(void 0,\s?_toConsumableArray/g) * per;
+        },
       },
     ];
   }
@@ -283,9 +332,9 @@ class LegacyJavascript extends ByteEfficiencyAudit {
 
           const mapping = bundle.map.mappings().find(m => m.sourceURL === source);
           if (mapping) {
-            matches.push({name, line: mapping.lineNumber, column: mapping.columnNumber, count: 1});
+            matches.push({name, line: mapping.lineNumber, column: mapping.columnNumber});
           } else {
-            matches.push({name, line: 0, column: 0, count: 1});
+            matches.push({name, line: 0, column: 0});
           }
         }
       }
@@ -298,10 +347,11 @@ class LegacyJavascript extends ByteEfficiencyAudit {
   }
 
   /**
+   * @param {LH.Artifacts.Script} script
    * @param {PatternMatchResult[]} matches
    * @return {number}
    */
-  static estimateWastedBytes(matches) {
+  static estimateWastedBytes(script, matches) {
     // Split up results based on polyfill / transform. Only transforms start with @.
     const polyfillResults = matches.filter(m => !m.name.startsWith('@'));
     const transformResults = matches.filter(m => m.name.startsWith('@'));
@@ -325,8 +375,8 @@ class LegacyJavascript extends ByteEfficiencyAudit {
 
     for (const result of transformResults) {
       const pattern = this.getTransformPatterns().find(p => p.name === result.name);
-      if (!pattern || !pattern.estimateBytes) continue;
-      estimatedWastedBytesFromTransforms += pattern.estimateBytes(result);
+      if (!pattern || !pattern.estimateBytes || !script.content) continue;
+      estimatedWastedBytesFromTransforms += pattern.estimateBytes(script.content);
     }
 
     const estimatedWastedBytes =
@@ -363,7 +413,7 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     for (const [script, matches] of scriptToMatchResults.entries()) {
       const compressionRatio = estimateCompressionRatioForContent(
         compressionRatioByUrl, script.url, artifacts, networkRecords);
-      const wastedBytes = Math.round(this.estimateWastedBytes(matches) * compressionRatio);
+      const wastedBytes = Math.round(this.estimateWastedBytes(script, matches) * compressionRatio);
       /** @type {typeof items[number]} */
       const item = {
         url: script.url,

package/core/audits/byte-efficiency/render-blocking-resources.js

@@ -122,13 +122,14 @@ class RenderBlockingResources extends Audit {
    * @return {Promise<{fcpWastedMs: number, lcpWastedMs: number, results: Array<{url: string, totalBytes: number, wastedMs: number}>}>}
    */
   static async computeResults(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 simulatorData = {devtoolsLog, settings: context.settings};
     const simulator = await LoadSimulator.request(simulatorData, context);
     const wastedCssBytes = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
-    const navInsights = await NavigationInsights.request(trace, context);
+    const navInsights = await NavigationInsights.request({trace, settings}, context);
 
     const renderBlocking = navInsights.model.RenderBlocking;
     if (renderBlocking instanceof Error) throw renderBlocking;

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

@@ -168,10 +168,11 @@ class CriticalRequestChains extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
+    const settings = context.settings;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
-    const chains = await ComputedChains.request({devtoolsLog, trace, URL}, context);
+    const chains = await ComputedChains.request({settings, devtoolsLog, trace, URL}, context);
     let chainCount = 0;
     /**
      * @param {LH.Audit.Details.SimpleCriticalRequestNode} node

package/core/audits/insights/insight-audit.js

@@ -16,9 +16,10 @@ import {Audit} from '../audit.js';
  * @return {Promise<import('@paulirish/trace_engine/models/trace/insights/types.js').InsightSet|undefined>}
  */
 async function getInsightSet(artifacts, context) {
+  const settings = context.settings;
   const trace = artifacts.traces[Audit.DEFAULT_PASS];
   const processedTrace = await ProcessedTrace.request(trace, context);
-  const traceEngineResult = await TraceEngineResult.request({trace}, context);
+  const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
 
   const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
   const key = navigationId ?? NO_NAVIGATION;

package/core/audits/layout-shifts.js

@@ -57,8 +57,9 @@ class LayoutShifts extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
+    const settings = context.settings;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    const traceEngineResult = await TraceEngineResult.request({trace}, context);
+    const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
     const clusters = traceEngineResult.data.LayoutShifts.clusters ?? [];
     const {cumulativeLayoutShift: clsSavings, impactByNodeId} =
       await CumulativeLayoutShiftComputed.request(trace, context);

package/core/audits/long-tasks.js

@@ -192,7 +192,8 @@ class LongTasks extends Audit {
       taskTimingsByEvent = new Map();
 
       const simulatorOptions = {devtoolsLog, settings: context.settings};
-      const pageGraph = await PageDependencyGraph.request({trace, devtoolsLog, URL}, context);
+      const pageGraph =
+        await PageDependencyGraph.request({settings, trace, devtoolsLog, URL}, context);
       const simulator = await LoadSimulator.request(simulatorOptions, context);
       const simulation = await simulator.simulate(pageGraph, {label: 'long-tasks-diagnostic'});
       for (const [node, timing] of simulation.nodeTimings.entries()) {

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

@@ -114,8 +114,12 @@ class ScriptTreemapDataAudit extends Audit {
      */
     function collapseAll(node) {
       while (node.children && node.children.length === 1) {
-        node.name += '/' + node.children[0].name;
-        node.children = node.children[0].children;
+        const child = node.children[0];
+        node.name += '/' + child.name;
+        if (child.duplicatedNormalizedModuleName) {
+          node.duplicatedNormalizedModuleName = child.duplicatedNormalizedModuleName;
+        }
+        node.children = child.children;
       }
 
       if (node.children) {

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

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

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

@@ -212,6 +212,7 @@ class UsesRelPreloadAudit extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
+    const settings = context.settings;
     const trace = artifacts.traces[UsesRelPreloadAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreloadAudit.DEFAULT_PASS];
     const URL = artifacts.URL;
@@ -219,7 +220,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({settings, trace, devtoolsLog, URL}, context),
       LoadSimulator.request(simulatorOptions, context),
     ]);
 

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

@@ -4,6 +4,7 @@ declare const CriticalRequestChainsComputed: typeof CriticalRequestChains & {
         URL: LH.Artifacts["URL"];
         devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof CriticalRequestChains.compute_>;
 };
 declare class CriticalRequestChains {
@@ -24,7 +25,7 @@ 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}} data
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Artifacts.CriticalRequestNode>}
      */
@@ -32,6 +33,7 @@ declare class CriticalRequestChains {
         URL: LH.Artifacts["URL"];
         devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.CriticalRequestNode>;
 }
 import * as Lantern from '../lib/lantern/lantern.js';

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

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

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

@@ -1,6 +1,9 @@
 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"];
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationInsights.compute_>;
 };
 /**
  * @fileoverview Gets insights from the shared trace engine for the navigation audited by Lighthouse.
@@ -8,9 +11,12 @@ declare const NavigationInsightsComputed: typeof NavigationInsights & {
  */
 declare class NavigationInsights {
     /**
-      * @param {LH.Trace} trace
+      * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} 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"];
+    }, 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,13 @@ import {TraceEngineResult} from './trace-engine-result.js';
  */
 class NavigationInsights {
   /**
-    * @param {LH.Trace} trace
+    * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
     * @param {LH.Artifacts.ComputedContext} context
    */
-  static async compute_(trace, context) {
+  static async compute_(data, context) {
+    const {trace, settings} = data;
     const processedTrace = await ProcessedTrace.request(trace, context);
-    const traceEngineResult = await TraceEngineResult.request({trace}, context);
+    const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
 
     const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
     if (!navigationId) throw new Error('No navigationId found');
@@ -31,5 +32,5 @@ class NavigationInsights {
   }
 }
 
-const NavigationInsightsComputed = makeComputedArtifact(NavigationInsights, null);
+const NavigationInsightsComputed = makeComputedArtifact(NavigationInsights, ['trace', 'settings']);
 export {NavigationInsightsComputed as NavigationInsights};

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

@@ -3,19 +3,21 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     request: (dependencies: {
         trace: LH.Trace;
         devtoolsLog: LH.DevtoolsLog;
+        settings: LH.Audit.Context["settings"];
         URL: LH.Artifacts["URL"];
         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'], 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;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Gatherer.Simulation.GraphNode>;

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

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

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

@@ -2,6 +2,7 @@ export { TraceEngineResultComputed as TraceEngineResult };
 declare const TraceEngineResultComputed: typeof TraceEngineResult & {
     request: (dependencies: {
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
     }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof TraceEngineResult.compute_>;
 };
 /**
@@ -10,9 +11,10 @@ declare const TraceEngineResultComputed: typeof TraceEngineResult & {
 declare class TraceEngineResult {
     /**
      * @param {LH.TraceEvent[]} traceEvents
+     * @param {LH.Audit.Context['settings']} settings
      * @return {Promise<LH.Artifacts.TraceEngineResult>}
      */
-    static runTraceEngine(traceEvents: LH.TraceEvent[]): Promise<LH.Artifacts.TraceEngineResult>;
+    static runTraceEngine(traceEvents: LH.TraceEvent[], settings: LH.Audit.Context["settings"]): Promise<LH.Artifacts.TraceEngineResult>;
     /**
      * Adapts the given DevTools function that returns a localized string to one
      * that returns a LH.IcuMessage.
@@ -45,12 +47,13 @@ declare class TraceEngineResult {
      */
     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']}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Artifacts.TraceEngineResult>}
      */
     static compute_(data: {
         trace: LH.Trace;
+        settings: LH.Audit.Context["settings"];
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.TraceEngineResult>;
 }
 import * as LH from '../../types/lh.js';

package/core/computed/trace-engine-result.js

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import log from 'lighthouse-logger';
+
 import * as i18n from '../lib/i18n/i18n.js';
 import * as TraceEngine from '../lib/trace-engine.js';
 import {makeComputedArtifact} from './computed-artifact.js';
@@ -17,15 +19,35 @@ import * as LH from '../../types/lh.js';
 class TraceEngineResult {
   /**
    * @param {LH.TraceEvent[]} traceEvents
+   * @param {LH.Audit.Context['settings']} settings
    * @return {Promise<LH.Artifacts.TraceEngineResult>}
    */
-  static async runTraceEngine(traceEvents) {
+  static async runTraceEngine(traceEvents, settings) {
     const processor = new TraceEngine.TraceProcessor(TraceEngine.TraceHandlers);
 
+    const lanternSettings = {};
+    if (settings.throttlingMethod) lanternSettings.throttlingMethod = settings.throttlingMethod;
+    if (settings.throttling) lanternSettings.throttling = settings.throttling;
+    if (settings.precomputedLanternData) {
+      lanternSettings.precomputedLanternData = settings.precomputedLanternData;
+    }
+
     // eslint-disable-next-line max-len
     await processor.parse(/** @type {import('@paulirish/trace_engine').Types.Events.Event[]} */ (
       traceEvents
-    ), {});
+    ), {
+      logger: {
+        start(id) {
+          const logId = `lh:computed:TraceEngineResult:${id}`;
+          log.time({msg: `Trace Engine ${id}`, id: logId});
+        },
+        end(id) {
+          const logId = `lh:computed:TraceEngineResult:${id}`;
+          log.timeEnd({msg: `Trace Engine ${id}`, id: logId});
+        },
+      },
+      lanternSettings,
+    });
     if (!processor.parsedTrace) throw new Error('No data');
     if (!processor.insights) throw new Error('No insights');
     this.localizeInsights(processor.insights);
@@ -177,7 +199,7 @@ class TraceEngineResult {
   }
 
   /**
-   * @param {{trace: LH.Trace}} data
+   * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.TraceEngineResult>}
    */
@@ -207,10 +229,10 @@ class TraceEngineResult {
       }
     }
 
-    const result = await TraceEngineResult.runTraceEngine(traceEvents);
+    const result = await TraceEngineResult.runTraceEngine(traceEvents, data.settings);
     return result;
   }
 }
 
-const TraceEngineResultComputed = makeComputedArtifact(TraceEngineResult, ['trace']);
+const TraceEngineResultComputed = makeComputedArtifact(TraceEngineResult, ['trace', 'settings']);
 export {TraceEngineResultComputed as TraceEngineResult};

package/core/gather/gatherers/trace-elements.js

@@ -386,7 +386,8 @@ class TraceElements extends BaseGatherer {
     const session = context.driver.defaultSession;
 
     const trace = context.dependencies.Trace;
-    const traceEngineResult = await TraceEngineResult.request({trace}, context);
+    const settings = context.settings;
+    const traceEngineResult = await TraceEngineResult.request({trace, settings}, context);
     const rootCauses = context.dependencies.RootCauses;
 
     const processedTrace = await ProcessedTrace.request(trace, context);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "12.4.0-dev.20250312",
+  "version": "12.4.0-dev.20250313",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -184,7 +184,7 @@
     "webtreemap-cdt": "^3.2.1"
   },
   "dependencies": {
-    "@paulirish/trace_engine": "0.0.47",
+    "@paulirish/trace_engine": "0.0.48",
     "@sentry/node": "^7.0.0",
     "axe-core": "^4.10.2",
     "chrome-launcher": "^1.1.2",