lighthouse 12.1.0 → 12.2.0

package/core/lib/lantern/metrics/MaxPotentialFID.js

@@ -1,91 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-/** @typedef {import('../BaseNode.js').Node} Node */
-
-class MaxPotentialFID extends Lantern.Metric {
-  /**
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result} simulation
-   * @param {import('../Metric.js').Extras} extras
-   * @return {Lantern.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-
-    // Intentionally use the opposite FCP estimate, a more pessimistic FCP means that more tasks
-    // are excluded from the FID computation, so a higher FCP means lower FID for same work.
-    const fcpTimeInMs = extras.optimistic
-      ? extras.fcpResult.pessimisticEstimate.timeInMs
-      : extras.fcpResult.optimisticEstimate.timeInMs;
-
-    const timings = MaxPotentialFID.getTimingsAfterFCP(
-      simulation.nodeTimings,
-      fcpTimeInMs
-    );
-
-    return {
-      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
-      nodeTimings: simulation.nodeTimings,
-    };
-  }
-
-  /**
-   * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metrics.Result>}
-   */
-  static compute(data, extras) {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Error('FCP is required to calculate the Max Potential FID metric');
-    }
-
-    return super.compute(data, extras);
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {Array<{duration: number}>}
-   */
-  static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
-    return Array.from(nodeTimings.entries())
-      .filter(([node, timing]) =>
-        node.type === Lantern.BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
-      .map(([_, timing]) => timing);
-  }
-}
-
-export {MaxPotentialFID};

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

@@ -1,19 +0,0 @@
-/**
- * @param {TraceEngine.Types.TraceEvents.TraceEventData[]} traceEvents
- */
-export function runTraceEngine(traceEvents: TraceEngine.Types.TraceEvents.TraceEventData[]): Promise<TraceEngine.Handlers.Types.EnabledHandlerDataWithMeta<typeof TraceEngine.Handlers.ModelHandlers>>;
-/**
- * @param {{trace: Lantern.Trace, settings?: Lantern.Simulation.Settings, URL?: Lantern.Simulation.URL}} opts
- */
-export function getComputationDataFromFixture({ trace, settings, URL }: {
-    trace: Lantern.Trace;
-    settings?: Lantern.Simulation.Settings;
-    URL?: Lantern.Simulation.URL;
-}): Promise<{
-    simulator: Lantern.Simulation.Simulator<any>;
-    graph: import("../PageDependencyGraph.js").Node;
-    processedNavigation: import("../types/lantern.js").Simulation.ProcessedNavigation;
-}>;
-import * as TraceEngine from '@paulirish/trace_engine';
-import * as Lantern from '../lantern.js';
-//# sourceMappingURL=MetricTestUtils.d.ts.map

package/core/lib/lantern/metrics/MetricTestUtils.js

@@ -1,48 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as TraceEngine from '@paulirish/trace_engine';
-
-import * as Lantern from '../lantern.js';
-import {polyfillDOMRect} from '../../polyfill-dom-rect.js';
-
-polyfillDOMRect();
-
-/**
- * @param {TraceEngine.Types.TraceEvents.TraceEventData[]} traceEvents
- */
-async function runTraceEngine(traceEvents) {
-  const processor = TraceEngine.Processor.TraceProcessor.createWithAllHandlers();
-  await processor.parse(traceEvents);
-  if (!processor.traceParsedData) throw new Error('No data');
-  return processor.traceParsedData;
-}
-
-/**
- * @param {{trace: Lantern.Trace, settings?: Lantern.Simulation.Settings, URL?: Lantern.Simulation.URL}} opts
- */
-async function getComputationDataFromFixture({trace, settings, URL}) {
-  settings = settings ?? /** @type {Lantern.Simulation.Settings} */({});
-  if (!settings.throttlingMethod) settings.throttlingMethod = 'simulate';
-  const traceEngineData = await runTraceEngine(
-    /** @type {TraceEngine.Types.TraceEvents.TraceEventData[]} */ (trace.traceEvents)
-  );
-  const requests =
-    Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
-  const networkAnalysis = Lantern.Simulation.NetworkAnalyzer.analyze(requests);
-
-  return {
-    simulator: Lantern.Simulation.Simulator.createSimulator({...settings, networkAnalysis}),
-    graph: Lantern.TraceEngineComputationData.createGraph(requests, trace, traceEngineData, URL),
-    processedNavigation:
-      Lantern.TraceEngineComputationData.createProcessedNavigation(traceEngineData),
-  };
-}
-
-export {
-  runTraceEngine,
-  getComputationDataFromFixture,
-};

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

