lighthouse 12.0.0 → 12.1.0

package/core/audits/uses-rel-preload.js

@@ -61,8 +61,8 @@ class UsesRelPreloadAudit extends Audit {
       if (node.type !== 'network') return;
       // Don't include the node itself or any CPU nodes in the initiatorPath
       const path = traversalPath.slice(1).filter(initiator => initiator.type === 'network');
-      if (!UsesRelPreloadAudit.shouldPreloadRequest(node.record, mainResource, path)) return;
-      urls.add(node.record.url);
+      if (!UsesRelPreloadAudit.shouldPreloadRequest(node.rawRequest, mainResource, path)) return;
+      urls.add(node.rawRequest.url);
     });
 
     return urls;
@@ -77,7 +77,7 @@ class UsesRelPreloadAudit extends Audit {
   static getURLsFailedToPreload(graph) {
     /** @type {Array<LH.Artifacts.NetworkRequest>} */
     const requests = [];
-    graph.traverse(node => node.type === 'network' && requests.push(node.record));
+    graph.traverse(node => node.type === 'network' && requests.push(node.rawRequest));
 
     const preloadRequests = requests.filter(req => req.isLinkPreload);
     const preloadURLsByFrame = new Map();
@@ -157,7 +157,7 @@ class UsesRelPreloadAudit extends Audit {
 
       if (node.isMainDocument()) {
         mainDocumentNode = node;
-      } else if (node.record && urls.has(node.record.url)) {
+      } else if (node.rawRequest && urls.has(node.rawRequest.url)) {
         nodesToPreload.push(node);
       }
     });
@@ -176,20 +176,20 @@ class UsesRelPreloadAudit extends Audit {
 
     // Once we've modified the dependencies, simulate the new graph.
     const simulationAfterChanges = simulator.simulate(modifiedGraph);
-    const originalNodesByRecord = Array.from(simulationBeforeChanges.nodeTimings.keys())
-        // @ts-expect-error we don't care if all nodes without a record collect on `undefined`
-        .reduce((map, node) => map.set(node.record, node), new Map());
+    const originalNodesByRequest = Array.from(simulationBeforeChanges.nodeTimings.keys())
+        // @ts-expect-error we don't care if all nodes without a request collect on `undefined`
+        .reduce((map, node) => map.set(node.request, node), new Map());
 
     const results = [];
     for (const node of nodesToPreload) {
-      const originalNode = originalNodesByRecord.get(node.record);
+      const originalNode = originalNodesByRequest.get(node.request);
       const timingAfter = simulationAfterChanges.nodeTimings.get(node);
       const timingBefore = simulationBeforeChanges.nodeTimings.get(originalNode);
       if (!timingBefore || !timingAfter) throw new Error('Missing preload node');
 
       const wastedMs = Math.round(timingBefore.endTime - timingAfter.endTime);
       if (wastedMs < THRESHOLD_IN_MS) continue;
-      results.push({url: node.record.url, wastedMs});
+      results.push({url: node.rawRequest.url, wastedMs});
     }
 
     if (!results.length) {

package/core/computed/critical-request-chains.js

@@ -105,19 +105,19 @@ class CriticalRequestChains {
     graph.traverse((node, traversalPath) => {
       seenNodes.add(node);
       if (node.type !== 'network') return;
-      if (!CriticalRequestChains.isCritical(node.record, mainResource)) return;
+      if (!CriticalRequestChains.isCritical(node.rawRequest, mainResource)) return;
 
       const networkPath = traversalPath
         .filter(/** @return {n is LH.Gatherer.Simulation.GraphNetworkNode} */
           n => n.type === 'network')
         .reverse()
-        .map(node => node.record);
+        .map(node => node.rawRequest);
 
       // Ignore if some ancestor is not a critical request.
       if (networkPath.some(r => !CriticalRequestChains.isCritical(r, mainResource))) return;
 
       // Ignore non-network things (like data urls).
-      if (NetworkRequest.isNonNetworkRequest(node.record)) return;
+      if (NetworkRequest.isNonNetworkRequest(node.rawRequest)) return;
 
       addChain(networkPath);
     }, getNextNodes);

package/core/computed/document-urls.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {NetworkAnalyzer} from '../lib/lantern/simulator/network-analyzer.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRecords} from './network-records.js';
 import {ProcessedTrace} from './processed-trace.js';
@@ -41,7 +41,8 @@ class DocumentUrls {
     }
     if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
 
-    const initialRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+    const initialRequest =
+      Lantern.Simulation.NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
     if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
 
     return {requestedUrl, mainDocumentUrl};

package/core/computed/load-simulator.d.ts

@@ -5,24 +5,24 @@ declare const LoadSimulatorComputed: typeof LoadSimulator & {
         settings: LH.Audit.Context['settings'];
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<Simulator<any>>;
+    }>) => Promise<Lantern.Simulation.Simulator<any>>;
 };
 declare class LoadSimulator {
     /**
      * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<Simulator>}
+     * @return {Promise<Lantern.Simulation.Simulator>}
      */
     static compute_(data: {
         devtoolsLog: import("../index.js").DevtoolsLog;
         settings: LH.Audit.Context['settings'];
-    }, context: LH.Artifacts.ComputedContext): Promise<Simulator>;
+    }, context: LH.Artifacts.ComputedContext): Promise<Lantern.Simulation.Simulator>;
     /**
      * @param {LH.Artifacts.NetworkAnalysis} networkAnalysis
      * @return {LH.PrecomputedLanternData}
      */
     static convertAnalysisToSaveableLanternData(networkAnalysis: LH.Artifacts.NetworkAnalysis): LH.PrecomputedLanternData;
 }
