lighthouse 11.7.0-dev.20240410 → 11.7.0-dev.20240411

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

@@ -14,10 +14,10 @@ import * as i18n from '../../lib/i18n/i18n.js';
 import {BaseNode} from '../../lib/lantern/base-node.js';
 import {UnusedCSS} from '../../computed/unused-css.js';
 import {NetworkRequest} from '../../lib/network-request.js';
-import {ProcessedNavigation} from '../../computed/processed-navigation.js';
 import {LoadSimulator} from '../../computed/load-simulator.js';
 import {FirstContentfulPaint} from '../../computed/metrics/first-contentful-paint.js';
 import {LCPImageRecord} from '../../computed/lcp-image-record.js';
+import {NavigationInsights} from '../../computed/navigation-insights.js';
 
 
 /** @typedef {import('../../lib/lantern/simulator/simulator.js').Simulator} Simulator */
@@ -44,21 +44,19 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 /**
  * Given a simulation's nodeTimings, return an object with the nodes/timing keyed by network URL
  * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
- * @return {Object<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
+ * @return {Map<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
  */
-function getNodesAndTimingByUrl(nodeTimings) {
-  /** @type {Object<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>} */
-  const urlMap = {};
-  const nodes = Array.from(nodeTimings.keys());
-  nodes.forEach(node => {
-    if (node.type !== 'network') return;
-    const nodeTiming = nodeTimings.get(node);
-    if (!nodeTiming) return;
-
-    urlMap[node.record.url] = {node, nodeTiming};
-  });
+function getNodesAndTimingByRequestId(nodeTimings) {
+  /** @type {Map<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>} */
+  const requestIdToNode = new Map();
+
+  for (const [node, nodeTiming] of nodeTimings) {
+    if (node.type !== 'network') continue;
 
-  return urlMap;
+    requestIdToNode.set(node.record.requestId, {node, nodeTiming});
+  }
+
+  return requestIdToNode;
 }
 
 /**
@@ -119,8 +117,7 @@ class RenderBlockingResources extends Audit {
       guidanceLevel: 2,
       // TODO: look into adding an `optionalArtifacts` property that captures the non-required nature
       // of CSSUsage
-      requiredArtifacts: ['URL', 'TagsBlockingFirstPaint', 'traces', 'devtoolsLogs', 'CSSUsage',
-        'GatherContext', 'Stacks'],
+      requiredArtifacts: ['URL', 'traces', 'devtoolsLogs', 'CSSUsage', 'GatherContext', 'Stacks'],
     };
   }
 
@@ -134,9 +131,12 @@ class RenderBlockingResources extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const simulatorData = {devtoolsLog, settings: context.settings};
-    const processedNavigation = await ProcessedNavigation.request(trace, context);
     const simulator = await LoadSimulator.request(simulatorData, context);
     const wastedCssBytes = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
+    const navInsights = await NavigationInsights.request(trace, context);
+
+    const renderBlocking = navInsights.RenderBlocking;
+    if (renderBlocking instanceof Error) throw renderBlocking;
 
     /** @type {LH.Audit.Context['settings']} */
     const metricSettings = {
@@ -150,19 +150,18 @@ class RenderBlockingResources extends Audit {
     // Cast to just `LanternMetric` since we explicitly set `throttlingMethod: 'simulate'`.
     const fcpSimulation = /** @type {LH.Artifacts.LanternMetric} */
       (await FirstContentfulPaint.request(metricComputationData, context));
-    const fcpTsInMs = processedNavigation.timestamps.firstContentfulPaint / 1000;
 
-    const nodesByUrl = getNodesAndTimingByUrl(fcpSimulation.optimisticEstimate.nodeTimings);
+    const nodesAndTimingsByRequestId =
+      getNodesAndTimingByRequestId(fcpSimulation.optimisticEstimate.nodeTimings);
 
     const results = [];
     const deferredNodeIds = new Set();
-    for (const resource of artifacts.TagsBlockingFirstPaint) {
-      // Ignore any resources that finished after observed FCP (they're clearly not render-blocking)
-      if (resource.endTime > fcpTsInMs) continue;
+    for (const resource of renderBlocking.renderBlockingRequests) {
+      const nodeAndTiming = nodesAndTimingsByRequestId.get(resource.args.data.requestId);
       // TODO: beacon to Sentry, https://github.com/GoogleChrome/lighthouse/issues/7041
-      if (!nodesByUrl[resource.tag.url]) continue;
+      if (!nodeAndTiming) continue;
 
-      const {node, nodeTiming} = nodesByUrl[resource.tag.url];
+      const {node, nodeTiming} = nodeAndTiming;
 
       const stackSpecificTiming = computeStackSpecificTiming(node, nodeTiming, artifacts.Stacks);
 
@@ -174,8 +173,8 @@ class RenderBlockingResources extends Audit {
       if (wastedMs < MINIMUM_WASTED_MS) continue;
 
       results.push({
-        url: resource.tag.url,
-        totalBytes: resource.transferSize,
+        url: resource.args.data.url,
+        totalBytes: resource.args.data.encodedDataLength,
         wastedMs,
       });
     }

package/core/audits/layout-shifts.js

@@ -61,7 +61,7 @@ class LayoutShifts extends Audit {
   static async audit(artifacts, context) {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const traceEngineResult = await TraceEngineResult.request({trace}, context);
-    const clusters = traceEngineResult.LayoutShifts.clusters ?? [];
+    const clusters = traceEngineResult.data.LayoutShifts.clusters ?? [];
     const {cumulativeLayoutShift: clsSavings, impactByNodeId} =
       await CumulativeLayoutShiftComputed.request(trace, context);
     const traceElements = artifacts.TraceElements

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

@@ -5,7 +5,7 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {FirstContentfulPaint} from '../../lib/lantern/metrics/first-contentful-paint.js';
 
 /** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
@@ -18,7 +18,8 @@ class LanternFirstContentfulPaint extends FirstContentfulPaint {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -5,7 +5,7 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {FirstMeaningfulPaint} from '../../lib/lantern/metrics/first-meaningful-paint.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
@@ -19,7 +19,8 @@ class LanternFirstMeaningfulPaint extends FirstMeaningfulPaint {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -7,7 +7,7 @@
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
 import {Interactive} from '../../lib/lantern/metrics/interactive.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
 /** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
 
@@ -19,7 +19,8 @@ class LanternInteractive extends Interactive {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -6,7 +6,7 @@
 
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {LargestContentfulPaint} from '../../lib/lantern/metrics/largest-contentful-paint.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
 /** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
@@ -19,7 +19,8 @@ class LanternLargestContentfulPaint extends LargestContentfulPaint {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -6,7 +6,7 @@
 
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {MaxPotentialFID} from '../../lib/lantern/metrics/max-potential-fid.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
 /** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
@@ -19,7 +19,8 @@ class LanternMaxPotentialFID extends MaxPotentialFID {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

package/core/computed/metrics/lantern-metric.d.ts

@@ -7,4 +7,9 @@ export function getComputationDataParams(data: LH.Artifacts.MetricComputationDat
     graph: import("../page-dependency-graph.js").Node;
     processedNavigation: import("../../index.js").Artifacts.ProcessedNavigation;
 }>;
+/**
+ * @param {unknown} err
+ * @return {never}
+ */
+export function lanternErrorAdapter(err: unknown): never;
 //# sourceMappingURL=lantern-metric.d.ts.map

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

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {LanternError} from '../../lib/lantern/lantern-error.js';
+import {LighthouseError} from '../../lib/lh-error.js';
 import {LoadSimulator} from '../load-simulator.js';
 import {PageDependencyGraph} from '../page-dependency-graph.js';
 import {ProcessedNavigation} from '../processed-navigation.js';
@@ -24,4 +26,24 @@ async function getComputationDataParams(data, context) {
   return {simulator, graph, processedNavigation};
 }
 
-export {getComputationDataParams};
+/**
+ * @param {unknown} err
+ * @return {never}
+ */
+function lanternErrorAdapter(err) {
+  if (!(err instanceof LanternError)) {
+    throw err;
+  }
+
+  const code = /** @type {keyof LighthouseError.errors} */ (err.message);
+  if (LighthouseError.errors[code]) {
+    throw new LighthouseError(LighthouseError.errors[code]);
+  }
+
+  throw err;
+}
+
+export {
+  getComputationDataParams,
+  lanternErrorAdapter,
+};

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

@@ -5,7 +5,7 @@
  */
 
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {getComputationDataParams} from './lantern-metric.js';
+import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {Speedline} from '../speedline.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 import {SpeedIndex} from '../../lib/lantern/metrics/speed-index.js';
@@ -20,7 +20,8 @@ class LanternSpeedIndex extends SpeedIndex {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras);
+    return this.compute(await getComputationDataParams(data, context), extras)
+      .catch(lanternErrorAdapter);
   }
 
   /**

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/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/config/default-config.js

@@ -137,7 +137,6 @@ const defaultConfig = {
     {id: 'Scripts', gatherer: 'scripts'},
     {id: 'SourceMaps', gatherer: 'source-maps'},
     {id: 'Stacks', gatherer: 'stacks'},
-    {id: 'TagsBlockingFirstPaint', gatherer: 'dobetterweb/tags-blocking-first-paint'},
     {id: 'TraceElements', gatherer: 'trace-elements'},
     {id: 'ViewportDimensions', gatherer: 'viewport-dimensions'},
 

package/core/config/filters.js

@@ -13,7 +13,6 @@ const baseArtifactKeySource = {
   fetchTime: '',
   LighthouseRunWarnings: '',
   BenchmarkIndex: '',
-  BenchmarkIndexes: '',
   settings: '',
   Timing: '',
   URL: '',

package/core/gather/gatherers/root-causes.d.ts

@@ -3,10 +3,10 @@ declare class RootCauses extends BaseGatherer {
     static symbol: symbol;
     /**
      * @param {LH.Gatherer.Driver} driver
-     * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+     * @param {LH.Artifacts.TraceEngineResult['data']} traceParsedData
      * @return {Promise<LH.Artifacts.TraceEngineRootCauses>}
      */
-    static runRootCauseAnalysis(driver: LH.Gatherer.Driver, traceEngineResult: LH.Artifacts.TraceEngineResult): Promise<LH.Artifacts.TraceEngineRootCauses>;
+    static runRootCauseAnalysis(driver: LH.Gatherer.Driver, traceParsedData: LH.Artifacts.TraceEngineResult['data']): Promise<LH.Artifacts.TraceEngineRootCauses>;
     /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
     meta: LH.Gatherer.GathererMeta<'Trace'>;
     /**

package/core/gather/gatherers/root-causes.js

@@ -21,10 +21,10 @@ class RootCauses extends BaseGatherer {
 
   /**
    * @param {LH.Gatherer.Driver} driver
-   * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+   * @param {LH.Artifacts.TraceEngineResult['data']} traceParsedData
    * @return {Promise<LH.Artifacts.TraceEngineRootCauses>}
    */
-  static async runRootCauseAnalysis(driver, traceEngineResult) {
+  static async runRootCauseAnalysis(driver, traceParsedData) {
     await driver.defaultSession.sendCommand('DOM.enable');
     await driver.defaultSession.sendCommand('CSS.enable');
 
@@ -112,9 +112,10 @@ class RootCauses extends BaseGatherer {
       layoutShifts: {},
     };
     const rootCausesEngine = new TraceEngine.RootCauses(protocolInterface);
-    const layoutShiftEvents = traceEngineResult.LayoutShifts.clusters.flatMap(c => c.events);
+    const layoutShiftEvents = traceParsedData.LayoutShifts.clusters.flatMap(c => c.events);
     for (const event of layoutShiftEvents) {
-      const r = await rootCausesEngine.layoutShifts.rootCausesForEvent(traceEngineResult, event);
+      // @ts-expect-error The data we do get in the trace processor is still enough here
+      const r = await rootCausesEngine.layoutShifts.rootCausesForEvent(traceParsedData, event);
       if (!r) continue;
 
       for (const cause of r.fontChanges) {
@@ -137,7 +138,7 @@ class RootCauses extends BaseGatherer {
   async getArtifact(context) {
     const trace = context.dependencies.Trace;
     const traceEngineResult = await TraceEngineResult.request({trace}, context);
-    return RootCauses.runRootCauseAnalysis(context.driver, traceEngineResult);
+    return RootCauses.runRootCauseAnalysis(context.driver, traceEngineResult.data);
   }
 }
 

package/core/gather/gatherers/trace-elements.d.ts

@@ -25,12 +25,12 @@ declare class TraceElements extends BaseGatherer {
      * that may have caused the shift.
      *
      * @param {LH.Trace} trace
-     * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+     * @param {LH.Artifacts.TraceEngineResult['data']} traceEngineResult
      * @param {LH.Artifacts.TraceEngineRootCauses} rootCauses
      * @param {LH.Gatherer.Context} context
      * @return {Promise<Array<{nodeId: number}>>}
      */
-    static getTopLayoutShifts(trace: LH.Trace, traceEngineResult: LH.Artifacts.TraceEngineResult, rootCauses: LH.Artifacts.TraceEngineRootCauses, context: LH.Gatherer.Context): Promise<Array<{
+    static getTopLayoutShifts(trace: LH.Trace, traceEngineResult: LH.Artifacts.TraceEngineResult['data'], rootCauses: LH.Artifacts.TraceEngineRootCauses, context: LH.Gatherer.Context): Promise<Array<{
         nodeId: number;
     }>>;
     /**

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

@@ -122,7 +122,7 @@ class TraceElements extends BaseGatherer {
    * that may have caused the shift.
    *
    * @param {LH.Trace} trace
-   * @param {LH.Artifacts.TraceEngineResult} traceEngineResult
+   * @param {LH.Artifacts.TraceEngineResult['data']} traceEngineResult
    * @param {LH.Artifacts.TraceEngineRootCauses} rootCauses
    * @param {LH.Gatherer.Context} context
    * @return {Promise<Array<{nodeId: number}>>}
@@ -322,7 +322,7 @@ class TraceElements extends BaseGatherer {
 
     const lcpNodeData = await TraceElements.getLcpElement(trace, context);
     const shiftsData = await TraceElements.getTopLayoutShifts(
-      trace, traceEngineResult, rootCauses, context);
+      trace, traceEngineResult.data, rootCauses, context);
     const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
     const responsivenessElementData = await TraceElements.getResponsivenessElement(trace, context);
 

package/core/lib/lantern/cpu-node.d.ts

@@ -6,11 +6,17 @@ export class CPUNode<T = any> extends BaseNode<T> {
     /**
      * @param {LH.TraceEvent} parentEvent
      * @param {LH.TraceEvent[]=} childEvents
+     * @param {number=} correctedEndTs
      */
-    constructor(parentEvent: LH.TraceEvent, childEvents?: LH.TraceEvent[] | undefined);
+    constructor(parentEvent: LH.TraceEvent, childEvents?: LH.TraceEvent[] | undefined, correctedEndTs?: number | undefined);
     _event: LH.TraceEvent;
     _childEvents: LH.TraceEvent[];
+    _correctedEndTs: number | undefined;
     get type(): "cpu";
+    /**
+     * @return {number}
+     */
+    get duration(): number;
     /**
      * @return {LH.TraceEvent}
      */

package/core/lib/lantern/cpu-node.js

@@ -15,13 +15,15 @@ class CPUNode extends BaseNode {
   /**
    * @param {LH.TraceEvent} parentEvent
    * @param {LH.TraceEvent[]=} childEvents
+   * @param {number=} correctedEndTs
    */
-  constructor(parentEvent, childEvents = []) {
+  constructor(parentEvent, childEvents = [], correctedEndTs) {
     const nodeId = `${parentEvent.tid}.${parentEvent.ts}`;
     super(nodeId);
 
     this._event = parentEvent;
     this._childEvents = childEvents;
+    this._correctedEndTs = correctedEndTs;
   }
 
   get type() {
@@ -39,9 +41,17 @@ class CPUNode extends BaseNode {
    * @return {number}
    */
   get endTime() {
+    if (this._correctedEndTs) return this._correctedEndTs;
     return this._event.ts + this._event.dur;
   }
 
+  /**
+   * @return {number}
+   */
+  get duration() {
+    return this.endTime - this.startTime;
+  }
+
   /**
    * @return {LH.TraceEvent}
    */
@@ -83,7 +93,7 @@ class CPUNode extends BaseNode {
    * @return {CPUNode}
    */
   cloneWithoutRelationships() {
-    return new CPUNode(this._event, this._childEvents);
+    return new CPUNode(this._event, this._childEvents, this._correctedEndTs);
   }
 }
 

package/core/lib/lantern/lantern-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export class LanternError extends Error {
+}
+//# sourceMappingURL=lantern-error.d.ts.map

package/core/lib/lantern/lantern-error.js

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class LanternError extends Error {}
+
+export {LanternError};