lighthouse 12.0.0-dev.20240610 → 12.0.0-dev.20240612

package/core/lib/lantern/metrics/LargestContentfulPaint.d.ts

@@ -0,0 +1,19 @@
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class LargestContentfulPaint extends Lantern.Metric {
+    /**
+     * Low priority image nodes are usually offscreen and very unlikely to be the
+     * resource that is required for LCP. Our LCP graphs include everything except for these images.
+     *
+     * @param {Node} node
+     * @return {boolean}
+     */
+    static isNotLowPriorityImageNode(node: Node): boolean;
+    /**
+     * @param {Lantern.Simulation.Result} simulationResult
+     * @return {Lantern.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: Lantern.Simulation.Result): Lantern.Simulation.Result;
+}
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=LargestContentfulPaint.d.ts.map

package/core/lib/lantern/metrics/{largest-contentful-paint.js → LargestContentfulPaint.js}

@@ -4,16 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {FirstContentfulPaint} from './first-contentful-paint.js';
-import {LanternError} from '../lantern-error.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class LargestContentfulPaint extends Metric {
+class LargestContentfulPaint extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -45,10 +42,10 @@ class LargestContentfulPaint extends Metric {
   static getOptimisticGraph(dependencyGraph, processedNavigation) {
     const lcp = processedNavigation.timestamps.largestContentfulPaint;
     if (!lcp) {
-      throw new LanternError('NO_LCP');
+      throw new Lantern.Error('NO_LCP');
     }
 
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+    return Lantern.Metrics.FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
       cutoffTimestamp: lcp,
       treatNodeAsRenderBlocking: LargestContentfulPaint.isNotLowPriorityImageNode,
     });
@@ -62,10 +59,10 @@ class LargestContentfulPaint extends Metric {
   static getPessimisticGraph(dependencyGraph, processedNavigation) {
     const lcp = processedNavigation.timestamps.largestContentfulPaint;
     if (!lcp) {
-      throw new LanternError('NO_LCP');
+      throw new Lantern.Error('NO_LCP');
     }
 
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+    return Lantern.Metrics.FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
       cutoffTimestamp: lcp,
       treatNodeAsRenderBlocking: _ => true,
       // For pessimistic LCP we'll include *all* layout nodes
@@ -74,8 +71,8 @@ class LargestContentfulPaint extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulationResult
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult) {
     const nodeTimesNotOffscreenImages = Array.from(simulationResult.nodeTimings.entries())
@@ -90,8 +87,8 @@ class LargestContentfulPaint extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;

package/core/lib/lantern/metrics/LargestContentfulPaint.test.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from '../lantern.js';
+import {getComputationDataFromFixture} from './MetricTestUtils.js';
+import {readJson} from '../../../test/test-utils.js';
+
+const {FirstContentfulPaint, LargestContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../fixtures/artifacts/paul/trace.json', import.meta);
+
+describe('Metrics: Lantern LCP', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    const result = await LargestContentfulPaint.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs),
+      optimisticNodeTimings: result.optimisticEstimate.nodeTimings.size,
+      pessimisticNodeTimings: result.pessimisticEstimate.nodeTimings.size}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 1457,
+  "optimisticNodeTimings": 8,
+  "pessimistic": 1616,
+  "pessimisticNodeTimings": 9,
+  "timing": 1536,
+}
+`);
+    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
+    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+  });
+});

package/core/lib/lantern/metrics/MaxPotentialFID.d.ts

@@ -0,0 +1,24 @@
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class MaxPotentialFID extends Lantern.Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} fcpTimeInMs
+     * @return {Array<{duration: number}>}
+     */
+    static getTimingsAfterFCP(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
+        duration: number;
+    }>;
+}
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=MaxPotentialFID.d.ts.map

package/core/lib/lantern/metrics/{max-potential-fid.js → MaxPotentialFID.js}

@@ -4,15 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class MaxPotentialFID extends Metric {
+class MaxPotentialFID extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -39,9 +37,9 @@ class MaxPotentialFID extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulation
+   * @param {import('../Metric.js').Extras} extras
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -65,8 +63,8 @@ class MaxPotentialFID extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -78,13 +76,14 @@ class MaxPotentialFID extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} fcpTimeInMs
    * @return {Array<{duration: number}>}
    */
   static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
     return Array.from(nodeTimings.entries())
-      .filter(([node, timing]) => node.type === BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
+      .filter(([node, timing]) =>
+        node.type === Lantern.BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
       .map(([_, timing]) => timing);
   }
 }

package/core/lib/lantern/metrics/MetricTestUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {TraceEngine.Types.TraceEvents.TraceEventData[]} traceEvents
+ */
+export function runTraceEngine(traceEvents: TraceEngine.Types.TraceEvents.TraceEventData[]): Promise<TraceEngine.Handlers.Types.EnabledHandlerDataWithMeta<typeof TraceEngine.Handlers.ModelHandlers>>;
+/**
+ * @param {{trace: Lantern.Trace, settings?: Lantern.Simulation.Settings, URL?: Lantern.Simulation.URL}} opts
+ */
+export function getComputationDataFromFixture({ trace, settings, URL }: {
+    trace: Lantern.Trace;
+    settings?: Lantern.Simulation.Settings;
+    URL?: Lantern.Simulation.URL;
+}): Promise<{
+    simulator: Lantern.Simulation.Simulator<any>;
+    graph: import("../PageDependencyGraph.js").Node;
+    processedNavigation: import("../types/lantern.js").Simulation.ProcessedNavigation;
+}>;
+import * as TraceEngine from '@paulirish/trace_engine';
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=MetricTestUtils.d.ts.map