-import { Simulator } from '../lib/lantern/simulator/simulator.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 import { NetworkAnalysis } from './network-analysis.js';
 //# sourceMappingURL=load-simulator.d.ts.map

package/core/computed/load-simulator.js

@@ -4,70 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../lib/lantern/types/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
-import * as constants from '../config/constants.js';
-import {Simulator} from '../lib/lantern/simulator/simulator.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 import {NetworkAnalysis} from './network-analysis.js';
 
 class LoadSimulator {
   /**
    * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<Simulator>}
+   * @return {Promise<Lantern.Simulation.Simulator>}
    */
   static async compute_(data, context) {
-    const {throttlingMethod, throttling, precomputedLanternData} = data.settings;
     const networkAnalysis = await NetworkAnalysis.request(data.devtoolsLog, context);
-
-    /** @type {Lantern.Simulation.Options} */
-    const options = {
-      additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
-      serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,
-      observedThroughput: networkAnalysis.throughput,
-    };
-
-    // If we have precomputed lantern data, overwrite our observed estimates and use precomputed instead
-    // for increased stability.
-    if (precomputedLanternData) {
-      options.additionalRttByOrigin = new Map(Object.entries(
-        precomputedLanternData.additionalRttByOrigin));
-      options.serverResponseTimeByOrigin = new Map(Object.entries(
-        precomputedLanternData.serverResponseTimeByOrigin));
-    }
-
-    switch (throttlingMethod) {
-      case 'provided':
-        options.rtt = networkAnalysis.rtt;
-        options.throughput = networkAnalysis.throughput;
-        options.cpuSlowdownMultiplier = 1;
-        options.layoutTaskMultiplier = 1;
-        break;
-      case 'devtools':
-        if (throttling) {
-          options.rtt =
-            throttling.requestLatencyMs / constants.throttling.DEVTOOLS_RTT_ADJUSTMENT_FACTOR;
-          options.throughput =
-            throttling.downloadThroughputKbps * 1024 /
-            constants.throttling.DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR;
-        }
-
-        options.cpuSlowdownMultiplier = 1;
-        options.layoutTaskMultiplier = 1;
-        break;
-      case 'simulate':
-        if (throttling) {
-          options.rtt = throttling.rttMs;
-          options.throughput = throttling.throughputKbps * 1024;
-          options.cpuSlowdownMultiplier = throttling.cpuSlowdownMultiplier;
-        }
-        break;
-      default:
-        // intentionally fallback to simulator defaults
-        break;
-    }
-
-    return new Simulator(options);
+    return Lantern.Simulation.Simulator.createSimulator({...data.settings, networkAnalysis});
   }
 
   /**

package/core/computed/main-resource.js

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRecords} from './network-records.js';
-import {NetworkAnalyzer} from '../lib/lantern/simulator/network-analyzer.js';
 
 /**
  * @fileoverview This artifact identifies the main resource on the page. Current solution assumes
@@ -28,7 +28,8 @@ class MainResource {
     // document request, we should return the last candidate here. Besides, the browser
     // would have evicted the first request by the time `MainDocumentRequest` (a consumer
     // of this computed artifact) attempts to fetch the contents, resulting in a protocol error.
-    const mainResource = NetworkAnalyzer.findLastDocumentForUrl(records, mainDocumentUrl);
+    const mainResource =
+      Lantern.Simulation.NetworkAnalyzer.findLastDocumentForUrl(records, mainDocumentUrl);
     if (!mainResource) {
       throw new Error('Unable to identify the main resource');
     }

package/core/computed/metrics/interactive.d.ts

@@ -1,6 +1,12 @@
 export { InteractiveComputed as Interactive };
 export type TimePeriod = {
+    /**
+     * In ms.
+     */
     start: number;
+    /**
+     * In ms.
+     */
     end: number;
 };
 declare const InteractiveComputed: typeof Interactive & {

package/core/computed/metrics/interactive.js

@@ -187,6 +187,6 @@ export {InteractiveComputed as Interactive};
 
 /**
  * @typedef TimePeriod
- * @property {number} start
- * @property {number} end
+ * @property {number} start In ms.
+ * @property {number} end In ms.
  */

package/core/computed/metrics/lantern-first-contentful-paint.d.ts

@@ -1,12 +1,12 @@
 export { LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternFirstContentfulPaintComputed: typeof LanternFirstContentfulPaint & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternFirstContentfulPaint extends FirstContentfulPaint {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternFirstContentfulPaint extends Lantern.Metrics.FirstContentfulPaint {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternFirstContentfulPaint extends FirstContentfulPaint {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { FirstContentfulPaint } from '../../lib/lantern/metrics/first-contentful-paint.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-first-contentful-paint.d.ts.map

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

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.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 */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternFirstContentfulPaint extends FirstContentfulPaint {
+class LanternFirstContentfulPaint extends Lantern.Metrics.FirstContentfulPaint {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context

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

@@ -1,12 +1,12 @@
 export { LanternInteractiveComputed as LanternInteractive };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternInteractiveComputed: typeof LanternInteractive & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternInteractive extends Interactive {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternInteractive extends Lantern.Metrics.Interactive {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternInteractive extends Interactive {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { Interactive } from '../../lib/lantern/metrics/interactive.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-interactive.d.ts.map

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

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
-import {Interactive} from '../../lib/lantern/metrics/interactive.js';
+import {LanternLargestContentfulPaint} from './lantern-largest-contentful-paint.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternInteractive extends Interactive {
+class LanternInteractive extends Lantern.Metrics.Interactive {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -29,8 +29,8 @@ class LanternInteractive extends Interactive {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async compute_(data, context) {
-    const fmpResult = await LanternFirstMeaningfulPaint.request(data, context);
-    return this.computeMetricWithGraphs(data, context, {fmpResult});
+    const lcpResult = await LanternLargestContentfulPaint.request(data, context);
+    return this.computeMetricWithGraphs(data, context, {lcpResult});
   }
 }
 

package/core/computed/metrics/lantern-largest-contentful-paint.d.ts

@@ -1,12 +1,12 @@
 export { LanternLargestContentfulPaintComputed as LanternLargestContentfulPaint };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternLargestContentfulPaintComputed: typeof LanternLargestContentfulPaint & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternLargestContentfulPaint extends LargestContentfulPaint {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternLargestContentfulPaint extends Lantern.Metrics.LargestContentfulPaint {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternLargestContentfulPaint extends LargestContentfulPaint {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { LargestContentfulPaint } from '../../lib/lantern/metrics/largest-contentful-paint.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-largest-contentful-paint.d.ts.map

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

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {LargestContentfulPaint} from '../../lib/lantern/metrics/largest-contentful-paint.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternLargestContentfulPaint extends LargestContentfulPaint {
+class LanternLargestContentfulPaint extends Lantern.Metrics.LargestContentfulPaint {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context

package/core/computed/metrics/lantern-max-potential-fid.d.ts

@@ -1,12 +1,12 @@
 export { LanternMaxPotentialFIDComputed as LanternMaxPotentialFID };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternMaxPotentialFIDComputed: typeof LanternMaxPotentialFID & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternMaxPotentialFID extends MaxPotentialFID {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternMaxPotentialFID extends Lantern.Metrics.MaxPotentialFID {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternMaxPotentialFID extends MaxPotentialFID {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { MaxPotentialFID } from '../../lib/lantern/metrics/max-potential-fid.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-max-potential-fid.d.ts.map

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

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
-import {MaxPotentialFID} from '../../lib/lantern/metrics/max-potential-fid.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternMaxPotentialFID extends MaxPotentialFID {
+class LanternMaxPotentialFID extends Lantern.Metrics.MaxPotentialFID {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context

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

@@ -2,14 +2,33 @@
  * @param {LH.Artifacts.MetricComputationDataInput} data
  * @param {LH.Artifacts.ComputedContext} context
  */
-export function getComputationDataParams(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
-    simulator: import("../../lib/lantern/simulator/simulator.js").Simulator<any>;
+export function getComputationDataParamsFromTrace(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+    simulator: Lantern.Simulation.Simulator<any>;
+    graph: import("../page-dependency-graph.js").Node;
+    processedNavigation: import("../../lib/lantern/types/lantern.js").Simulation.ProcessedNavigation;
+}>;
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+export function getComputationDataParamsFromDevtoolsLog(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+    simulator: Lantern.Simulation.Simulator<any>;
     graph: import("../page-dependency-graph.js").Node;
     processedNavigation: import("../../index.js").Artifacts.ProcessedNavigation;
 }>;
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+export function getComputationDataParams(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+    simulator: Lantern.Simulation.Simulator<any>;
+    graph: import("../page-dependency-graph.js").Node;
+    processedNavigation: import("../../lib/lantern/types/lantern.js").Simulation.ProcessedNavigation;
+}>;
 /**
  * @param {unknown} err
  * @return {never}
  */
 export function lanternErrorAdapter(err: unknown): never;
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-metric.d.ts.map

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

@@ -4,17 +4,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {LanternError} from '../../lib/lantern/lantern-error.js';
+import * as Lantern from '../../lib/lantern/lantern.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';
+import {PageDependencyGraph} from '../page-dependency-graph.js';
+import {TraceEngineResult} from '../trace-engine-result.js';
 
 /**
  * @param {LH.Artifacts.MetricComputationDataInput} data
  * @param {LH.Artifacts.ComputedContext} context
  */
-async function getComputationDataParams(data, context) {
+async function getComputationDataParamsFromDevtoolsLog(data, context) {
   if (data.gatherContext.gatherMode !== 'navigation') {
     throw new Error(`Lantern metrics can only be computed on navigations`);
   }
@@ -26,12 +27,30 @@ async function getComputationDataParams(data, context) {
   return {simulator, graph, processedNavigation};
 }
 
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+async function getComputationDataParamsFromTrace(data, context) {
+  if (data.gatherContext.gatherMode !== 'navigation') {
+    throw new Error(`Lantern metrics can only be computed on navigations`);
+  }
+
+  const graph = await PageDependencyGraph.request({...data, fromTrace: true}, context);
+  const traceEngineResult = await TraceEngineResult.request(data, context);
+  const processedNavigation =
+    Lantern.TraceEngineComputationData.createProcessedNavigation(traceEngineResult.data);
+  const simulator = data.simulator || (await LoadSimulator.request(data, context));
+
+  return {simulator, graph, processedNavigation};
+}
+
 /**
  * @param {unknown} err
  * @return {never}
  */
 function lanternErrorAdapter(err) {
-  if (!(err instanceof LanternError)) {
+  if (!(err instanceof Lantern.Error)) {
     throw err;
   }
 
@@ -43,7 +62,23 @@ function lanternErrorAdapter(err) {
   throw err;
 }
 
+/**
+ * @param {LH.Artifacts.MetricComputationDataInput} data
+ * @param {LH.Artifacts.ComputedContext} context
+ */
+function getComputationDataParams(data, context) {
+  // TODO(15841): remove devtools impl when ready to make breaking change.
+  if (process.env.INTERNAL_LANTERN_USE_TRACE !== undefined) {
+    return getComputationDataParamsFromTrace(data, context);
+  } else {
+    // This is the default behavior.
+    return getComputationDataParamsFromDevtoolsLog(data, context);
+  }
+}
+
 export {
+  getComputationDataParamsFromTrace,
+  getComputationDataParamsFromDevtoolsLog,
   getComputationDataParams,
   lanternErrorAdapter,
 };

package/core/computed/metrics/lantern-speed-index.d.ts

@@ -1,12 +1,12 @@
 export { LanternSpeedIndexComputed as LanternSpeedIndex };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternSpeedIndexComputed: typeof LanternSpeedIndex & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternSpeedIndex extends SpeedIndex {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternSpeedIndex extends Lantern.Metrics.SpeedIndex {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternSpeedIndex extends SpeedIndex {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { SpeedIndex } from '../../lib/lantern/metrics/speed-index.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-speed-index.d.ts.map

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

@@ -4,15 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.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';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternSpeedIndex extends SpeedIndex {
+class LanternSpeedIndex extends Lantern.Metrics.SpeedIndex {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -34,7 +34,7 @@ class LanternSpeedIndex extends SpeedIndex {
     const speedline = await Speedline.request(data.trace, context);
     const fcpResult = await LanternFirstContentfulPaint.request(data, context);
     return this.computeMetricWithGraphs(data, context, {
-      speedline,
+      observedSpeedIndex: speedline.speedIndex,
       fcpResult,
     });
   }

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

@@ -1,12 +1,12 @@
 export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
+export type Extras = import('../../lib/lantern/Metric.js').Extras;
 declare const LanternTotalBlockingTimeComputed: typeof LanternTotalBlockingTime & {
     request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
 };
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternTotalBlockingTime extends TotalBlockingTime {
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
+declare class LanternTotalBlockingTime extends Lantern.Metrics.TotalBlockingTime {
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -21,5 +21,5 @@ declare class LanternTotalBlockingTime extends TotalBlockingTime {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { TotalBlockingTime } from '../../lib/lantern/metrics/total-blocking-time.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 //# sourceMappingURL=lantern-total-blocking-time.d.ts.map

package/core/computed/metrics/lantern-total-blocking-time.js

@@ -4,15 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {TotalBlockingTime} from '../../lib/lantern/metrics/total-blocking-time.js';
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 import {LanternInteractive} from './lantern-interactive.js';
 import {getComputationDataParams} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
+/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
 
-class LanternTotalBlockingTime extends TotalBlockingTime {
+class LanternTotalBlockingTime extends Lantern.Metrics.TotalBlockingTime {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context