lighthouse 11.7.1 → 12.0.0

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

@@ -4,83 +4,23 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {TotalBlockingTime} from '../../lib/lantern/metrics/total-blocking-time.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 import {LanternInteractive} from './lantern-interactive.js';
-import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from './tbt-utils.js';
+import {getComputationDataParams} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternTotalBlockingTime extends LanternMetric {
+class LanternTotalBlockingTime extends TotalBlockingTime {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('../../lib/lantern/metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
    */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.interactiveResult) throw new Error('missing interactiveResult');
-
-    // Intentionally use the opposite FCP estimate. A pessimistic FCP is higher than equal to an
-    // optimistic FCP, which means potentially more tasks are excluded from the Total Blocking Time
-    // computation. So a more pessimistic FCP gives a more optimistic Total Blocking Time for the
-    // same work.
-    const fcpTimeInMs = extras.optimistic
-      ? extras.fcpResult.pessimisticEstimate.timeInMs
-      : extras.fcpResult.optimisticEstimate.timeInMs;
-
-    // Similarly, we always have pessimistic TTI >= optimistic TTI. Therefore, picking optimistic
-    // TTI means our window of interest is smaller and thus potentially more tasks are excluded from
-    // Total Blocking Time computation, yielding a lower (more optimistic) Total Blocking Time value
-    // for the same work.
-    const interactiveTimeMs = extras.optimistic
-      ? extras.interactiveResult.optimisticEstimate.timeInMs
-      : extras.interactiveResult.pessimisticEstimate.timeInMs;
-
-    const minDurationMs = BLOCKING_TIME_THRESHOLD;
-
-    const events = LanternTotalBlockingTime.getTopLevelEvents(
-      simulation.nodeTimings,
-      minDurationMs
-    );
-
-    return {
-      timeInMs: calculateSumOfBlockingTime(
-        events,
-        fcpTimeInMs,
-        interactiveTimeMs
-      ),
-      nodeTimings: simulation.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras);
   }
 
   /**
@@ -93,30 +33,6 @@ class LanternTotalBlockingTime extends LanternMetric {
     const interactiveResult = await LanternInteractive.request(data, context);
     return this.computeMetricWithGraphs(data, context, {fcpResult, interactiveResult});
   }
-
-  /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} minDurationMs
-   */
-  static getTopLevelEvents(nodeTimings, minDurationMs) {
-    /** @type {Array<{start: number, end: number, duration: number}>}
-     */
-    const events = [];
-
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
-      // Filtering out events below minimum duration.
-      if (timing.duration < minDurationMs) continue;
-
-      events.push({
-        start: timing.startTime,
-        end: timing.endTime,
-        duration: timing.duration,
-      });
-    }
-
-    return events;
-  }
 }
 
 const LanternTotalBlockingTimeComputed = makeComputedArtifact(

package/core/computed/metrics/metric.js

@@ -61,9 +61,7 @@ class Metric {
    * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
    */
   static async compute_(data, context) {
-    // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
-    const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
-    const {trace, devtoolsLog, settings} = data;
+    const {trace, devtoolsLog, settings, gatherContext} = data;
     if (!trace || !devtoolsLog || !settings) {
       throw new Error('Did not provide necessary metric computation data');
     }

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, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<Map<string, {
         scriptId: string;

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

@@ -0,0 +1,36 @@
+export { NavigationInsightsComputed as NavigationInsights };
+declare const NavigationInsightsComputed: typeof NavigationInsights & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<{
+        AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
+        Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
+        LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
+        NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
+        Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
+        Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
+        Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
+        PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+    }>>;
+};
+/**
+ * @fileoverview Gets insights from the shared trace engine for the navigation audited by Lighthouse.
+ * Only usable in navigation mode.
+ */
+declare class NavigationInsights {
+    /**
+      * @param {LH.Trace} trace
+      * @param {LH.Artifacts.ComputedContext} context
+     */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<{
+        AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
+        Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
+        LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
+        NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
+        Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
+        Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
+        Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
+        PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+    }>>;
+}
+//# sourceMappingURL=navigation-insights.d.ts.map

package/core/computed/navigation-insights.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {makeComputedArtifact} from './computed-artifact.js';
+import {ProcessedTrace} from './processed-trace.js';
+import {TraceEngineResult} from './trace-engine-result.js';
+
+/**
+ * @fileoverview Gets insights from the shared trace engine for the navigation audited by Lighthouse.
+ * Only usable in navigation mode.
+ */
+class NavigationInsights {
+  /**
+    * @param {LH.Trace} trace
+    * @param {LH.Artifacts.ComputedContext} context
+   */
+  static async compute_(trace, context) {
+    const processedTrace = await ProcessedTrace.request(trace, context);
+    const traceEngineResult = await TraceEngineResult.request({trace}, context);
+
+    const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
+    if (!navigationId) throw new Error('No navigationId found');
+
+    const navInsights = traceEngineResult.insights.get(navigationId);
+    if (!navInsights) throw new Error('No navigations insights found');
+
+    return navInsights;
+  }
+}
+
+const NavigationInsightsComputed = makeComputedArtifact(NavigationInsights, null);
+export {NavigationInsightsComputed as NavigationInsights};

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

@@ -9,7 +9,6 @@ import {PageDependencyGraph as LanternPageDependencyGraph} from '../lib/lantern/
 import {NetworkRequest} from '../lib/network-request.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
-import {DocumentUrls} from './document-urls.js';
 
 /** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
@@ -20,18 +19,15 @@ class PageDependencyGraph {
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
-    const {trace, devtoolsLog} = data;
+    const {trace, devtoolsLog, URL} = data;
     const [processedTrace, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    // COMPAT: Backport for pre-10.0 clients that don't pass the URL artifact here (e.g. pubads).
-    // Calculates the URL artifact from the processed trace and DT log.
-    const URL = data.URL || await DocumentUrls.request(data, context);
-
+    const mainThreadEvents = processedTrace.mainThreadEvents;
     const lanternRequests = networkRecords.map(NetworkRequest.asLanternNetworkRequest);
-    return LanternPageDependencyGraph.createGraph(processedTrace, lanternRequests, URL);
+    return LanternPageDependencyGraph.createGraph(mainThreadEvents, lanternRequests, URL);
   }
 }
 

package/core/computed/resource-summary.d.ts

@@ -4,42 +4,40 @@ export type ResourceEntry = {
     resourceSize: number;
     transferSize: number;
 };
+export type ResourceType = 'stylesheet' | 'image' | 'media' | 'font' | 'script' | 'document' | 'other' | 'third-party' | 'total';
 declare const ResourceSummaryComputed: typeof ResourceSummary & {
     request: (dependencies: {
         URL: LH.Artifacts['URL'];
         devtoolsLog: import("../index.js").DevtoolsLog;
-        budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<Record<import("../../types/lhr/budget.js").default.ResourceType, ResourceEntry>>;
+    }>) => Promise<Record<ResourceType, ResourceEntry>>;
 };
 /** @typedef {{count: number, resourceSize: number, transferSize: number}} ResourceEntry */
+/** @typedef {'stylesheet'|'image'|'media'|'font'|'script'|'document'|'other'|'third-party'|'total'} ResourceType */
 declare class ResourceSummary {
     /**
      * @param {LH.Artifacts.NetworkRequest} record
-     * @return {LH.Budget.ResourceType}
+     * @return {ResourceType}
      */
-    static determineResourceType(record: LH.Artifacts.NetworkRequest): LH.Budget.ResourceType;
+    static determineResourceType(record: LH.Artifacts.NetworkRequest): ResourceType;
     /**
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
      * @param {LH.Artifacts.URL} URLArtifact
-     * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
      * @param {LH.Artifacts.EntityClassification} classifiedEntities
-     * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
+     * @return {Record<ResourceType, ResourceEntry>}
      */
-    static summarize(networkRecords: Array<LH.Artifacts.NetworkRequest>, URLArtifact: LH.Artifacts.URL, budgets: LH.Util.ImmutableObject<LH.Budget[] | null>, classifiedEntities: LH.Artifacts.EntityClassification): Record<LH.Budget.ResourceType, ResourceEntry>;
+    static summarize(networkRecords: Array<LH.Artifacts.NetworkRequest>, URLArtifact: LH.Artifacts.URL, classifiedEntities: LH.Artifacts.EntityClassification): Record<ResourceType, ResourceEntry>;
     /**
-     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: LH.Util.ImmutableObject<LH.Budget[]|null>}} data
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<Record<LH.Budget.ResourceType,ResourceEntry>>}
+     * @return {Promise<Record<ResourceType,ResourceEntry>>}
      */
     static compute_(data: {
         URL: LH.Artifacts['URL'];
         devtoolsLog: import("../index.js").DevtoolsLog;
-        budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
-    }, context: LH.Artifacts.ComputedContext): Promise<Record<LH.Budget.ResourceType, ResourceEntry>>;
+    }, context: LH.Artifacts.ComputedContext): Promise<Record<ResourceType, ResourceEntry>>;
 }
-import { Budget } from '../config/budget.js';
 import { NetworkRequest } from '../lib/network-request.js';
 import { EntityClassification } from './entity-classification.js';
 //# sourceMappingURL=resource-summary.d.ts.map

package/core/computed/resource-summary.js

@@ -8,19 +8,19 @@ import {EntityClassification} from './entity-classification.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRecords} from './network-records.js';
 import {NetworkRequest} from '../lib/network-request.js';
-import {Budget} from '../config/budget.js';
 import UrlUtils from '../lib/url-utils.js';
 
 /** @typedef {{count: number, resourceSize: number, transferSize: number}} ResourceEntry */
+/** @typedef {'stylesheet'|'image'|'media'|'font'|'script'|'document'|'other'|'third-party'|'total'} ResourceType */
 
 class ResourceSummary {
   /**
    * @param {LH.Artifacts.NetworkRequest} record
-   * @return {LH.Budget.ResourceType}
+   * @return {ResourceType}
    */
   static determineResourceType(record) {
     if (!record.resourceType) return 'other';
-    /** @type {Partial<Record<LH.Crdp.Network.ResourceType, LH.Budget.ResourceType>>} */
+    /** @type {Partial<Record<LH.Crdp.Network.ResourceType, ResourceType>>} */
     const requestToResourceType = {
       'Stylesheet': 'stylesheet',
       'Image': 'image',
@@ -35,12 +35,11 @@ class ResourceSummary {
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @param {LH.Artifacts.URL} URLArtifact
-   * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
    * @param {LH.Artifacts.EntityClassification} classifiedEntities
-   * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
+   * @return {Record<ResourceType, ResourceEntry>}
    */
-  static summarize(networkRecords, URLArtifact, budgets, classifiedEntities) {
-    /** @type {Record<LH.Budget.ResourceType, ResourceEntry>} */
+  static summarize(networkRecords, URLArtifact, classifiedEntities) {
+    /** @type {Record<ResourceType, ResourceEntry>} */
     const resourceSummary = {
       'stylesheet': {count: 0, resourceSize: 0, transferSize: 0},
       'image': {count: 0, resourceSize: 0, transferSize: 0},
@@ -52,15 +51,9 @@ class ResourceSummary {
       'total': {count: 0, resourceSize: 0, transferSize: 0},
       'third-party': {count: 0, resourceSize: 0, transferSize: 0},
     };
-    const budget = Budget.getMatchingBudget(budgets, URLArtifact.mainDocumentUrl);
     /** @type {ReadonlyArray<string>} */
-    let firstPartyHosts = [];
-    if (budget?.options?.firstPartyHostnames) {
-      firstPartyHosts = budget.options.firstPartyHostnames;
-    } else {
-      firstPartyHosts = classifiedEntities.firstParty?.domains.map(domain => `*.${domain}`) ||
-        [`*.${UrlUtils.getRootDomain(URLArtifact.finalDisplayedUrl)}`];
-    }
+    const firstPartyHosts = classifiedEntities.firstParty?.domains.map(domain => `*.${domain}`) ||
+      [`*.${UrlUtils.getRootDomain(URLArtifact.finalDisplayedUrl)}`];
 
     networkRecords.filter(record => {
       // Ignore favicon.co
@@ -101,18 +94,18 @@ class ResourceSummary {
   }
 
   /**
-   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: LH.Util.ImmutableObject<LH.Budget[]|null>}} data
+   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<Record<LH.Budget.ResourceType,ResourceEntry>>}
+   * @return {Promise<Record<ResourceType,ResourceEntry>>}
    */
   static async compute_(data, context) {
     const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
     const classifiedEntities = await EntityClassification.request(
       {URL: data.URL, devtoolsLog: data.devtoolsLog}, context);
-    return ResourceSummary.summarize(networkRecords, data.URL, data.budgets, classifiedEntities);
+    return ResourceSummary.summarize(networkRecords, data.URL, classifiedEntities);
   }
 }
 
 const ResourceSummaryComputed =
-  makeComputedArtifact(ResourceSummary, ['URL', 'devtoolsLog', 'budgets']);
+  makeComputedArtifact(ResourceSummary, ['URL', 'devtoolsLog']);
 export {ResourceSummaryComputed as ResourceSummary};

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

@@ -1,19 +1,31 @@
 export { TraceEngineResultComputed as TraceEngineResult };
+export type EnabledHandlers = typeof ENABLED_HANDLERS;
 declare const TraceEngineResultComputed: typeof TraceEngineResult & {
     request: (dependencies: {
         trace: LH.Trace;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+    }, context: LH.Util.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<Readonly<import("@paulirish/trace_engine/models/trace/handlers/types.js").EnabledHandlerDataWithMeta<typeof import("@paulirish/trace_engine/models/trace/handlers/ModelHandlers.js")>>>;
+    }>) => Promise<LH.Artifacts.TraceEngineResult>;
 };
+declare namespace ENABLED_HANDLERS {
+    const AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
+    const Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
+    const LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
+    const NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
+    const Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
+    const Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
+    const Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
+    const PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
+}
 /**
  * @fileoverview Processes trace with the shared trace engine.
  */
 declare class TraceEngineResult {
     /**
      * @param {LH.TraceEvent[]} traceEvents
+     * @return {Promise<LH.Artifacts.TraceEngineResult>}
      */
-    static runTraceEngine(traceEvents: LH.TraceEvent[]): Promise<Readonly<import("@paulirish/trace_engine/models/trace/handlers/types.js").EnabledHandlerDataWithMeta<typeof import("@paulirish/trace_engine/models/trace/handlers/ModelHandlers.js")>>>;
+    static runTraceEngine(traceEvents: LH.TraceEvent[]): Promise<LH.Artifacts.TraceEngineResult>;
     /**
      * @param {{trace: LH.Trace}} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -23,4 +35,5 @@ declare class TraceEngineResult {
         trace: LH.Trace;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.TraceEngineResult>;
 }
+import * as LH from '../../types/lh.js';
 //# sourceMappingURL=trace-engine-result.d.ts.map

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

@@ -8,6 +8,20 @@ import * as TraceEngine from '../lib/trace-engine.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {CumulativeLayoutShift} from './metrics/cumulative-layout-shift.js';
 import {ProcessedTrace} from './processed-trace.js';
+import * as LH from '../../types/lh.js';
+
+/** @typedef {typeof ENABLED_HANDLERS} EnabledHandlers */
+
+const ENABLED_HANDLERS = {
+  AuctionWorklets: TraceEngine.TraceHandlers.AuctionWorklets,
+  Initiators: TraceEngine.TraceHandlers.Initiators,
+  LayoutShifts: TraceEngine.TraceHandlers.LayoutShifts,
+  NetworkRequests: TraceEngine.TraceHandlers.NetworkRequests,
+  Renderer: TraceEngine.TraceHandlers.Renderer,
+  Samples: TraceEngine.TraceHandlers.Samples,
+  Screenshots: TraceEngine.TraceHandlers.Screenshots,
+  PageLoadMetrics: TraceEngine.TraceHandlers.PageLoadMetrics,
+};
 
 /**
  * @fileoverview Processes trace with the shared trace engine.
@@ -15,24 +29,18 @@ import {ProcessedTrace} from './processed-trace.js';
 class TraceEngineResult {
   /**
    * @param {LH.TraceEvent[]} traceEvents
+   * @return {Promise<LH.Artifacts.TraceEngineResult>}
    */
   static async runTraceEngine(traceEvents) {
-    const engine = new TraceEngine.TraceProcessor({
-      AuctionWorklets: TraceEngine.TraceHandlers.AuctionWorklets,
-      Initiators: TraceEngine.TraceHandlers.Initiators,
-      LayoutShifts: TraceEngine.TraceHandlers.LayoutShifts,
-      NetworkRequests: TraceEngine.TraceHandlers.NetworkRequests,
-      Renderer: TraceEngine.TraceHandlers.Renderer,
-      Samples: TraceEngine.TraceHandlers.Samples,
-      Screenshots: TraceEngine.TraceHandlers.Screenshots,
-    });
+    const engine = new TraceEngine.TraceProcessor(ENABLED_HANDLERS);
     // eslint-disable-next-line max-len
     await engine.parse(/** @type {import('@paulirish/trace_engine').Types.TraceEvents.TraceEventData[]} */ (
       traceEvents
     ));
     // TODO: use TraceEngine.TraceProcessor.createWithAllHandlers above.
-    return /** @type {import('@paulirish/trace_engine').Handlers.Types.TraceParseData} */(
-      engine.traceParsedData);
+    if (!engine.traceParsedData) throw new Error('No data');
+    if (!engine.insights) throw new Error('No insights');
+    return {data: engine.traceParsedData, insights: engine.insights};
   }
 
   /**
@@ -67,9 +75,6 @@ class TraceEngineResult {
     }
 
     const result = await TraceEngineResult.runTraceEngine(traceEvents);
-    if (!result) {
-      throw new Error('null trace engine result');
-    }
     return result;
   }
 }

package/core/computed/unused-css.d.ts

@@ -5,6 +5,7 @@ export type StyleSheetInfo = LH.Artifacts.CSSStyleSheetInfo & {
 };
 declare const UnusedCSSComputed: typeof UnusedCSS & {
     request: (dependencies: {
+        Stylesheets: LH.Artifacts['Stylesheets'];
         CSSUsage: LH.Artifacts['CSSUsage'];
         devtoolsLog: import("../index.js").DevtoolsLog;
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
@@ -50,11 +51,12 @@ declare class UnusedCSS {
      */
     static mapSheetToResult(stylesheetInfo: StyleSheetInfo): LH.Audit.ByteEfficiencyItem;
     /**
-     * @param {{CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
+     * @param {{Stylesheets: LH.Artifacts['Stylesheets'], CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Audit.ByteEfficiencyItem[]>}
     */
     static compute_(data: {
+        Stylesheets: LH.Artifacts['Stylesheets'];
         CSSUsage: LH.Artifacts['CSSUsage'];
         devtoolsLog: import("../index.js").DevtoolsLog;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Audit.ByteEfficiencyItem[]>;

package/core/computed/unused-css.js

@@ -134,15 +134,15 @@ class UnusedCSS {
   }
 
   /**
-   * @param {{CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
+   * @param {{Stylesheets: LH.Artifacts['Stylesheets'], CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Audit.ByteEfficiencyItem[]>}
   */
   static async compute_(data, context) {
-    const {CSSUsage, devtoolsLog} = data;
+    const {CSSUsage, Stylesheets, devtoolsLog} = data;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const indexedSheets = UnusedCSS.indexStylesheetsById(CSSUsage.stylesheets, networkRecords);
-    UnusedCSS.indexUsedRules(CSSUsage.rules, indexedSheets);
+    const indexedSheets = UnusedCSS.indexStylesheetsById(Stylesheets, networkRecords);
+    UnusedCSS.indexUsedRules(CSSUsage, indexedSheets);
 
     const items = Object.keys(indexedSheets)
       .map(sheetId => UnusedCSS.mapSheetToResult(indexedSheets[sheetId]));
@@ -150,5 +150,6 @@ class UnusedCSS {
   }
 }
 
-const UnusedCSSComputed = makeComputedArtifact(UnusedCSS, ['CSSUsage', 'devtoolsLog']);
+const UnusedCSSComputed = makeComputedArtifact(UnusedCSS,
+  ['Stylesheets', 'CSSUsage', 'devtoolsLog']);
 export {UnusedCSSComputed as UnusedCSS};

package/core/config/config-helpers.js

@@ -11,7 +11,6 @@ import url from 'url';
 import isDeepEqual from 'lodash/isEqual.js';
 
 import * as constants from './constants.js';
-import {Budget} from './budget.js';
 import ConfigPlugin from './config-plugin.js';
 import {Runner} from '../runner.js';
 import * as i18n from '../lib/i18n/i18n.js';
@@ -347,9 +346,6 @@ function resolveSettings(settingsJson = {}, overrides = undefined) {
     true
   );
 
-  if (settingsWithFlags.budgets) {
-    settingsWithFlags.budgets = Budget.initializeBudget(settingsWithFlags.budgets);
-  }
   // Locale is special and comes only from flags/settings/lookupLocale.
   settingsWithFlags.locale = locale;
 

package/core/config/constants.js

@@ -118,7 +118,6 @@ const defaultSettings = {
 
   // the following settings have no defaults but we still want ensure that `key in settings`
   // in config will work in a typechecked way
-  budgets: null,
   locale: 'en-US', // actual default determined by Config using lib/i18n
   blockedUrlPatterns: null,
   additionalTraceCategories: null,