lighthouse 11.6.0-dev.20240305 → 11.6.0-dev.20240307

package/core/lib/lantern/metric.js

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from './types/lantern.js';
+import {BaseNode} from '../../lib/lantern/base-node.js';
+import {NetworkRequest} from '../../lib/network-request.js';
+
+/** @typedef {import('./base-node.js').Node} Node */
+/** @typedef {import('./network-node.js').NetworkNode} NetworkNode */
+/** @typedef {import('./simulator/simulator.js').Simulator} Simulator */
+
+/**
+ * @typedef Extras
+ * @property {boolean} optimistic
+ * @property {LH.Artifacts.LanternMetric=} fcpResult
+ * @property {LH.Artifacts.LanternMetric=} fmpResult
+ * @property {LH.Artifacts.LanternMetric=} interactiveResult
+ * @property {{speedIndex: number}=} speedline
+ */
+
+class Metric {
+  /**
+   * @param {Node} dependencyGraph
+   * @param {function(NetworkNode):boolean=} treatNodeAsRenderBlocking
+   * @return {Set<string>}
+   */
+  static getScriptUrls(dependencyGraph, treatNodeAsRenderBlocking) {
+    /** @type {Set<string>} */
+    const scriptUrls = new Set();
+
+    dependencyGraph.traverse(node => {
+      if (node.type !== BaseNode.TYPES.NETWORK) return;
+      if (node.record.resourceType !== NetworkRequest.TYPES.Script) return;
+      if (treatNodeAsRenderBlocking?.(node)) {
+        scriptUrls.add(node.record.url);
+      }
+    });
+
+    return scriptUrls;
+  }
+
+  /**
+   * @return {Lantern.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    throw new Error('COEFFICIENTS unimplemented!');
+  }
+
+  /**
+   * 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
+   * from the simulator. In this case, we need to adjust the coefficients as the target throttling
+   * settings change.
+   *
+   * @param {number} rttMs
+   * @return {Lantern.Simulation.MetricCoefficients}
+   */
+  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
+    return this.COEFFICIENTS;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
+    throw new Error('Optimistic graph unimplemented!');
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
+    throw new Error('Pessmistic graph unimplemented!');
+  }
+
+  /**
+   * @param {Lantern.Simulation.Result} simulationResult
+   * @param {Extras} extras
+   * @return {Lantern.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulationResult, extras) { // eslint-disable-line no-unused-vars
+    return simulationResult;
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const {simulator, graph, processedNavigation} = data;
+
+    const metricName = this.name.replace('Lantern', '');
+    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
+    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
+
+    /** @type {{flexibleOrdering?: boolean, label?: string}} */
+    let simulateOptions = {label: `optimistic${metricName}`};
+    const optimisticSimulation = simulator.simulate(optimisticGraph, simulateOptions);
+
+    simulateOptions = {label: `optimisticFlex${metricName}`, flexibleOrdering: true};
+    const optimisticFlexSimulation = simulator.simulate(optimisticGraph, simulateOptions);
+
+    simulateOptions = {label: `pessimistic${metricName}`};
+    const pessimisticSimulation = simulator.simulate(pessimisticGraph, simulateOptions);
+
+    const optimisticEstimate = this.getEstimateFromSimulation(
+      optimisticSimulation.timeInMs < optimisticFlexSimulation.timeInMs ?
+        optimisticSimulation : optimisticFlexSimulation, {...extras, optimistic: true}
+    );
+
+    const pessimisticEstimate = this.getEstimateFromSimulation(
+      pessimisticSimulation,
+      {...extras, optimistic: false}
+    );
+
+    const coefficients = this.getScaledCoefficients(simulator.rtt);
+    // Estimates under 1s don't really follow the normal curve fit, minimize the impact of the intercept
+    const interceptMultiplier = coefficients.intercept > 0 ?
+      Math.min(1, optimisticEstimate.timeInMs / 1000) : 1;
+    const timing =
+      coefficients.intercept * interceptMultiplier +
+      coefficients.optimistic * optimisticEstimate.timeInMs +
+      coefficients.pessimistic * pessimisticEstimate.timeInMs;
+
+    return {
+      timing,
+      optimisticEstimate,
+      pessimisticEstimate,
+      optimisticGraph,
+      pessimisticGraph,
+    };
+  }
+}
+
+export {Metric};

package/core/lib/lantern/network-node.d.ts