@@ -1,32 +0,0 @@
-export type Node = import('../BaseNode.js').Node;
-/** @typedef {import('../BaseNode.js').Node} Node */
-export class SpeedIndex extends Lantern.Metric {
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * Approximate speed index using layout events from the simulated node timings.
-     * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
-     * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
-     *
-     * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
-     *
-     * This approach was determined after evaluating the accuracy/complexity tradeoff of many
-     * different methods. Read more in the evaluation doc.
-     *
-     * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} fcpTimeInMs
-     * @return {number}
-     */
-    static computeLayoutBasedSpeedIndex(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
-}
-import * as Lantern from '../lantern.js';
-//# sourceMappingURL=SpeedIndex.d.ts.map

package/core/lib/lantern/metrics/SpeedIndex.js

@@ -1,142 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-const mobileSlow4GRtt = 150;
-
-/** @typedef {import('../BaseNode.js').Node} Node */
-
-class SpeedIndex extends Lantern.Metric {
-  /**
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      // Note that the optimistic estimate is based on the real observed speed index rather than a
-      // real lantern graph (and the final estimate will be Math.max(FCP, Speed Index)).
-      intercept: 0,
-      optimistic: 1.4,
-      pessimistic: 0.4,
-    };
-  }
-
-  /**
-   * @param {number} rttMs
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    // We want to scale our default coefficients based on the speed of the connection.
-    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
-    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
-    //      30 ms was based on a typical home WiFi connection's actual RTT.
-    //      Coefficients here follow from the fact that the optimistic estimate should be very close
-    //      to reality at this connection speed and the pessimistic estimate compensates for minor
-    //      connection speed differences.
-    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
-    //      Coefficients here were determined through thorough analysis and linear regression on the
-    //      lantern test data set. See core/scripts/test-lantern.sh for more detail.
-    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
-    const defaultCoefficients = this.COEFFICIENTS;
-    const defaultRttExcess = mobileSlow4GRtt - 30;
-    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
-
-    return {
-      intercept: defaultCoefficients.intercept * multiplier,
-      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
-      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result} simulationResult
-   * @param {import('../Metric.js').Extras} extras
-   * @return {Lantern.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (extras.observedSpeedIndex === undefined) throw new Error('missing observedSpeedIndex');
-
-    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
-    const estimate = extras.optimistic
-      ? extras.observedSpeedIndex
-      : SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
-    return {
-      timeInMs: estimate,
-      nodeTimings: simulationResult.nodeTimings,
-    };
-  }
-
-  /**
-   * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metrics.Result>}
-   */
-  static async compute(data, extras) {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Error('FCP is required to calculate the SpeedIndex metric');
-    }
-
-    const metricResult = await super.compute(data, extras);
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-
-  /**
-   * Approximate speed index using layout events from the simulated node timings.
-   * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
-   * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
-   *
-   * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
-   *
-   * This approach was determined after evaluating the accuracy/complexity tradeoff of many
-   * different methods. Read more in the evaluation doc.
-   *
-   * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
-   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} fcpTimeInMs
-   * @return {number}
-   */
-  static computeLayoutBasedSpeedIndex(nodeTimings, fcpTimeInMs) {
-    /** @type {Array<{time: number, weight: number}>} */
-    const layoutWeights = [];
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
-
-      if (node.childEvents.some(x => x.name === 'Layout')) {
-        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
-        layoutWeights.push({time: timing.endTime, weight: timingWeight});
-      }
-    }
-
-    const totalWeightedTime = layoutWeights
-      .map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs))
-      .reduce((a, b) => a + b, 0);
-    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
-
-    if (!totalWeight) return fcpTimeInMs;
-    return totalWeightedTime / totalWeight;
-  }
-}
-
-export {SpeedIndex};

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

