lighthouse 12.0.0 → 12.1.0-dev.20240619

package/core/lib/lantern/metrics/{first-contentful-paint.d.ts → FirstContentfulPaint.d.ts}

@@ -1,10 +1,10 @@
-export type Node = import('../base-node.js').Node;
-export type NetworkNode<T> = import('../network-node.js').NetworkNode<T>;
-export type CpuNode = import('../cpu-node.js').CPUNode;
-/** @typedef {import('../base-node.js').Node} Node */
-/** @template T @typedef {import('../network-node.js').NetworkNode<T>} NetworkNode */
-/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
-export class FirstContentfulPaint extends Metric {
+export type Node = import('../BaseNode.js').Node;
+export type NetworkNode<T> = import('../NetworkNode.js').NetworkNode<T>;
+export type CpuNode = import('../CpuNode.js').CPUNode;
+/** @typedef {import('../BaseNode.js').Node} Node */
+/** @template T @typedef {import('../NetworkNode.js').NetworkNode<T>} NetworkNode */
+/** @typedef {import('../CpuNode.js').CPUNode} CpuNode */
+export class FirstContentfulPaint extends Lantern.Metric {
     /**
      * @template T
      * @typedef FirstPaintBasedGraphOpts
@@ -37,7 +37,7 @@ export class FirstContentfulPaint extends Metric {
          * The function that determines
          * which resources should be considered *possibly* render-blocking.
          */
-        treatNodeAsRenderBlocking: (arg0: import("../network-node.js").NetworkNode<T>) => boolean;
+        treatNodeAsRenderBlocking: (arg0: Lantern.NetworkNode<T>) => boolean;
         /**
          * The function that
          * determines which CPU nodes should also be included in our blocking node IDs set,
@@ -66,7 +66,7 @@ export class FirstContentfulPaint extends Metric {
          * The function that determines
          * which resources should be considered *possibly* render-blocking.
          */
-        treatNodeAsRenderBlocking: (arg0: import("../network-node.js").NetworkNode<T_1>) => boolean;
+        treatNodeAsRenderBlocking: (arg0: Lantern.NetworkNode<T_1>) => boolean;
         /**
          * The function that
          * determines which CPU nodes should also be included in our blocking node IDs set,
@@ -75,5 +75,5 @@ export class FirstContentfulPaint extends Metric {
         additionalCpuNodesToTreatAsRenderBlocking?: ((arg0: CpuNode) => boolean) | undefined;
     }): Node;
 }
-import { Metric } from '../metric.js';
-//# sourceMappingURL=first-contentful-paint.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=FirstContentfulPaint.d.ts.map

package/core/lib/lantern/metrics/{first-contentful-paint.js → FirstContentfulPaint.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 */
-/** @template T @typedef {import('../network-node.js').NetworkNode<T>} NetworkNode */
-/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
+/** @typedef {import('../BaseNode.js').Node} Node */
+/** @template T @typedef {import('../NetworkNode.js').NetworkNode<T>} NetworkNode */
+/** @typedef {import('../CpuNode.js').CPUNode} CpuNode */
 
-class FirstContentfulPaint extends Metric {
+class FirstContentfulPaint extends Lantern.Metric {
   /**
    * @return {Lantern.Simulation.MetricCoefficients}
    */
@@ -57,7 +55,7 @@ class FirstContentfulPaint extends Metric {
     /** @type {Array<CpuNode>} */
     const cpuNodes = [];
     graph.traverse(node => {
-      if (node.type === BaseNode.TYPES.CPU) {
+      if (node.type === Lantern.BaseNode.TYPES.CPU) {
         // A task is *possibly* render blocking if it *started* before cutoffTimestamp.
         // We use startTime here because the paint event can be *inside* the task that was render blocking.
         if (node.startTime <= cutoffTimestamp) cpuNodes.push(node);
@@ -75,7 +73,7 @@ class FirstContentfulPaint extends Metric {
     cpuNodes.sort((a, b) => a.startTime - b.startTime);
 
     // A script is *possibly* render blocking if it finished loading before cutoffTimestamp.
-    const possiblyRenderBlockingScriptUrls = Metric.getScriptUrls(graph, node => {
+    const possiblyRenderBlockingScriptUrls = Lantern.Metric.getScriptUrls(graph, node => {
       // The optimistic LCP treatNodeAsRenderBlocking fn wants to exclude some images in the graph,
       // but here it only receives scripts to evaluate. It's a no-op in this case, but it will
       // matter below in the getFirstPaintBasedGraph clone operation.
@@ -147,13 +145,13 @@ class FirstContentfulPaint extends Metric {
     const {definitelyNotRenderBlockingScriptUrls, renderBlockingCpuNodeIds} = rbData;
 
     return dependencyGraph.cloneWithRelationships(node => {
-      if (node.type === BaseNode.TYPES.NETWORK) {
+      if (node.type === Lantern.BaseNode.TYPES.NETWORK) {
         // Exclude all nodes that ended after cutoffTimestamp (except for the main document which we always consider necessary)
         // endTime is negative if request does not finish, make sure startTime isn't after cutoffTimestamp in this case.
         const endedAfterPaint = node.endTime > cutoffTimestamp || node.startTime > cutoffTimestamp;
         if (endedAfterPaint && !node.isMainDocument()) return false;
 
-        const url = node.record.url;
+        const url = node.request.url;
         // If the URL definitely wasn't render-blocking then we filter it out.
         if (definitelyNotRenderBlockingScriptUrls.has(url)) {
           return false;
@@ -170,7 +168,7 @@ class FirstContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getOptimisticGraph(dependencyGraph, processedNavigation) {
@@ -186,7 +184,7 @@ class FirstContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   static getPessimisticGraph(dependencyGraph, processedNavigation) {

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

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from '../lantern.js';
+import {readJson} from '../../../test/test-utils.js';
+import {getComputationDataFromFixture} from './MetricTestUtils.js';
+
+const {FirstContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../test/fixtures/artifacts/progressive-app/trace.json', import.meta);
+
+describe('Metrics: Lantern FCP', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    const result = 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,
+    }).toMatchSnapshot();
+    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
+    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+  });
+
+  it('should handle negative request networkEndTime', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    data.graph.request.networkEndTime = -1;
+    const result = await FirstContentfulPaint.compute(data);
+
+    const optimisticNodes = [];
+    result.optimisticGraph.traverse(node => {
+      if (node.type === 'network') {
+        optimisticNodes.push(node);
+      }
+    });
+    expect(optimisticNodes.map(node => node.request.url)).toEqual(['https://squoosh.app/']);
+
+    const pessimisticNodes = [];
+    result.pessimisticGraph.traverse(node => {
+      if (node.type === 'network') {
+        pessimisticNodes.push(node);
+      }
+    });
+    expect(pessimisticNodes.map(node => node.request.url)).toEqual(['https://squoosh.app/']);
+  });
+});

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

@@ -0,0 +1,20 @@
+export type Node = import('../BaseNode.js').Node;
+export class Interactive 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
+     * @return {number}
+     */
+    static getLastLongTaskEndTime(nodeTimings: Lantern.Simulation.Result['nodeTimings'], duration?: number): number;
+}
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=Interactive.d.ts.map

package/core/lib/lantern/metrics/{interactive.js → Interactive.js}

@@ -4,19 +4,16 @@
  * 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 {NetworkRequestTypes} from '../lantern.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
 // Any CPU task of 20 ms or more will end up being a critical long task on mobile
 const CRITICAL_LONG_TASK_THRESHOLD = 20;
 
-class Interactive extends Metric {
+class Interactive extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -36,18 +33,18 @@ class Interactive extends Metric {
 
     return dependencyGraph.cloneWithRelationships(node => {
       // Include everything that might be a long task
-      if (node.type === BaseNode.TYPES.CPU) {
+      if (node.type === Lantern.BaseNode.TYPES.CPU) {
         return node.duration > minimumCpuTaskDuration;
       }
 
       // Include all scripts and high priority requests, exclude all images
-      const isImage = node.record.resourceType === NetworkRequestTypes.Image;
-      const isScript = node.record.resourceType === NetworkRequestTypes.Script;
+      const isImage = node.request.resourceType === Lantern.NetworkRequestTypes.Image;
+      const isScript = node.request.resourceType === Lantern.NetworkRequestTypes.Script;
       return (
         !isImage &&
         (isScript ||
-          node.record.priority === 'High' ||
-          node.record.priority === 'VeryHigh')
+          node.request.priority === 'High' ||
+          node.request.priority === 'VeryHigh')
       );
     });
   }
@@ -61,17 +58,17 @@ class Interactive 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.fmpResult) throw new Error('missing fmpResult');
+    if (!extras.lcpResult) throw new Error('missing lcpResult');
 
     const lastTaskAt = Interactive.getLastLongTaskEndTime(simulationResult.nodeTimings);
     const minimumTime = extras.optimistic
-      ? extras.fmpResult.optimisticEstimate.timeInMs
-      : extras.fmpResult.pessimisticEstimate.timeInMs;
+      ? extras.lcpResult.optimisticEstimate.timeInMs
+      : extras.lcpResult.pessimisticEstimate.timeInMs;
     return {
       timeInMs: Math.max(minimumTime, lastTaskAt),
       nodeTimings: simulationResult.nodeTimings,
@@ -80,28 +77,28 @@ class Interactive 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 fmpResult = extras?.fmpResult;
-    if (!fmpResult) {
-      throw new Error('FMP is required to calculate the Interactive metric');
+    const lcpResult = extras?.lcpResult;
+    if (!lcpResult) {
+      throw new Error('LCP is required to calculate the Interactive metric');
     }
 
     const metricResult = await super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, fmpResult.timing);
+    metricResult.timing = Math.max(metricResult.timing, lcpResult.timing);
     return metricResult;
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @return {number}
    */
   static getLastLongTaskEndTime(nodeTimings, duration = 50) {
     return Array.from(nodeTimings.entries())
       .filter(([node, timing]) => {
-        if (node.type !== BaseNode.TYPES.CPU) return false;
+        if (node.type !== Lantern.BaseNode.TYPES.CPU) return false;
         return timing.duration > duration;
       })
       .map(([_, timing]) => timing.endTime)

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

@@ -0,0 +1,56 @@
+/**
+ * @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 {Interactive, FirstContentfulPaint, LargestContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../test/fixtures/artifacts/progressive-app/trace.json', import.meta);
+const iframeTrace = readJson('../../../test/fixtures/artifacts/iframe/trace.json', import.meta);
+
+describe('Metrics: Lantern TTI', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    const result = await Interactive.compute(data, {
+      lcpResult: 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),
+    }).toMatchSnapshot();
+    assert.equal(result.optimisticEstimate.nodeTimings.size, 14);
+    assert.equal(result.pessimisticEstimate.nodeTimings.size, 31);
+    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
+    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+  });
+
+  it('should compute predicted value on iframes with substantial layout', async () => {
+    const data = await getComputationDataFromFixture({
+      trace: iframeTrace,
+    });
+    const result = await Interactive.compute(data, {
+      lcpResult: 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),
+    }).toMatchSnapshot();
+    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
+    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+  });
+});

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 {
@@ -32,23 +29,23 @@ class LargestContentfulPaint extends Metric {
    */
   static isNotLowPriorityImageNode(node) {
     if (node.type !== 'network') return true;
-    const isImage = node.record.resourceType === 'Image';
-    const isLowPriority = node.record.priority === 'Low' || node.record.priority === 'VeryLow';
+    const isImage = node.request.resourceType === 'Image';
+    const isLowPriority = node.request.priority === 'Low' || node.request.priority === 'VeryLow';
     return !isImage || !isLowPriority;
   }
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   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,
     });
@@ -56,16 +53,16 @@ class LargestContentfulPaint extends Metric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
    * @return {Node}
    */
   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('../../../test/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