@@ -1,13 +1,12 @@
-export type NetworkRequest<T> = import('../../../types/internal/lantern.js').Lantern.NetworkRequest<T>;
 /**
  * @template [T=any]
  * @extends {BaseNode<T>}
  */
 export class NetworkNode<T = any> extends BaseNode<T> {
     /**
-     * @param {NetworkRequest<T>} networkRequest
+     * @param {Lantern.NetworkRequest<T>} networkRequest
      */
-    constructor(networkRequest: NetworkRequest<T>);
+    constructor(networkRequest: Lantern.NetworkRequest<T>);
     /** @private */
     private _request;
     get type(): "network";
@@ -16,9 +15,9 @@ export class NetworkNode<T = any> extends BaseNode<T> {
      */
     get record(): Readonly<T>;
     /**
-     * @return {NetworkRequest<T>}
+     * @return {Lantern.NetworkRequest<T>}
      */
-    get request(): import("../../../types/internal/lantern.js").Lantern.NetworkRequest<T>;
+    get request(): Lantern.NetworkRequest<T>;
     /**
      * @return {string}
      */
@@ -47,4 +46,5 @@ export class NetworkNode<T = any> extends BaseNode<T> {
     cloneWithoutRelationships(): NetworkNode<T>;
 }
 import { BaseNode } from './base-node.js';
+import * as Lantern from './types/lantern.js';
 //# sourceMappingURL=network-node.d.ts.map

package/core/lib/lantern/network-node.js

@@ -4,8 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @template T @typedef {import('../../../types/internal/lantern.js').Lantern.NetworkRequest<T>} NetworkRequest */
-
+import * as Lantern from './types/lantern.js';
 import {NetworkRequestTypes} from './lantern.js';
 import {BaseNode} from './base-node.js';
 // TODO(15841): bring impl of isNonNetworkRequest inside lantern and remove this.
@@ -17,7 +16,7 @@ import UrlUtils from '../url-utils.js';
  */
 class NetworkNode extends BaseNode {
   /**
-   * @param {NetworkRequest<T>} networkRequest
+   * @param {Lantern.NetworkRequest<T>} networkRequest
    */
   constructor(networkRequest) {
     super(networkRequest.requestId);
@@ -51,7 +50,7 @@ class NetworkNode extends BaseNode {
   }
 
   /**
-   * @return {NetworkRequest<T>}
+   * @return {Lantern.NetworkRequest<T>}
    */
   get request() {
     return this._request;

package/core/lib/lantern/page-dependency-graph.d.ts

@@ -1,4 +1,3 @@
-export type NetworkRequest = import('../../../types/internal/lantern.js').Lantern.NetworkRequest;
 export type Node = import('./base-node.js').Node;
 export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
 export type NetworkNodeOutput = {
@@ -9,15 +8,15 @@ export type NetworkNodeOutput = {
 };
 export class PageDependencyGraph {
     /**
-     * @param {NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @return {Array<string>}
      */
-    static getNetworkInitiators(record: NetworkRequest): Array<string>;
+    static getNetworkInitiators(record: Lantern.NetworkRequest): Array<string>;
     /**
-     * @param {Array<NetworkRequest>} networkRecords
+     * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @return {NetworkNodeOutput}
      */
-    static getNetworkNodeOutput(networkRecords: Array<NetworkRequest>): NetworkNodeOutput;
+    static getNetworkNodeOutput(networkRecords: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
     /**
      * @param {LH.Artifacts.ProcessedTrace} processedTrace
      * @return {Array<CPUNode>}
@@ -42,11 +41,11 @@ export class PageDependencyGraph {
     static _pruneNode(node: Node): void;
     /**
      * @param {LH.Artifacts.ProcessedTrace} processedTrace
-     * @param {Array<NetworkRequest>} networkRecords
+     * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @param {URLArtifact} URL
      * @return {Node}
      */
-    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<NetworkRequest>, URL: URLArtifact): Node;
+    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<Lantern.NetworkRequest>, URL: URLArtifact): Node;
     /**
      *
      * @param {Node} rootNode
@@ -54,5 +53,6 @@ export class PageDependencyGraph {
     static printGraph(rootNode: Node, widthInCharacters?: number): void;
 }
 import { NetworkNode } from './network-node.js';
+import * as Lantern from './types/lantern.js';
 import { CPUNode } from './cpu-node.js';
 //# sourceMappingURL=page-dependency-graph.d.ts.map

package/core/lib/lantern/page-dependency-graph.js

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from './types/lantern.js';
 import {NetworkRequestTypes} from './lantern.js';
 import {NetworkNode} from './network-node.js';
 import {CPUNode} from './cpu-node.js';
 import {TraceProcessor} from '../tracehouse/trace-processor.js';
 import {NetworkAnalyzer} from './simulator/network-analyzer.js';
 
-/** @typedef {import('../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
 /** @typedef {import('./base-node.js').Node} Node */
 /** @typedef {Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>} URLArtifact */
 
@@ -31,7 +31,7 @@ const IGNORED_MIME_TYPES_REGEX = /^video/;
 
 class PageDependencyGraph {
   /**
-   * @param {NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @return {Array<string>}
    */
   static getNetworkInitiators(record) {
@@ -60,7 +60,7 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {Array<NetworkRequest>} networkRecords
+   * @param {Array<Lantern.NetworkRequest>} networkRecords
    * @return {NetworkNodeOutput}
    */
   static getNetworkNodeOutput(networkRecords) {
@@ -394,7 +394,7 @@ class PageDependencyGraph {
 
   /**
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @param {Array<NetworkRequest>} networkRecords
+   * @param {Array<Lantern.NetworkRequest>} networkRecords
    * @param {URLArtifact} URL
    * @return {Node}
    */

package/core/lib/lantern/simulator/connection-pool.d.ts

@@ -1,15 +1,15 @@
 export class ConnectionPool {
     /**
-     * @param {NetworkRequest[]} records
-     * @param {Required<SimulationOptions>} options
+     * @param {Lantern.NetworkRequest[]} records
+     * @param {Required<Lantern.Simulation.Options>} options
      */
-    constructor(records: NetworkRequest[], options: Required<SimulationOptions>);
-    _options: Required<import("../../../../types/internal/lantern.js").Lantern.Simulation.Options>;
-    _records: import("../../../../types/internal/lantern.js").Lantern.NetworkRequest<any>[];
+    constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>);
+    _options: Required<Lantern.Simulation.Options>;
+    _records: Lantern.NetworkRequest<any>[];
     /** @type {Map<string, TcpConnection[]>} */
     _connectionsByOrigin: Map<string, TcpConnection[]>;
-    /** @type {Map<NetworkRequest, TcpConnection>} */
-    _connectionsByRecord: Map<NetworkRequest, TcpConnection>;
+    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
+    _connectionsByRecord: Map<Lantern.NetworkRequest, TcpConnection>;
     _connectionsInUse: Set<any>;
     _connectionReusedByRequestId: Map<string, boolean>;
     /**
@@ -33,27 +33,26 @@ export class ConnectionPool {
      * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
      * Otherwise, only connections that have matching "warmth" are considered available.
      *
-     * @param {NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @param {{ignoreConnectionReused?: boolean}} options
      * @return {?TcpConnection}
      */
-    acquire(record: NetworkRequest, options?: {
+    acquire(record: Lantern.NetworkRequest, options?: {
         ignoreConnectionReused?: boolean;
     }): TcpConnection | null;
     /**
      * Return the connection currently being used to fetch a record. If no connection
      * currently being used for this record, an error will be thrown.
      *
-     * @param {NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @return {TcpConnection}
      */
-    acquireActiveConnectionFromRecord(record: NetworkRequest): TcpConnection;
+    acquireActiveConnectionFromRecord(record: Lantern.NetworkRequest): TcpConnection;
     /**
-     * @param {NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      */
-    release(record: NetworkRequest): void;
+    release(record: Lantern.NetworkRequest): void;
 }
-export type NetworkRequest = import('../../../../types/internal/lantern.js').Lantern.NetworkRequest;
-export type SimulationOptions = import('../../../../types/internal/lantern.js').Lantern.Simulation.Options;
+import * as Lantern from '../types/lantern.js';
 import { TcpConnection } from './tcp-connection.js';
 //# sourceMappingURL=connection-pool.d.ts.map

package/core/lib/lantern/simulator/connection-pool.js

@@ -4,9 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
-/** @typedef {import('../../../../types/internal/lantern.js').Lantern.Simulation.Options} SimulationOptions */
-
+import * as Lantern from '../types/lantern.js';
 import {NetworkAnalyzer} from './network-analyzer.js';
 import {TcpConnection} from './tcp-connection.js';
 
@@ -19,8 +17,8 @@ const CONNECTIONS_PER_ORIGIN = 6;
 
 export class ConnectionPool {
   /**
-   * @param {NetworkRequest[]} records
-   * @param {Required<SimulationOptions>} options
+   * @param {Lantern.NetworkRequest[]} records
+   * @param {Required<Lantern.Simulation.Options>} options
    */
   constructor(records, options) {
     this._options = options;
@@ -28,7 +26,7 @@ export class ConnectionPool {
     this._records = records;
     /** @type {Map<string, TcpConnection[]>} */
     this._connectionsByOrigin = new Map();
-    /** @type {Map<NetworkRequest, TcpConnection>} */
+    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
     this._connectionsByRecord = new Map();
     this._connectionsInUse = new Set();
     this._connectionReusedByRequestId = NetworkAnalyzer.estimateIfConnectionWasReused(records, {
@@ -126,7 +124,7 @@ export class ConnectionPool {
    * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
    * Otherwise, only connections that have matching "warmth" are considered available.
    *
-   * @param {NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @param {{ignoreConnectionReused?: boolean}} options
    * @return {?TcpConnection}
    */
@@ -152,7 +150,7 @@ export class ConnectionPool {
    * Return the connection currently being used to fetch a record. If no connection
    * currently being used for this record, an error will be thrown.
    *
-   * @param {NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @return {TcpConnection}
    */
   acquireActiveConnectionFromRecord(record) {
@@ -163,7 +161,7 @@ export class ConnectionPool {
   }
 
   /**
-   * @param {NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    */
   release(record) {
     const connection = this._connectionsByRecord.get(record);

package/core/lib/lantern/simulator/dns-cache.d.ts

@@ -1,4 +1,3 @@
-export type NetworkRequest = import('../../../../types/internal/lantern.js').Lantern.NetworkRequest;
 export class DNSCache {
     /**
      * @param {{rtt: number}} options
@@ -12,19 +11,19 @@ export class DNSCache {
         resolvedAt: number;
     }>;
     /**
-     * @param {NetworkRequest} request
+     * @param {Lantern.NetworkRequest} request
      * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
      * @return {number}
      */
-    getTimeUntilResolution(request: NetworkRequest, options?: {
+    getTimeUntilResolution(request: Lantern.NetworkRequest, options?: {
         requestedAt: number;
         shouldUpdateCache: boolean;
     } | undefined): number;
     /**
-     * @param {NetworkRequest} request
+     * @param {Lantern.NetworkRequest} request
      * @param {number} resolvedAt
      */
-    _updateCacheResolvedAtIfNeeded(request: NetworkRequest, resolvedAt: number): void;
+    _updateCacheResolvedAtIfNeeded(request: Lantern.NetworkRequest, resolvedAt: number): void;
     /**
      * Forcefully sets the DNS resolution time for a record.
      * Useful for testing and alternate execution simulations.
@@ -37,12 +36,7 @@ export class DNSCache {
 export namespace DNSCache {
     export { DNS_RESOLUTION_RTT_MULTIPLIER as RTT_MULTIPLIER };
 }
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
+import * as Lantern from '../types/lantern.js';
 declare const DNS_RESOLUTION_RTT_MULTIPLIER: 2;
 export {};
 //# sourceMappingURL=dns-cache.d.ts.map

package/core/lib/lantern/simulator/dns-cache.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
+import * as Lantern from '../types/lantern.js';
 
 // A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
 // Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
@@ -25,7 +25,7 @@ class DNSCache {
   }
 
   /**
-   * @param {NetworkRequest} request
+   * @param {Lantern.NetworkRequest} request
    * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
    * @return {number}
    */
@@ -47,7 +47,7 @@ class DNSCache {
   }
 
   /**
-   * @param {NetworkRequest} request
+   * @param {Lantern.NetworkRequest} request
    * @param {number} resolvedAt
    */
   _updateCacheResolvedAtIfNeeded(request, resolvedAt) {

package/core/lib/lantern/simulator/network-analyzer.d.ts

@@ -1,4 +1,3 @@
-export type NetworkRequest = import('../../../../types/internal/lantern.js').Lantern.NetworkRequest;
 export type Summary = {
     min: number;
     max: number;
@@ -33,10 +32,10 @@ export class NetworkAnalyzer {
      */
     static get SUMMARY(): string;
     /**
-     * @param {NetworkRequest[]} records
-     * @return {Map<string, NetworkRequest[]>}
+     * @param {Lantern.NetworkRequest[]} records
+     * @return {Map<string, Lantern.NetworkRequest[]>}
      */
-    static groupByOrigin(records: NetworkRequest[]): Map<string, NetworkRequest[]>;
+    static groupByOrigin(records: Lantern.NetworkRequest[]): Map<string, Lantern.NetworkRequest[]>;
     /**
      * @param {number[]} values
      * @return {Summary}
@@ -47,14 +46,14 @@ export class NetworkAnalyzer {
      * @return {Map<string, Summary>}
      */
     static summarize(values: Map<string, number[]>): Map<string, Summary>;
-    /** @typedef {{record: NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
      * @return {Map<string, number[]>}
      */
-    static _estimateValueByOrigin(records: NetworkRequest[], iteratee: (e: {
-        record: NetworkRequest;
+    static _estimateValueByOrigin(records: Lantern.NetworkRequest[], iteratee: (e: {
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }) => number | number[] | undefined): Map<string, number[]>;
@@ -70,7 +69,7 @@ export class NetworkAnalyzer {
      * @return {number[]|number|undefined}
      */
     static _estimateRTTViaConnectionTiming(info: {
-        record: NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number[] | number | undefined;
@@ -83,7 +82,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaDownloadTiming(info: {
-        record: NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -97,7 +96,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaSendStartTiming(info: {
-        record: NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -111,32 +110,32 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaHeadersEndTiming(info: {
-        record: NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**
      * Given the RTT to each origin, estimates the observed server response times.
      *
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {Map<string, number>} rttByOrigin
      * @return {Map<string, number[]>}
      */
-    static _estimateResponseTimeByOrigin(records: NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static _estimateResponseTimeByOrigin(records: Lantern.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
     /**
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @return {boolean}
      */
-    static canTrustConnectionInformation(records: NetworkRequest[]): boolean;
+    static canTrustConnectionInformation(records: Lantern.NetworkRequest[]): boolean;
     /**
      * Returns a map of requestId -> connectionReused, estimating the information if the information
      * available in the records themselves appears untrustworthy.
      *
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {{forceCoarseEstimates: boolean}} [options]
      * @return {Map<string, boolean>}
      */
-    static estimateIfConnectionWasReused(records: NetworkRequest[], options?: {
+    static estimateIfConnectionWasReused(records: Lantern.NetworkRequest[], options?: {
         forceCoarseEstimates: boolean;
     } | undefined): Map<string, boolean>;
     /**
@@ -144,20 +143,20 @@ export class NetworkAnalyzer {
      * Attempts to use the most accurate information first and falls back to coarser estimates when it
      * is unavailable.
      *
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateRTTByOrigin(records: NetworkRequest[], options?: RTTEstimateOptions | undefined): Map<string, Summary>;
+    static estimateRTTByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions | undefined): Map<string, Summary>;
     /**
      * Estimates the server response time of each origin. RTT times can be passed in or will be
      * estimated automatically if not provided.
      *
-     * @param {NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateServerResponseTimeByOrigin(records: NetworkRequest[], options?: (RTTEstimateOptions & {
+    static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options?: (RTTEstimateOptions & {
         rttByOrigin?: Map<string, number> | undefined;
     }) | undefined): Map<string, Summary>;
     /**
@@ -165,32 +164,33 @@ export class NetworkAnalyzer {
      * Excludes data URI, failed or otherwise incomplete, and cached requests.
      * Returns Infinity if there were no analyzable network records.
      *
-     * @param {Array<NetworkRequest>} networkRecords
+     * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @return {number}
      */
-    static estimateThroughput(networkRecords: Array<NetworkRequest>): number;
+    static estimateThroughput(networkRecords: Array<Lantern.NetworkRequest>): number;
     /**
-     * @template {NetworkRequest} T
+     * @template {Lantern.NetworkRequest} T
      * @param {Array<T>} records
      * @param {string} resourceUrl
      * @return {T|undefined}
      */
-    static findResourceForUrl<T extends import("../../../../types/internal/lantern.js").Lantern.NetworkRequest<any>>(records: T[], resourceUrl: string): T | undefined;
+    static findResourceForUrl<T extends Lantern.NetworkRequest<any>>(records: T[], resourceUrl: string): T | undefined;
     /**
-     * @template {NetworkRequest} T
+     * @template {Lantern.NetworkRequest} T
      * @param {Array<T>} records
      * @param {string} resourceUrl
      * @return {T|undefined}
      */
-    static findLastDocumentForUrl<T_1 extends import("../../../../types/internal/lantern.js").Lantern.NetworkRequest<any>>(records: T_1[], resourceUrl: string): T_1 | undefined;
+    static findLastDocumentForUrl<T_1 extends Lantern.NetworkRequest<any>>(records: T_1[], resourceUrl: string): T_1 | undefined;
     /**
      * Resolves redirect chain given a main document.
      * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
      *
-     * @template {NetworkRequest} T
+     * @template {Lantern.NetworkRequest} T
      * @param {T} request
      * @return {T}
      */
-    static resolveRedirects<T_2 extends import("../../../../types/internal/lantern.js").Lantern.NetworkRequest<any>>(request: T_2): T_2;
+    static resolveRedirects<T_2 extends Lantern.NetworkRequest<any>>(request: T_2): T_2;
 }
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=network-analyzer.d.ts.map