package/core/lib/lantern/metrics/MetricTestUtils.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as TraceEngine from '@paulirish/trace_engine';
+
+import * as Lantern from '../lantern.js';
+import {polyfillDOMRect} from '../../polyfill-dom-rect.js';
+
+polyfillDOMRect();
+
+/**
+ * @param {TraceEngine.Types.TraceEvents.TraceEventData[]} traceEvents
+ */
+async function runTraceEngine(traceEvents) {
+  const processor = TraceEngine.Processor.TraceProcessor.createWithAllHandlers();
+  await processor.parse(traceEvents);
+  if (!processor.traceParsedData) throw new Error('No data');
+  return processor.traceParsedData;
+}
+
+/**
+ * @param {{trace: Lantern.Trace, settings?: Lantern.Simulation.Settings, URL?: Lantern.Simulation.URL}} opts
+ */
+async function getComputationDataFromFixture({trace, settings, URL}) {
+  settings = settings ?? /** @type {Lantern.Simulation.Settings} */({});
+  if (!settings.throttlingMethod) settings.throttlingMethod = 'simulate';
+  const traceEngineData = await runTraceEngine(
+    /** @type {TraceEngine.Types.TraceEvents.TraceEventData[]} */ (trace.traceEvents)
+  );
+  const requests =
+    Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
+  const networkAnalysis = Lantern.Simulation.NetworkAnalyzer.analyze(requests);
+
+  return {
+    simulator: Lantern.Simulation.Simulator.createSimulator({...settings, networkAnalysis}),
+    graph: Lantern.TraceEngineComputationData.createGraph(requests, trace, traceEngineData, URL),
+    processedNavigation:
+      Lantern.TraceEngineComputationData.createProcessedNavigation(traceEngineData),
+  };
+}
+
+export {
+  runTraceEngine,
+  getComputationDataFromFixture,
+};

package/core/lib/lantern/metrics/{speed-index.d.ts → SpeedIndex.d.ts}

