lighthouse 12.1.0 → 12.2.0

package/core/audits/work-during-interaction.d.ts

@@ -1,6 +1,6 @@
 export default WorkDuringInteraction;
-export type EventTimingEvent = import('../computed/metrics/responsiveness.js').EventTimingEvent;
-export type TaskNode = import('../lib/tracehouse/main-thread-tasks.js').TaskNode;
+export type EventTimingEvent = import("../computed/metrics/responsiveness.js").EventTimingEvent;
+export type TaskNode = import("../lib/tracehouse/main-thread-tasks.js").TaskNode;
 /**
  * @fileoverview This metric gives a high-percentile measure of responsiveness to input.
  */
@@ -59,7 +59,7 @@ declare class WorkDuringInteraction extends Audit {
      * @param {LH.Artifacts['TraceElements']} traceElements
      * @return {LH.Audit.Details.Table | undefined}
      */
-    static getTraceElementTable(traceElements: LH.Artifacts['TraceElements']): LH.Audit.Details.Table | undefined;
+    static getTraceElementTable(traceElements: LH.Artifacts["TraceElements"]): LH.Audit.Details.Table | undefined;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context
@@ -68,15 +68,14 @@ declare class WorkDuringInteraction extends Audit {
     static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
-    const title: string;
-    const failureTitle: string;
-    const description: string;
-    const inputDelay: string;
-    const processingDuration: string;
-    const presentationDelay: string;
-    const displayValue: string;
-    const eventTarget: string;
+    let title: string;
+    let failureTitle: string;
+    let description: string;
+    let inputDelay: string;
+    let processingDuration: string;
+    let presentationDelay: string;
+    let displayValue: string;
+    let eventTarget: string;
 }
 import { Audit } from './audit.js';
-import { ProcessedTrace } from '../computed/processed-trace.js';
 //# sourceMappingURL=work-during-interaction.d.ts.map

package/core/computed/computed-artifact.d.ts

@@ -9,7 +9,7 @@
 export function makeComputedArtifact<C extends {
     name: string;
     compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>;
-}, K extends (keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>)[]>(computableArtifact: C, keys: (K & ([keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>] extends [K[number]] ? unknown : never)) | null): C & {
-    request: (dependencies: import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>, context: LH.Artifacts.ComputedContext) => ReturnType<C["compute_"]>;
+}, K extends Array<keyof LH.Util.FirstParamType<C["compute_"]>>>(computableArtifact: C, keys: (K & ([keyof LH.Util.FirstParamType<C["compute_"]>] extends [K[number]] ? unknown : never)) | null): C & {
+    request: (dependencies: LH.Util.FirstParamType<C["compute_"]>, context: LH.Artifacts.ComputedContext) => ReturnType<C["compute_"]>;
 };
 //# sourceMappingURL=computed-artifact.d.ts.map

package/core/computed/critical-request-chains.d.ts

@@ -1,23 +1,21 @@
 export { CriticalRequestChainsComputed as CriticalRequestChains };
 declare const CriticalRequestChainsComputed: typeof CriticalRequestChains & {
     request: (dependencies: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../index.js").Artifacts.CriticalRequestNode>;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof CriticalRequestChains.compute_>;
 };
 declare class CriticalRequestChains {
     /**
      * For now, we use network priorities as a proxy for "render-blocking"/critical-ness.
      * It's imperfect, but there is not a higher-fidelity signal available yet.
      * @see https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc
-     * @param {LH.Artifacts.NetworkRequest} request
-     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {Lantern.Types.NetworkRequest} request
+     * @param {Lantern.Types.NetworkRequest} mainResource
      * @return {boolean}
      */
-    static isCritical(request: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest): boolean;
+    static isCritical(request: Lantern.Types.NetworkRequest, mainResource: Lantern.Types.NetworkRequest): boolean;
     /**
      * Create a tree of critical requests.
      * @param {LH.Artifacts.NetworkRequest} mainResource
@@ -31,10 +29,10 @@ declare class CriticalRequestChains {
      * @return {Promise<LH.Artifacts.CriticalRequestNode>}
      */
     static compute_(data: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
         trace: LH.Trace;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.CriticalRequestNode>;
 }
-import { NetworkRequest } from '../lib/network-request.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 //# sourceMappingURL=critical-request-chains.d.ts.map

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

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRequest} from '../lib/network-request.js';
 import {MainResource} from './main-resource.js';
@@ -14,8 +15,8 @@ class CriticalRequestChains {
    * For now, we use network priorities as a proxy for "render-blocking"/critical-ness.
    * It's imperfect, but there is not a higher-fidelity signal available yet.
    * @see https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc
-   * @param {LH.Artifacts.NetworkRequest} request
-   * @param {LH.Artifacts.NetworkRequest} mainResource
+   * @param {Lantern.Types.NetworkRequest} request
+   * @param {Lantern.Types.NetworkRequest} mainResource
    * @return {boolean}
    */
   static isCritical(request, mainResource) {
@@ -105,11 +106,10 @@ class CriticalRequestChains {
     graph.traverse((node, traversalPath) => {
       seenNodes.add(node);
       if (node.type !== 'network') return;
-      if (!CriticalRequestChains.isCritical(node.rawRequest, mainResource)) return;
+      if (!CriticalRequestChains.isCritical(node.request, mainResource)) return;
 
       const networkPath = traversalPath
-        .filter(/** @return {n is LH.Gatherer.Simulation.GraphNetworkNode} */
-          n => n.type === 'network')
+        .filter(n => n.type === 'network')
         .reverse()
         .map(node => node.rawRequest);
 
@@ -117,7 +117,7 @@ class CriticalRequestChains {
       if (networkPath.some(r => !CriticalRequestChains.isCritical(r, mainResource))) return;
 
       // Ignore non-network things (like data urls).
-      if (NetworkRequest.isNonNetworkRequest(node.rawRequest)) return;
+      if (NetworkRequest.isNonNetworkRequest(node.request)) return;
 
       addChain(networkPath);
     }, getNextNodes);

package/core/computed/document-urls.d.ts

@@ -2,13 +2,8 @@ export { DocumentUrlsComputed as DocumentUrls };
 declare const DocumentUrlsComputed: typeof DocumentUrls & {
     request: (dependencies: {
         trace: LH.Trace;
-        devtoolsLog: import("../index.js").DevtoolsLog;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<{
-        requestedUrl: string;
-        mainDocumentUrl: string;
-    }>;
+        devtoolsLog: LH.DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof DocumentUrls.compute_>;
 };
 /**
  * @fileoverview Compute the navigation specific URLs `requestedUrl` and `mainDocumentUrl` in situations where
@@ -23,7 +18,7 @@ declare class DocumentUrls {
      */
     static compute_(data: {
         trace: LH.Trace;
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        devtoolsLog: LH.DevtoolsLog;
     }, context: LH.Artifacts.ComputedContext): Promise<{
         requestedUrl: string;
         mainDocumentUrl: string;

package/core/computed/document-urls.js

@@ -42,7 +42,7 @@ class DocumentUrls {
     if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
 
     const initialRequest =
-      Lantern.Simulation.NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+      Lantern.Core.NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
     if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
 
     return {requestedUrl, mainDocumentUrl};

package/core/computed/entity-classification.d.ts

@@ -2,11 +2,9 @@ export { EntityClassificationComputed as EntityClassification };
 export type EntityCache = Map<string, LH.Artifacts.Entity>;
 declare const EntityClassificationComputed: typeof EntityClassification & {
     request: (dependencies: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../index.js").Artifacts.EntityClassification>;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof EntityClassification.compute_>;
 };
 /** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
 declare class EntityClassification {
@@ -28,15 +26,15 @@ declare class EntityClassification {
      * @param {EntityCache} entityCache
      * @param {LH.DevtoolsLog} devtoolsLog
      */
-    static _preloadChromeExtensionsToCache(entityCache: EntityCache, devtoolsLog: import("../index.js").DevtoolsLog): void;
+    static _preloadChromeExtensionsToCache(entityCache: EntityCache, devtoolsLog: LH.DevtoolsLog): void;
     /**
      * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<LH.Artifacts.EntityClassification>}
      */
     static compute_(data: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.EntityClassification>;
 }
 //# sourceMappingURL=entity-classification.d.ts.map

package/core/computed/image-records.d.ts

@@ -1,11 +1,9 @@
 export { ImageRecordsComputed as ImageRecords };
 declare const ImageRecordsComputed: typeof ImageRecords & {
     request: (dependencies: {
-        ImageElements: LH.Artifacts['ImageElements'];
+        ImageElements: LH.Artifacts["ImageElements"];
         networkRecords: LH.Artifacts.NetworkRequest[];
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../index.js").Artifacts.ImageElementRecord[]>;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof ImageRecords.compute_>;
 };
 declare class ImageRecords {
     /**
@@ -17,7 +15,7 @@ declare class ImageRecords {
      * @return {Promise<LH.Artifacts.ImageElementRecord[]>}
      */
     static compute_(data: {
-        ImageElements: LH.Artifacts['ImageElements'];
+        ImageElements: LH.Artifacts["ImageElements"];
         networkRecords: LH.Artifacts.NetworkRequest[];
     }): Promise<LH.Artifacts.ImageElementRecord[]>;
 }

package/core/computed/js-bundles.d.ts

@@ -1,13 +1,11 @@
 export { JSBundlesComputed as JSBundles };
 declare const JSBundlesComputed: typeof JSBundles & {
-    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../index.js").Artifacts.Bundle[]>;
+    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: LH.Artifacts.ComputedContext) => ReturnType<typeof JSBundles.compute_>;
 };
 declare class JSBundles {
     /**
      * @param {Pick<LH.Artifacts, 'SourceMaps'|'Scripts'>} artifacts
      */
-    static compute_(artifacts: Pick<LH.Artifacts, 'SourceMaps' | 'Scripts'>): Promise<import("../index.js").Artifacts.Bundle[]>;
+    static compute_(artifacts: Pick<LH.Artifacts, "SourceMaps" | "Scripts">): Promise<import("../index.js").Artifacts.Bundle[]>;
 }
 //# sourceMappingURL=js-bundles.d.ts.map

package/core/computed/lcp-image-record.d.ts

@@ -2,10 +2,8 @@ export { LCPImageRecordComputed as LCPImageRecord };
 declare const LCPImageRecordComputed: typeof LCPImageRecord & {
     request: (dependencies: {
         trace: LH.Trace;
-        devtoolsLog: import("../index.js").DevtoolsLog;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../lib/network-request.js").NetworkRequest | undefined>;
+        devtoolsLog: LH.DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LCPImageRecord.compute_>;
 };
 /**
  * @fileoverview Match the LCP event with the paint event to get the request of the image actually painted.
@@ -20,7 +18,7 @@ declare class LCPImageRecord {
      */
     static compute_(data: {
         trace: LH.Trace;
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        devtoolsLog: LH.DevtoolsLog;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkRequest | undefined>;
 }
 //# sourceMappingURL=lcp-image-record.d.ts.map

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

@@ -1,28 +1,24 @@
 export { LoadSimulatorComputed as LoadSimulator };
 declare const LoadSimulatorComputed: typeof LoadSimulator & {
     request: (dependencies: {
-        devtoolsLog: import("../index.js").DevtoolsLog;
-        settings: LH.Audit.Context['settings'];
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<Lantern.Simulation.Simulator<any>>;
+        devtoolsLog: LH.DevtoolsLog;
+        settings: LH.Audit.Context["settings"];
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LoadSimulator.compute_>;
 };
 declare class LoadSimulator {
     /**
      * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<Lantern.Simulation.Simulator>}
+     * @return {Promise<LH.Gatherer.Simulation.Simulator>}
      */
     static compute_(data: {
-        devtoolsLog: import("../index.js").DevtoolsLog;
-        settings: LH.Audit.Context['settings'];
-    }, context: LH.Artifacts.ComputedContext): Promise<Lantern.Simulation.Simulator>;
+        devtoolsLog: LH.DevtoolsLog;
+        settings: LH.Audit.Context["settings"];
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Gatherer.Simulation.Simulator>;
     /**
      * @param {LH.Artifacts.NetworkAnalysis} networkAnalysis
      * @return {LH.PrecomputedLanternData}
      */
     static convertAnalysisToSaveableLanternData(networkAnalysis: LH.Artifacts.NetworkAnalysis): LH.PrecomputedLanternData;
 }
-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

@@ -12,7 +12,7 @@ class LoadSimulator {
   /**
    * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<Lantern.Simulation.Simulator>}
+   * @return {Promise<LH.Gatherer.Simulation.Simulator>}
    */
   static async compute_(data, context) {
     const networkAnalysis = await NetworkAnalysis.request(data.devtoolsLog, context);

package/core/computed/main-resource.d.ts

@@ -1,11 +1,9 @@
 export { MainResourceComputed as MainResource };
 declare const MainResourceComputed: typeof MainResource & {
     request: (dependencies: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
-    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../lib/network-request.js").NetworkRequest>;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext) => ReturnType<typeof MainResource.compute_>;
 };
 /**
  * @fileoverview This artifact identifies the main resource on the page. Current solution assumes
@@ -18,8 +16,8 @@ declare class MainResource {
      * @return {Promise<LH.Artifacts.NetworkRequest>}
      */
     static compute_(data: {
-        URL: LH.Artifacts['URL'];
-        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts["URL"];
+        devtoolsLog: LH.DevtoolsLog;
     }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkRequest>;
 }
 //# sourceMappingURL=main-resource.d.ts.map

package/core/computed/main-resource.js

@@ -29,7 +29,7 @@ class MainResource {
     // 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 =
-      Lantern.Simulation.NetworkAnalyzer.findLastDocumentForUrl(records, mainDocumentUrl);
+      Lantern.Core.NetworkAnalyzer.findLastDocumentForUrl(records, mainDocumentUrl);
     if (!mainResource) {
       throw new Error('Unable to identify the main resource');
     }

package/core/computed/main-thread-tasks.d.ts

@@ -1,8 +1,6 @@
 export { MainThreadTasksComputed as MainThreadTasks };
 declare const MainThreadTasksComputed: typeof MainThreadTasks & {
-    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../lib/tracehouse/main-thread-tasks.js").TaskNode[]>;
+    request: (dependencies: import("../index.js").Trace, context: LH.Artifacts.ComputedContext) => ReturnType<typeof MainThreadTasks.compute_>;
 };
 declare class MainThreadTasks {
     /**

package/core/computed/metrics/cumulative-layout-shift.d.ts

@@ -7,18 +7,7 @@ export type LayoutShiftEvent = {
     event: LH.TraceEvent;
 };
 declare const CumulativeLayoutShiftComputed: typeof CumulativeLayoutShift & {
-    request: (dependencies: import("../../index.js").Trace, context: import("../../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<{
-        cumulativeLayoutShift: number;
-        cumulativeLayoutShiftMainFrame: number;
-        impactByNodeId: Map<number, number>;
-        newEngineResult?: {
-            cumulativeLayoutShift: number;
-            cumulativeLayoutShiftMainFrame: number;
-        } | undefined;
-        newEngineResultDiffered: boolean;
-    }>;
+    request: (dependencies: import("../../index.js").Trace, context: LH.Artifacts.ComputedContext) => ReturnType<typeof CumulativeLayoutShift.compute_>;
 };
 declare class CumulativeLayoutShift {
     /**
@@ -69,9 +58,8 @@ declare class CumulativeLayoutShift {
         newEngineResult?: {
             cumulativeLayoutShift: number;
             cumulativeLayoutShiftMainFrame: number;
-        } | undefined;
+        };
         newEngineResultDiffered: boolean;
     }>;
 }
-import { ProcessedTrace } from '../processed-trace.js';
 //# sourceMappingURL=cumulative-layout-shift.d.ts.map

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

@@ -1,8 +1,6 @@
 export { FirstContentfulPaintAllFramesComputed as FirstContentfulPaintAllFrames };
 declare const FirstContentfulPaintAllFramesComputed: typeof FirstContentfulPaintAllFrames & {
-    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationMetric.compute_>;
 };
 declare class FirstContentfulPaintAllFrames extends NavigationMetric {
     /**

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

@@ -1,8 +1,6 @@
 export { FirstContentfulPaintComputed as FirstContentfulPaint };
 declare const FirstContentfulPaintComputed: typeof FirstContentfulPaint & {
-    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationMetric.compute_>;
 };
 declare class FirstContentfulPaint extends NavigationMetric {
     /**

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

@@ -10,9 +10,7 @@ export type TimePeriod = {
     end: number;
 };
 declare const InteractiveComputed: typeof Interactive & {
-    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof NavigationMetric.compute_>;
 };
 /**
  * @fileoverview Computes "Time To Interactive", the time at which the page has loaded critical

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

@@ -1,19 +1,15 @@
 export { LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint };
-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>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LanternFirstContentfulPaint.compute_>;
 };
-/** @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
-     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
      * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Lantern.Metrics.Extras, "optimistic"> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context

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

@@ -8,18 +8,16 @@ import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
-
 class LanternFirstContentfulPaint extends Lantern.Metrics.FirstContentfulPaint {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras)
-      .catch(lanternErrorAdapter);
+    const params = await getComputationDataParams(data, context);
+    return Promise.resolve(this.compute(params, extras)).catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -1,19 +1,15 @@
 export { LanternInteractiveComputed as LanternInteractive };
-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>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LanternInteractive.compute_>;
 };
-/** @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
-     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
      * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Lantern.Metrics.Extras, "optimistic"> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context

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

@@ -9,18 +9,16 @@ import {makeComputedArtifact} from '../computed-artifact.js';
 import {LanternLargestContentfulPaint} from './lantern-largest-contentful-paint.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 
-/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
-
 class LanternInteractive extends Lantern.Metrics.Interactive {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras)
-      .catch(lanternErrorAdapter);
+    const params = await getComputationDataParams(data, context);
+    return Promise.resolve(this.compute(params, extras)).catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -1,19 +1,15 @@
 export { LanternLargestContentfulPaintComputed as LanternLargestContentfulPaint };
-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>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LanternLargestContentfulPaint.compute_>;
 };
-/** @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
-     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
      * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Lantern.Metrics.Extras, "optimistic"> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context

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

@@ -9,18 +9,16 @@ import {makeComputedArtifact} from '../computed-artifact.js';
 import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
 import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
 
-/** @typedef {import('../../lib/lantern/Metric.js').Extras} Extras */
-
 class LanternLargestContentfulPaint extends Lantern.Metrics.LargestContentfulPaint {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras)
-      .catch(lanternErrorAdapter);
+    const params = await getComputationDataParams(data, context);
+    return Promise.resolve(this.compute(params, extras)).catch(lanternErrorAdapter);
   }
 
   /**

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

@@ -1,19 +1,15 @@
 export { LanternMaxPotentialFIDComputed as LanternMaxPotentialFID };
-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>;
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext) => ReturnType<typeof LanternMaxPotentialFID.compute_>;
 };
-/** @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
-     * @param {Omit<Extras, 'optimistic'>=} extras
+     * @param {Omit<Lantern.Metrics.Extras, 'optimistic'>=} extras
      * @return {Promise<LH.Artifacts.LanternMetric>}
      */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
+    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Lantern.Metrics.Extras, "optimistic"> | undefined): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} data
      * @param {LH.Artifacts.ComputedContext} context