lighthouse 12.0.0-dev.20240611 → 12.0.0-dev.20240613

package/core/computed/tbt-impact-tasks.js

@@ -4,14 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../lib/lantern/types/lantern.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {MainThreadTasks} from './main-thread-tasks.js';
 import {FirstContentfulPaint} from './metrics/first-contentful-paint.js';
 import {Interactive} from './metrics/interactive.js';
 import {TotalBlockingTime} from './metrics/total-blocking-time.js';
 import {ProcessedTrace} from './processed-trace.js';
-import {calculateTbtImpactForEvent} from '../lib/lantern/tbt-utils.js';
+
+const {calculateTbtImpactForEvent} = Lantern.TBTUtils;
 
 class TBTImpactTasks {
   /**

package/core/config/constants.js

@@ -6,7 +6,7 @@
 
 import * as Lantern from '../lib/lantern/lantern.js';
 
-const throttling = Lantern.constants.throttling;
+const throttling = Lantern.Simulation.Constants.throttling;
 
 /**
  * @type {Required<LH.SharedFlagsSettings['screenEmulation']>}

package/core/lib/asset-saver.js

@@ -12,7 +12,7 @@ import {createGzip, gunzipSync} from 'zlib';
 
 import log from 'lighthouse-logger';
 
-import {Simulator} from './lantern/simulator/simulator.js';
+import * as Lantern from './lantern/lantern.js';
 import lanternTraceSaver from './lantern-trace-saver.js';
 import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import {NetworkAnalysis} from '../computed/network-analysis.js';
@@ -449,7 +449,7 @@ function saveDevtoolsLog(devtoolsLog, devtoolLogFilename, options = {}) {
 async function saveLanternDebugTraces(pathWithBasename) {
   if (!process.env.LANTERN_DEBUG) return;
 
-  for (const [label, nodeTimings] of Simulator.ALL_NODE_TIMINGS) {
+  for (const [label, nodeTimings] of Lantern.Simulation.Simulator.ALL_NODE_TIMINGS) {
     if (lanternTraceSaver.simulationNamesToIgnore.includes(label)) continue;
 
     const traceFilename = `${pathWithBasename}-${label}${traceSuffix}`;

package/core/lib/lantern/{base-node.d.ts → BaseNode.d.ts}

@@ -2,7 +2,7 @@
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  */
-export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>;
+export type Node<T = any> = import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>;
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -12,7 +12,7 @@ export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./netwo
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  * @template [T=any]
- * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
+ * @typedef {import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>} Node
  */
 /**
  * @fileoverview This class encapsulates logic for handling resources and tasks used to model the
@@ -30,6 +30,10 @@ export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./netwo
  * @template [T=any]
  */
 export class BaseNode<T = any> {
+    static TYPES: {
+        NETWORK: 'network';
+        CPU: 'cpu';
+    };
     /**
      * Returns whether the given node has a cycle in its dependent graph by performing a DFS.
      * @param {Node} node
@@ -156,10 +160,4 @@ export class BaseNode<T = any> {
      */
     canDependOn(node: Node): boolean;
 }
-export namespace BaseNode {
-    namespace TYPES {
-        const NETWORK: 'network';
-        const CPU: 'cpu';
-    }
-}
-//# sourceMappingURL=base-node.d.ts.map
+//# sourceMappingURL=BaseNode.d.ts.map

package/core/lib/lantern/{base-node.js → BaseNode.js}

@@ -8,7 +8,7 @@
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  * @template [T=any]
- * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
+ * @typedef {import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>} Node
  */
 
 /**
@@ -28,6 +28,11 @@
  * @template [T=any]
  */
 class BaseNode {
+  static TYPES = /** @type {{NETWORK: 'network', CPU: 'cpu'}} */({
+    NETWORK: 'network',
+    CPU: 'cpu',
+  });
+
   /**
    * @param {string} id
    */
@@ -361,9 +366,4 @@ class BaseNode {
   }
 }
 
-BaseNode.TYPES = /** @type {{NETWORK: 'network', CPU: 'cpu'}} */({
-  NETWORK: 'network',
-  CPU: 'cpu',
-});
-
 export {BaseNode};

package/core/lib/lantern/BaseNode.test.js

@@ -0,0 +1,385 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from './lantern.js';
+
+const {BaseNode, NetworkNode} = Lantern;
+
+function sortedById(nodeArray) {
+  return nodeArray.sort((node1, node2) => node1.id.localeCompare(node2.id));
+}
+
+function createComplexGraph() {
+  //   B       F
+  //  / \     /
+  // A   D - E
+  //  \ /     \
+  //   C       G - H
+
+  const nodeA = new BaseNode('A');
+  const nodeB = new BaseNode('B');
+  const nodeC = new BaseNode('C');
+  const nodeD = new BaseNode('D');
+  const nodeE = new BaseNode('E');
+  const nodeF = new BaseNode('F');
+  const nodeG = new BaseNode('G');
+  const nodeH = new BaseNode('H');
+
+  nodeA.addDependent(nodeB);
+  nodeA.addDependent(nodeC);
+  nodeB.addDependent(nodeD);
+  nodeC.addDependent(nodeD);
+  nodeD.addDependent(nodeE);
+  nodeE.addDependent(nodeF);
+  nodeE.addDependent(nodeG);
+  nodeG.addDependent(nodeH);
+
+  return {
+    nodeA,
+    nodeB,
+    nodeC,
+    nodeD,
+    nodeE,
+    nodeF,
+    nodeG,
+    nodeH,
+  };
+}
+describe('DependencyGraph/Node', () => {
+  describe('#constructor', () => {
+    it('should set the ID', () => {
+      const node = new BaseNode('foo');
+      assert.equal(node.id, 'foo');
+    });
+  });
+
+  describe('.addDependent', () => {
+    it('should add the correct edge', () => {
+      const nodeA = new BaseNode(1);
+      const nodeB = new BaseNode(2);
+      nodeA.addDependent(nodeB);
+
+      assert.deepEqual(nodeA.getDependents(), [nodeB]);
+      assert.deepEqual(nodeB.getDependencies(), [nodeA]);
+    });
+  });
+
+  describe('.addDependency', () => {
+    it('should add the correct edge', () => {
+      const nodeA = new BaseNode(1);
+      const nodeB = new BaseNode(2);
+      nodeA.addDependency(nodeB);
+
+      assert.deepEqual(nodeA.getDependencies(), [nodeB]);
+      assert.deepEqual(nodeB.getDependents(), [nodeA]);
+    });
+
+    it('throw when trying to add a dependency on itself', () => {
+      const nodeA = new BaseNode(1);
+      expect(() => nodeA.addDependency(nodeA)).toThrow();
+    });
+  });
+
+  describe('.isDependentOn', () => {
+    it('should identify the dependency relationships', () => {
+      const graph = createComplexGraph();
+      const nodes = Object.values(graph);
+      const {nodeA, nodeB, nodeD, nodeF, nodeH} = graph;
+
+      for (const node of nodes) {
+        expect(nodeA.isDependentOn(node)).toBe(node === nodeA);
+        expect(nodeB.isDependentOn(node)).toBe(node === nodeA || node === nodeB);
+        expect(nodeH.isDependentOn(node)).toBe(node !== nodeF);
+      }
+
+      expect(nodeD.isDependentOn(nodeA)).toBe(true);
+      expect(nodeD.isDependentOn(nodeB)).toBe(true);
+      expect(nodeD.isDependentOn(nodeD)).toBe(true);
+
+      expect(nodeD.isDependentOn(nodeH)).toBe(false);
+      expect(nodeH.isDependentOn(nodeD)).toBe(true);
+
+      expect(nodeF.isDependentOn(nodeH)).toBe(false);
+      expect(nodeH.isDependentOn(nodeF)).toBe(false);
+    });
+  });
+
+  describe('.getRootNode', () => {
+    it('should return the root node', () => {
+      const graph = createComplexGraph();
+
+      assert.equal(graph.nodeA.getRootNode(), graph.nodeA);
+      assert.equal(graph.nodeB.getRootNode(), graph.nodeA);
+      assert.equal(graph.nodeD.getRootNode(), graph.nodeA);
+      assert.equal(graph.nodeF.getRootNode(), graph.nodeA);
+    });
+  });
+
+  describe('.cloneWithoutRelationships', () => {
+    it('should create a copy', () => {
+      const node = new BaseNode(1);
+      const neighbor = new BaseNode(2);
+      node.addDependency(neighbor);
+      const clone = node.cloneWithoutRelationships();
+
+      assert.equal(clone.id, 1);
+      assert.notEqual(node, clone);
+      assert.equal(clone.getDependencies().length, 0);
+    });
+
+    it('should copy isMainDocument', () => {
+      const node = new BaseNode(1);
+      node.setIsMainDocument(true);
+      const networkNode = new NetworkNode({});
+      networkNode.setIsMainDocument(true);
+
+      assert.ok(node.cloneWithoutRelationships().isMainDocument());
+      assert.ok(networkNode.cloneWithoutRelationships().isMainDocument());
+    });
+  });
+
+  describe('.cloneWithRelationships', () => {
+    it('should create a copy of a basic graph', () => {
+      const node = new BaseNode(1);
+      const neighbor = new BaseNode(2);
+      node.addDependency(neighbor);
+      const clone = node.cloneWithRelationships();
+
+      assert.equal(clone.id, 1);
+      assert.notEqual(node, clone);
+
+      const dependencies = clone.getDependencies();
+      assert.equal(dependencies.length, 1);
+
+      const neighborClone = dependencies[0];
+      assert.equal(neighborClone.id, neighbor.id);
+      assert.notEqual(neighborClone, neighbor);
+      assert.equal(neighborClone.getDependents()[0], clone);
+    });
+
+    it('should create a copy of a complex graph', () => {
+      const graph = createComplexGraph();
+      const clone = graph.nodeA.cloneWithRelationships();
+
+      const clonedIdMap = new Map();
+      clone.traverse(node => clonedIdMap.set(node.id, node));
+      assert.equal(clonedIdMap.size, 8);
+
+      graph.nodeA.traverse(node => {
+        const clone = clonedIdMap.get(node.id);
+        assert.equal(clone.id, node.id);
+        assert.notEqual(clone, node);
+
+        const actualDependents = sortedById(clone.getDependents());
+        const expectedDependents = sortedById(node.getDependents());
+        actualDependents.forEach((cloneDependent, index) => {
+          const originalDependent = expectedDependents[index];
+          assert.equal(cloneDependent.id, originalDependent.id);
+          assert.notEqual(cloneDependent, originalDependent);
+        });
+      });
+    });
+
+    it('should create a copy of a graph with long dependency chains', () => {
+      //   C - D - E - F
+      //  /             \
+      // A - - - - - - - B
+      const nodeA = new BaseNode('A');
+      const nodeB = new BaseNode('B');
+      const nodeC = new BaseNode('C');
+      const nodeD = new BaseNode('D');
+      const nodeE = new BaseNode('E');
+      const nodeF = new BaseNode('F');
+
+      nodeA.addDependent(nodeB);
+      nodeF.addDependent(nodeB);
+
+      nodeA.addDependent(nodeC);
+      nodeC.addDependent(nodeD);
+      nodeD.addDependent(nodeE);
+      nodeE.addDependent(nodeF);
+
+      const clone = nodeA.cloneWithRelationships();
+
+      const clonedIdMap = new Map();
+      clone.traverse(node => clonedIdMap.set(node.id, node));
+      assert.equal(clonedIdMap.size, 6);
+    });
+
+    it('should create a copy when not starting at root node', () => {
+      const graph = createComplexGraph();
+      const cloneD = graph.nodeD.cloneWithRelationships();
+      assert.equal(cloneD.id, 'D');
+      assert.equal(cloneD.getRootNode().id, 'A');
+    });
+
+    it('should create a partial copy of a complex graph', () => {
+      const graph = createComplexGraph();
+      // create a clone with F and all its dependencies
+      const clone = graph.nodeA.cloneWithRelationships(node => node.id === 'F');
+
+      const clonedIdMap = new Map();
+      clone.traverse(node => clonedIdMap.set(node.id, node));
+
+      assert.equal(clonedIdMap.size, 6);
+      assert.ok(clonedIdMap.has('F'), 'did not include target node');
+      assert.ok(clonedIdMap.has('E'), 'did not include dependency');
+      assert.ok(clonedIdMap.has('B'), 'did not include branched dependency');
+      assert.ok(clonedIdMap.has('C'), 'did not include branched dependency');
+      assert.equal(clonedIdMap.get('G'), undefined);
+      assert.equal(clonedIdMap.get('H'), undefined);
+    });
+
+    it('should throw if original node is not in cloned graph', () => {
+      const graph = createComplexGraph();
+      assert.throws(
+        // clone from root to nodeB, but called on nodeD
+        _ => graph.nodeD.cloneWithRelationships(node => node.id === 'B'),
+        /^Error: Cloned graph missing node$/
+      );
+    });
+  });
+
+  describe('.traverse', () => {
+    it('should visit every dependent node', () => {
+      const graph = createComplexGraph();
+      const ids = [];
+      graph.nodeA.traverse(node => ids.push(node.id));
+
+      assert.deepEqual(ids, ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']);
+    });
+
+    it('should include a shortest traversal path to every dependent node', () => {
+      const graph = createComplexGraph();
+      const paths = [];
+      graph.nodeA.traverse((node, traversalPath) => {
+        assert.strictEqual(node.id, traversalPath[0].id);
+        paths.push(traversalPath.map(node => node.id));
+      });
+
+      assert.deepStrictEqual(paths, [
+        ['A'],
+        ['B', 'A'],
+        ['C', 'A'],
+        ['D', 'B', 'A'],
+        ['E', 'D', 'B', 'A'],
+        ['F', 'E', 'D', 'B', 'A'],
+        ['G', 'E', 'D', 'B', 'A'],
+        ['H', 'G', 'E', 'D', 'B', 'A'],
+      ]);
+    });
+
+    it('should respect getNext', () => {
+      const graph = createComplexGraph();
+      const ids = [];
+      graph.nodeF.traverse(
+        node => ids.push(node.id),
+        node => node.getDependencies()
+      );
+
+      assert.deepEqual(ids, ['F', 'E', 'D', 'B', 'C', 'A']);
+    });
+  });
+
+  describe('#hasCycle', () => {
+    it('should return false for DAGs', () => {
+      const graph = createComplexGraph();
+      assert.equal(BaseNode.hasCycle(graph.nodeA), false);
+    });
+
+    it('should return false for triangular DAGs', () => {
+      //   B
+      //  / \
+      // A - C
+      const nodeA = new BaseNode('A');
+      const nodeB = new BaseNode('B');
+      const nodeC = new BaseNode('C');
+
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+
+      assert.equal(BaseNode.hasCycle(nodeA), false);
+    });
+
+    it('should return true for basic cycles', () => {
+      // A - B - C - A!
+      const nodeA = new BaseNode('A');
+      const nodeB = new BaseNode('B');
+      const nodeC = new BaseNode('C');
+
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+      nodeC.addDependent(nodeA);
+
+      assert.equal(BaseNode.hasCycle(nodeA), true);
+    });
+
+    it('should return true for children', () => {
+      //       A!
+      //      /
+      // A - B - C
+      const nodeA = new BaseNode('A');
+      const nodeB = new BaseNode('B');
+      const nodeC = new BaseNode('C');
+
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+      nodeB.addDependent(nodeA);
+
+      assert.equal(BaseNode.hasCycle(nodeC), true);
+    });
+
+    it('should return true for complex cycles', () => {
+      //   B - D - F - G - C!
+      //  /      /
+      // A - - C - E - H
+      const nodeA = new BaseNode('A');
+      const nodeB = new BaseNode('B');
+      const nodeC = new BaseNode('C');
+      const nodeD = new BaseNode('D');
+      const nodeE = new BaseNode('E');
+      const nodeF = new BaseNode('F');
+      const nodeG = new BaseNode('G');
+      const nodeH = new BaseNode('H');
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeB.addDependent(nodeD);
+      nodeC.addDependent(nodeE);
+      nodeC.addDependent(nodeF);
+      nodeD.addDependent(nodeF);
+      nodeE.addDependent(nodeH);
+      nodeF.addDependent(nodeG);
+      nodeG.addDependent(nodeC);
+
+      assert.equal(BaseNode.hasCycle(nodeA), true);
+      assert.equal(BaseNode.hasCycle(nodeB), true);
+      assert.equal(BaseNode.hasCycle(nodeC), true);
+      assert.equal(BaseNode.hasCycle(nodeD), true);
+      assert.equal(BaseNode.hasCycle(nodeE), true);
+      assert.equal(BaseNode.hasCycle(nodeF), true);
+      assert.equal(BaseNode.hasCycle(nodeG), true);
+      assert.equal(BaseNode.hasCycle(nodeH), true);
+    });
+
+    it('works for very large graphs', () => {
+      const root = new BaseNode('root');
+
+      let lastNode = root;
+      for (let i = 0; i < 10000; i++) {
+        const nextNode = new BaseNode(`child${i}`);
+        lastNode.addDependent(nextNode);
+        lastNode = nextNode;
+      }
+
+      lastNode.addDependent(root);
+      assert.equal(BaseNode.hasCycle(root), true);
+    });
+  });
+});

package/core/lib/lantern/{cpu-node.d.ts → CpuNode.d.ts}

@@ -1,16 +1,16 @@
 /**
  * @template [T=any]
- * @extends {BaseNode<T>}
+ * @extends {Lantern.BaseNode<T>}
  */
-export class CPUNode<T = any> extends BaseNode<T> {
+export class CPUNode<T = any> extends Lantern.BaseNode<T> {
     /**
      * @param {Lantern.TraceEvent} parentEvent
      * @param {Lantern.TraceEvent[]=} childEvents
      * @param {number=} correctedEndTs
      */
     constructor(parentEvent: Lantern.TraceEvent, childEvents?: Lantern.TraceEvent[] | undefined, correctedEndTs?: number | undefined);
-    _event: Lantern.TraceEvent;
-    _childEvents: Lantern.TraceEvent[];
+    _event: import("./types/lantern.js").TraceEvent;
+    _childEvents: import("./types/lantern.js").TraceEvent[];
     _correctedEndTs: number | undefined;
     get type(): "cpu";
     /**
@@ -20,11 +20,11 @@ export class CPUNode<T = any> extends BaseNode<T> {
     /**
      * @return {Lantern.TraceEvent}
      */
-    get event(): Lantern.TraceEvent;
+    get event(): import("./types/lantern.js").TraceEvent;
     /**
      * @return {Lantern.TraceEvent[]}
      */
-    get childEvents(): Lantern.TraceEvent[];
+    get childEvents(): import("./types/lantern.js").TraceEvent[];
     /**
      * Returns true if this node contains a Layout task.
      * @return {boolean}
@@ -39,6 +39,5 @@ export class CPUNode<T = any> extends BaseNode<T> {
      */
     cloneWithoutRelationships(): CPUNode;
 }
-import { BaseNode } from './base-node.js';
-import * as Lantern from './types/lantern.js';
-//# sourceMappingURL=cpu-node.d.ts.map
+import * as Lantern from './lantern.js';
+//# sourceMappingURL=CpuNode.d.ts.map

package/core/lib/lantern/{cpu-node.js → CpuNode.js}

@@ -4,14 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from './types/lantern.js';
-import {BaseNode} from './base-node.js';
+import * as Lantern from './lantern.js';
 
 /**
  * @template [T=any]
- * @extends {BaseNode<T>}
+ * @extends {Lantern.BaseNode<T>}
  */
-class CPUNode extends BaseNode {
+class CPUNode extends Lantern.BaseNode {
   /**
    * @param {Lantern.TraceEvent} parentEvent
    * @param {Lantern.TraceEvent[]=} childEvents
@@ -27,7 +26,7 @@ class CPUNode extends BaseNode {
   }
 
   get type() {
-    return BaseNode.TYPES.CPU;
+    return Lantern.BaseNode.TYPES.CPU;
   }
 
   /**

package/core/lib/lantern/{lantern-error.d.ts → LanternError.d.ts}

@@ -5,4 +5,4 @@
  */
 export class LanternError extends Error {
 }
-//# sourceMappingURL=lantern-error.d.ts.map
+//# sourceMappingURL=LanternError.d.ts.map

package/core/lib/lantern/{metric.d.ts → Metric.d.ts}

@@ -1,22 +1,22 @@
-export type Node = import('./base-node.js').Node;
-export type NetworkNode = import('./network-node.js').NetworkNode;
-export type Simulator = import('./simulator/simulator.js').Simulator;
+export type Node = import('./BaseNode.js').Node;
+export type NetworkNode = import('./NetworkNode.js').NetworkNode;
+export type Simulator = import('./simulation/Simulator.js').Simulator;
 export type Extras = {
     optimistic: boolean;
-    fcpResult?: Lantern.Metric | undefined;
-    lcpResult?: Lantern.Metric | undefined;
-    interactiveResult?: Lantern.Metric | undefined;
+    fcpResult?: Lantern.Metrics.Result | undefined;
+    lcpResult?: Lantern.Metrics.Result | undefined;
+    interactiveResult?: Lantern.Metrics.Result | undefined;
     observedSpeedIndex?: number | undefined;
 };
-/** @typedef {import('./base-node.js').Node} Node */
-/** @typedef {import('./network-node.js').NetworkNode} NetworkNode */
-/** @typedef {import('./simulator/simulator.js').Simulator} Simulator */
+/** @typedef {import('./BaseNode.js').Node} Node */
+/** @typedef {import('./NetworkNode.js').NetworkNode} NetworkNode */
+/** @typedef {import('./simulation/Simulator.js').Simulator} Simulator */
 /**
  * @typedef Extras
  * @property {boolean} optimistic
- * @property {Lantern.Metric=} fcpResult
- * @property {Lantern.Metric=} lcpResult
- * @property {Lantern.Metric=} interactiveResult
+ * @property {Lantern.Metrics.Result=} fcpResult
+ * @property {Lantern.Metrics.Result=} lcpResult
+ * @property {Lantern.Metrics.Result=} interactiveResult
  * @property {number=} observedSpeedIndex
  */
 export class Metric {
@@ -29,7 +29,7 @@ export class Metric {
     /**
      * @return {Lantern.Simulation.MetricCoefficients}
      */
-    static get COEFFICIENTS(): Lantern.Simulation.MetricCoefficients;
+    static get COEFFICIENTS(): import("./types/lantern.js").Simulation.MetricCoefficients;
     /**
      * Returns the coefficients, scaled by the throttling settings if needed by the metric.
      * Some lantern metrics (speed-index) use components in their estimate that are not
@@ -61,9 +61,9 @@ export class Metric {
     /**
      * @param {Lantern.Simulation.MetricComputationDataInput} data
      * @param {Omit<Extras, 'optimistic'>=} extras
-     * @return {Promise<Lantern.Metric>}
+     * @return {Promise<Lantern.Metrics.Result>}
      */
-    static compute(data: Lantern.Simulation.MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<Lantern.Metric>;
+    static compute(data: Lantern.Simulation.MetricComputationDataInput, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<Lantern.Metrics.Result>;
 }
-import * as Lantern from './types/lantern.js';
-//# sourceMappingURL=metric.d.ts.map
+import * as Lantern from './lantern.js';
+//# sourceMappingURL=Metric.d.ts.map