@@ -1,6 +1,6 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class SpeedIndex extends Metric {
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class SpeedIndex extends Lantern.Metric {
     /**
      * @param {Node} dependencyGraph
      * @return {Node}
@@ -11,12 +11,6 @@ export class SpeedIndex extends Metric {
      * @return {Node}
      */
     static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
     /**
      * 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
@@ -28,11 +22,11 @@ export class SpeedIndex extends Metric {
      * 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 {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} fcpTimeInMs
      * @return {number}
      */
-    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+    static computeLayoutBasedSpeedIndex(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
 }
-import { Metric } from '../metric.js';
-//# sourceMappingURL=speed-index.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=SpeedIndex.d.ts.map

package/core/lib/lantern/metrics/{speed-index.js → SpeedIndex.js}

@@ -4,17 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
+import * as Lantern from '../lantern.js';
 
 const mobileSlow4GRtt = 150;
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class SpeedIndex extends Metric {
+class SpeedIndex extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -28,7 +26,7 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.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.
@@ -70,9 +68,9 @@ class SpeedIndex extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulationResult
+   * @param {import('../Metric.js').Extras} extras
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -90,8 +88,8 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -115,7 +113,7 @@ class SpeedIndex extends Metric {
    * 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 {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} fcpTimeInMs
    * @return {number}
    */
@@ -123,7 +121,7 @@ class SpeedIndex extends Metric {
     /** @type {Array<{time: number, weight: number}>} */
     const layoutWeights = [];
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
 
       if (node.childEvents.some(x => x.name === 'Layout')) {
         const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);

package/core/lib/lantern/metrics/SpeedIndex.test.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../lantern.js';
+import {readJson} from '../../../test/test-utils.js';
+import {getComputationDataFromFixture} from './MetricTestUtils.js';
+
+const {SpeedIndex, FirstContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../fixtures/artifacts/progressive-app/trace.json', import.meta);
+
+const defaultThrottling = Lantern.Simulation.Constants.throttling.mobileSlow4G;
+
+describe('Metrics: Lantern Speed Index', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    // TODO: observedSpeedIndex is from the Speedline library, and is used for optimistic
+    // mode. At the moment callers must pass the result into Lantern.
+    const observedSpeedIndex = 379.04474997520487;
+    const result = await SpeedIndex.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+      observedSpeedIndex,
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 379,
+  "pessimistic": 1122,
+  "timing": 1107,
+}
+`);
+  });
+
+  it('should compute predicted value for different settings', async () => {
+    const settings = {throttlingMethod: 'simulate', throttling: {...defaultThrottling, rttMs: 300}};
+    const data = await getComputationDataFromFixture({trace, settings});
+    const observedSpeedIndex = 379.04474997520487;
+    const result = await SpeedIndex.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+      observedSpeedIndex,
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 379,
+  "pessimistic": 2022,
+  "timing": 2007,
+}
+`);
+  });
+
+  it('should not scale coefficients at default', async () => {
+    const result = SpeedIndex.getScaledCoefficients(defaultThrottling.rttMs);
+    expect(result).toEqual(SpeedIndex.COEFFICIENTS);
+  });
+
+  it('should scale coefficients back', async () => {
+    const result = SpeedIndex.getScaledCoefficients(5);
+    expect(result).toEqual({intercept: 0, pessimistic: 0.5, optimistic: 0.5});
+  });
+
+  it('should scale coefficients forward', async () => {
+    const result = SpeedIndex.getScaledCoefficients(300);
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "intercept": 0,
+        "optimistic": 2.525,
+        "pessimistic": 0.275,
+      }
+    `);
+  });
+});

package/core/lib/lantern/metrics/TotalBlockingTime.d.ts

@@ -0,0 +1,25 @@
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class TotalBlockingTime extends Lantern.Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} minDurationMs
+     */
+    static getTopLevelEvents(nodeTimings: Lantern.Simulation.Result['nodeTimings'], minDurationMs: number): {
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=TotalBlockingTime.d.ts.map

package/core/lib/lantern/metrics/{total-blocking-time.js → TotalBlockingTime.js}

@@ -4,16 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
-import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../tbt-utils.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class TotalBlockingTime extends Metric {
+class TotalBlockingTime extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -40,9 +37,9 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulation
+   * @param {import('../Metric.js').Extras} extras
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -64,7 +61,7 @@ class TotalBlockingTime extends Metric {
       ? extras.interactiveResult.optimisticEstimate.timeInMs
       : extras.interactiveResult.pessimisticEstimate.timeInMs;
 
-    const minDurationMs = BLOCKING_TIME_THRESHOLD;
+    const minDurationMs = Lantern.TBTUtils.BLOCKING_TIME_THRESHOLD;
 
     const events = TotalBlockingTime.getTopLevelEvents(
       simulation.nodeTimings,
@@ -72,7 +69,7 @@ class TotalBlockingTime extends Metric {
     );
 
     return {
-      timeInMs: calculateSumOfBlockingTime(
+      timeInMs: Lantern.TBTUtils.calculateSumOfBlockingTime(
         events,
         fcpTimeInMs,
         interactiveTimeMs
@@ -83,8 +80,8 @@ class TotalBlockingTime extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -101,7 +98,7 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} minDurationMs
    */
   static getTopLevelEvents(nodeTimings, minDurationMs) {
@@ -110,7 +107,7 @@ class TotalBlockingTime extends Metric {
     const events = [];
 
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
       // Filtering out events below minimum duration.
       if (timing.duration < minDurationMs) continue;
 

package/core/lib/lantern/metrics/__snapshots__/first-contentful-paint-test.js.snap

@@ -0,0 +1,11 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Metrics: Lantern FCP should compute predicted value 1`] = `
+Object {
+  "optimistic": 1107,
+  "optimisticNodeTimings": 4,
+  "pessimistic": 1107,
+  "pessimisticNodeTimings": 4,
+  "timing": 1107,
+}
+`;

package/core/lib/lantern/metrics/__snapshots__/interactive-test.js.snap

@@ -0,0 +1,17 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Metrics: Lantern TTI should compute predicted value 1`] = `
+Object {
+  "optimistic": 1107,
+  "pessimistic": 1134,
+  "timing": 1122,
+}
+`;
+
+exports[`Metrics: Lantern TTI should compute predicted value on iframes with substantial layout 1`] = `
+Object {
+  "optimistic": 2372,
+  "pessimistic": 2386,
+  "timing": 2379,
+}
+`;

package/core/lib/lantern/metrics/metrics.d.ts

@@ -0,0 +1,9 @@
+export { FirstContentfulPaint } from "./FirstContentfulPaint.js";
+export { Interactive } from "./Interactive.js";
+export { LargestContentfulPaint } from "./LargestContentfulPaint.js";
+export { MaxPotentialFID } from "./MaxPotentialFID.js";
+export { SpeedIndex } from "./SpeedIndex.js";
+export { TotalBlockingTime } from "./TotalBlockingTime.js";
+export type Result<T = any> = Lantern.MetricResult<T>;
+import * as Lantern from '../types/lantern.js';
+//# sourceMappingURL=metrics.d.ts.map

package/core/lib/lantern/metrics/metrics.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+
+export {FirstContentfulPaint} from './FirstContentfulPaint.js';
+export {Interactive} from './Interactive.js';
+export {LargestContentfulPaint} from './LargestContentfulPaint.js';
+export {MaxPotentialFID} from './MaxPotentialFID.js';
+export {SpeedIndex} from './SpeedIndex.js';
+export {TotalBlockingTime} from './TotalBlockingTime.js';
+
+/** @template [T=any] @typedef {Lantern.MetricResult<T>} Result */