@@ -1,83 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-import {readJson} from '../../../test/test-utils.js';
-import {getComputationDataFromFixture} from './MetricTestUtils.js';
-
-const {SpeedIndex, FirstContentfulPaint} = Lantern.Metrics;
-
-const trace = readJson('../../../test/fixtures/artifacts/progressive-app/trace.json', import.meta);
-
-const defaultThrottling = Lantern.Simulation.Constants.throttling.mobileSlow4G;
-
-describe('Metrics: Lantern Speed Index', () => {
-  it('should compute predicted value', async () => {
-    const data = await getComputationDataFromFixture({trace});
-    // TODO: observedSpeedIndex is from the Speedline library, and is used for optimistic
-    // mode. At the moment callers must pass the result into Lantern.
-    const observedSpeedIndex = 379.04474997520487;
-    const result = await SpeedIndex.compute(data, {
-      fcpResult: await FirstContentfulPaint.compute(data),
-      observedSpeedIndex,
-    });
-
-    expect({
-      timing: Math.round(result.timing),
-      optimistic: Math.round(result.optimisticEstimate.timeInMs),
-      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
-toMatchInlineSnapshot(`
-Object {
-  "optimistic": 379,
-  "pessimistic": 1122,
-  "timing": 1107,
-}
-`);
-  });
-
-  it('should compute predicted value for different settings', async () => {
-    const settings = {throttlingMethod: 'simulate', throttling: {...defaultThrottling, rttMs: 300}};
-    const data = await getComputationDataFromFixture({trace, settings});
-    const observedSpeedIndex = 379.04474997520487;
-    const result = await SpeedIndex.compute(data, {
-      fcpResult: await FirstContentfulPaint.compute(data),
-      observedSpeedIndex,
-    });
-
-    expect({
-      timing: Math.round(result.timing),
-      optimistic: Math.round(result.optimisticEstimate.timeInMs),
-      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
-toMatchInlineSnapshot(`
-Object {
-  "optimistic": 379,
-  "pessimistic": 2022,
-  "timing": 2007,
-}
-`);
-  });
-
-  it('should not scale coefficients at default', async () => {
-    const result = SpeedIndex.getScaledCoefficients(defaultThrottling.rttMs);
-    expect(result).toEqual(SpeedIndex.COEFFICIENTS);
-  });
-
-  it('should scale coefficients back', async () => {
-    const result = SpeedIndex.getScaledCoefficients(5);
-    expect(result).toEqual({intercept: 0, pessimistic: 0.5, optimistic: 0.5});
-  });
-
-  it('should scale coefficients forward', async () => {
-    const result = SpeedIndex.getScaledCoefficients(300);
-    expect(result).toMatchInlineSnapshot(`
-      Object {
-        "intercept": 0,
-        "optimistic": 2.525,
-        "pessimistic": 0.275,
-      }
-    `);
-  });
-});

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

@@ -1,25 +0,0 @@
-export type Node = import('../BaseNode.js').Node;
-/** @typedef {import('../BaseNode.js').Node} Node */
-export class TotalBlockingTime extends Lantern.Metric {
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} minDurationMs
-     */
-    static getTopLevelEvents(nodeTimings: Lantern.Simulation.Result['nodeTimings'], minDurationMs: number): {
-        start: number;
-        end: number;
-        duration: number;
-    }[];
-}
-import * as Lantern from '../lantern.js';
-//# sourceMappingURL=TotalBlockingTime.d.ts.map

package/core/lib/lantern/metrics/TotalBlockingTime.js

@@ -1,125 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-/** @typedef {import('../BaseNode.js').Node} Node */
-
-class TotalBlockingTime extends Lantern.Metric {
-  /**
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph) {
-    return dependencyGraph;
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result} simulation
-   * @param {import('../Metric.js').Extras} extras
-   * @return {Lantern.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulation, extras) {
-    if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.interactiveResult) throw new Error('missing interactiveResult');
-
-    // Intentionally use the opposite FCP estimate. A pessimistic FCP is higher than equal to an
-    // optimistic FCP, which means potentially more tasks are excluded from the Total Blocking Time
-    // computation. So a more pessimistic FCP gives a more optimistic Total Blocking Time for the
-    // same work.
-    const fcpTimeInMs = extras.optimistic
-      ? extras.fcpResult.pessimisticEstimate.timeInMs
-      : extras.fcpResult.optimisticEstimate.timeInMs;
-
-    // Similarly, we always have pessimistic TTI >= optimistic TTI. Therefore, picking optimistic
-    // TTI means our window of interest is smaller and thus potentially more tasks are excluded from
-    // Total Blocking Time computation, yielding a lower (more optimistic) Total Blocking Time value
-    // for the same work.
-    const interactiveTimeMs = extras.optimistic
-      ? extras.interactiveResult.optimisticEstimate.timeInMs
-      : extras.interactiveResult.pessimisticEstimate.timeInMs;
-
-    const minDurationMs = Lantern.TBTUtils.BLOCKING_TIME_THRESHOLD;
-
-    const events = TotalBlockingTime.getTopLevelEvents(
-      simulation.nodeTimings,
-      minDurationMs
-    );
-
-    return {
-      timeInMs: Lantern.TBTUtils.calculateSumOfBlockingTime(
-        events,
-        fcpTimeInMs,
-        interactiveTimeMs
-      ),
-      nodeTimings: simulation.nodeTimings,
-    };
-  }
-
-  /**
-   * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metrics.Result>}
-   */
-  static async compute(data, extras) {
-    const fcpResult = extras?.fcpResult;
-    if (!fcpResult) {
-      throw new Error('FCP is required to calculate the TBT metric');
-    }
-
-    const interactiveResult = extras?.fcpResult;
-    if (!interactiveResult) {
-      throw new Error('Interactive is required to calculate the TBT metric');
-    }
-
-    return super.compute(data, extras);
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
-   * @param {number} minDurationMs
-   */
-  static getTopLevelEvents(nodeTimings, minDurationMs) {
-    /** @type {Array<{start: number, end: number, duration: number}>}
-     */
-    const events = [];
-
-    for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
-      // Filtering out events below minimum duration.
-      if (timing.duration < minDurationMs) continue;
-
-      events.push({
-        start: timing.startTime,
-        end: timing.endTime,
-        duration: timing.duration,
-      });
-    }
-
-    return events;
-  }
-}
-
-export {TotalBlockingTime};

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

@@ -1,11 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Metrics: Lantern FCP should compute predicted value 1`] = `
-Object {
-  "optimistic": 1107,
-  "optimisticNodeTimings": 4,
-  "pessimistic": 1107,
-  "pessimisticNodeTimings": 4,
-  "timing": 1107,
-}
-`;

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

@@ -1,17 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Metrics: Lantern TTI should compute predicted value 1`] = `
-Object {
-  "optimistic": 1107,
-  "pessimistic": 1134,
-  "timing": 1122,
-}
-`;
-
-exports[`Metrics: Lantern TTI should compute predicted value on iframes with substantial layout 1`] = `
-Object {
-  "optimistic": 2372,
-  "pessimistic": 2386,
-  "timing": 2379,
-}
-`;

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

@@ -1,9 +0,0 @@
-export { FirstContentfulPaint } from "./FirstContentfulPaint.js";
-export { Interactive } from "./Interactive.js";
-export { LargestContentfulPaint } from "./LargestContentfulPaint.js";
-export { MaxPotentialFID } from "./MaxPotentialFID.js";
-export { SpeedIndex } from "./SpeedIndex.js";
-export { TotalBlockingTime } from "./TotalBlockingTime.js";
-export type Result<T = any> = Lantern.MetricResult<T>;
-import * as Lantern from '../types/lantern.js';
-//# sourceMappingURL=metrics.d.ts.map

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

@@ -1,16 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../types/lantern.js';
-
-export {FirstContentfulPaint} from './FirstContentfulPaint.js';
-export {Interactive} from './Interactive.js';
-export {LargestContentfulPaint} from './LargestContentfulPaint.js';
-export {MaxPotentialFID} from './MaxPotentialFID.js';
-export {SpeedIndex} from './SpeedIndex.js';
-export {TotalBlockingTime} from './TotalBlockingTime.js';
-
-/** @template [T=any] @typedef {Lantern.MetricResult<T>} Result */

package/core/lib/lantern/simulation/ConnectionPool.d.ts

@@ -1,48 +0,0 @@
-export class ConnectionPool {
-    /**
-     * @param {Lantern.NetworkRequest[]} records
-     * @param {Required<Lantern.Simulation.Options>} options
-     */
-    constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>);
-    _options: Required<import("../types/lantern.js").Simulation.Options>;
-    _records: Lantern.NetworkRequest<any>[];
-    /** @type {Map<string, TcpConnection[]>} */
-    _connectionsByOrigin: Map<string, TcpConnection[]>;
-    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
-    _connectionsByRequest: Map<Lantern.NetworkRequest, TcpConnection>;
-    _connectionsInUse: Set<any>;
-    _connectionReusedByRequestId: Map<string, boolean>;
-    /**
-     * @return {TcpConnection[]}
-     */
-    connectionsInUse(): TcpConnection[];
-    _initializeConnections(): void;
-    /**
-     * @param {Array<TcpConnection>} connections
-     */
-    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>): Lantern.Simulation.TcpConnection | null;
-    /**
-     * This method finds an available connection to the origin specified by the network request or null
-     * if no connection was available. If returned, connection will not be available for other network
-     * records until release is called.
-     *
-     * @param {Lantern.NetworkRequest} request
-     * @return {?TcpConnection}
-     */
-    acquire(request: Lantern.NetworkRequest): TcpConnection | null;
-    /**
-     * Return the connection currently being used to fetch a request. If no connection
-     * currently being used for this request, an error will be thrown.
-     *
-     * @param {Lantern.NetworkRequest} request
-     * @return {TcpConnection}
-     */
-    acquireActiveConnectionFromRequest(request: Lantern.NetworkRequest): TcpConnection;
-    /**
-     * @param {Lantern.NetworkRequest} request
-     */
-    release(request: Lantern.NetworkRequest): void;
-}
-import * as Lantern from '../lantern.js';
-import { TcpConnection } from './TcpConnection.js';
-//# sourceMappingURL=ConnectionPool.d.ts.map