lighthouse 11.7.0 → 12.0.0-dev.20240422

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

@@ -5,89 +5,23 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternMetric} from './lantern-metric.js';
-import {BaseNode} from '../../lib/lantern/base-node.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {Speedline} from '../speedline.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
-import {throttling as defaultThrottling} from '../../config/constants.js';
+import {SpeedIndex} from '../../lib/lantern/metrics/speed-index.js';
 
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
-class LanternSpeedIndex extends LanternMetric {
+class LanternSpeedIndex extends SpeedIndex {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      // Negative intercept is OK because estimate is Math.max(FCP, Speed Index) and
-      // the optimistic estimate is based on the real observed speed index rather than a real
-      // lantern graph.
-      intercept: -250,
-      optimistic: 1.4,
-      pessimistic: 0.65,
-    };
-  }
-
-  /**
-   * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    // We want to scale our default coefficients based on the speed of the connection.
-    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
-    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
-    //      30 ms was based on a typical home WiFi connection's actual RTT.
-    //      Coefficients here follow from the fact that the optimistic estimate should be very close
-    //      to reality at this connection speed and the pessimistic estimate compensates for minor
-    //      connection speed differences.
-    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
-    //      Coefficients here were determined through thorough analysis and linear regression on the
-    //      lantern test data set. See core/scripts/test-lantern.sh for more detail.
-    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
-    const defaultCoefficients = this.COEFFICIENTS;
-    const defaultRttExcess = defaultThrottling.mobileSlow4G.rttMs - 30;
-    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
-
-    return {
-      intercept: defaultCoefficients.intercept * multiplier,
-      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
-      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
-    };
-  }
-
-  /**
-   * @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} simulationResult
-   * @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(simulationResult, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.speedline) throw new Error('missing speedline');
-
-    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
-    const estimate = extras.optimistic
-      ? extras.speedline.speedIndex
-      : LanternSpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
-    return {
-      timeInMs: estimate,
-      nodeTimings: simulationResult.nodeTimings,
-    };
+  static async computeMetricWithGraphs(data, context, extras) {
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**
@@ -96,50 +30,13 @@ class LanternSpeedIndex extends LanternMetric {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async compute_(data, context) {
+    // TODO(15841): lib/lantern should probably run Speedline
     const speedline = await Speedline.request(data.trace, context);
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context, {
+    return this.computeMetricWithGraphs(data, context, {
       speedline,
       fcpResult,
     });
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-
-  /**
-   * Approximate speed index using layout events from the simulated node timings.
-   * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
-   * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
-   *
-   * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
-   *
-   * This approach was determined after evaluating the accuracy/complexity tradeoff of many
-   * different methods. Read more in the evaluation doc.
-   *
-   * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {number}
-   */
-  static computeLayoutBasedSpeedIndex(nodeTimings, fcpTimeInMs) {
-    /** @type {Array<{time: number, weight: number}>} */
-    const layoutWeights = [];
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
-
-      if (node.childEvents.some(x => x.name === 'Layout')) {
-        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
-        layoutWeights.push({time: timing.endTime, weight: timingWeight});
-      }
-    }
-
-    const totalWeightedTime = layoutWeights
-      .map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs))
-      .reduce((a, b) => a + b, 0);
-    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
-
-    if (!totalWeight) return fcpTimeInMs;
-    return totalWeightedTime / totalWeight;
   }
 }
 

package/core/computed/metrics/lantern-total-blocking-time.d.ts

@@ -1,37 +1,25 @@
 export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
-export type Node = import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Extras = import('../../lib/lantern/metric.js').Extras;
 declare const LanternTotalBlockingTimeComputed: typeof LanternTotalBlockingTime & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-declare class LanternTotalBlockingTime extends LanternMetric {
+/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+declare class LanternTotalBlockingTime extends TotalBlockingTime {
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulation
-     * @param {import('../../lib/lantern/metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../../lib/lantern/metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} minDurationMs
-     */
-    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
-        start: number;
-        end: number;
-        duration: number;
-    }[];
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LanternMetric } from './lantern-metric.js';
+import { TotalBlockingTime } from '../../lib/lantern/metrics/total-blocking-time.js';
 //# sourceMappingURL=lantern-total-blocking-time.d.ts.map

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