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

package/core/lib/lantern/metrics/{largest-contentful-paint.js → LargestContentfulPaint.js}

@@ -4,14 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {FirstContentfulPaint} from './first-contentful-paint.js';
-import {LanternError} from '../lantern-error.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class LargestContentfulPaint extends Metric {
+class LargestContentfulPaint extends Lantern.Metric {
   /**
    * @return {Lantern.Simulation.MetricCoefficients}
    */
@@ -45,10 +42,10 @@ class LargestContentfulPaint extends Metric {
   static getOptimisticGraph(dependencyGraph, processedNavigation) {
     const lcp = processedNavigation.timestamps.largestContentfulPaint;
     if (!lcp) {
-      throw new LanternError('NO_LCP');
+      throw new Lantern.Error('NO_LCP');
     }
 
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+    return Lantern.Metrics.FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
       cutoffTimestamp: lcp,
       treatNodeAsRenderBlocking: LargestContentfulPaint.isNotLowPriorityImageNode,
     });
@@ -62,10 +59,10 @@ class LargestContentfulPaint extends Metric {
   static getPessimisticGraph(dependencyGraph, processedNavigation) {
     const lcp = processedNavigation.timestamps.largestContentfulPaint;
     if (!lcp) {
-      throw new LanternError('NO_LCP');
+      throw new Lantern.Error('NO_LCP');
     }
 
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
+    return Lantern.Metrics.FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
       cutoffTimestamp: lcp,
       treatNodeAsRenderBlocking: _ => true,
       // For pessimistic LCP we'll include *all* layout nodes
@@ -90,8 +87,8 @@ class LargestContentfulPaint extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;

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

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from '../lantern.js';
+import {getComputationDataFromFixture} from './MetricTestUtils.js';
+import {readJson} from '../../../test/test-utils.js';
+
+const {FirstContentfulPaint, LargestContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../fixtures/artifacts/paul/trace.json', import.meta);
+
+describe('Metrics: Lantern LCP', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    const result = await LargestContentfulPaint.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs),
+      optimisticNodeTimings: result.optimisticEstimate.nodeTimings.size,
+      pessimisticNodeTimings: result.pessimisticEstimate.nodeTimings.size}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 1457,
+  "optimisticNodeTimings": 8,
+  "pessimistic": 1616,
+  "pessimisticNodeTimings": 9,
+  "timing": 1536,
+}
+`);
+    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
+    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+  });
+});

package/core/lib/lantern/metrics/{max-potential-fid.d.ts → MaxPotentialFID.d.ts}

@@ -1,6 +1,6 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class MaxPotentialFID extends Metric {
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class MaxPotentialFID extends Lantern.Metric {
     /**
      * @param {Node} dependencyGraph
      * @return {Node}
@@ -20,6 +20,5 @@ export class MaxPotentialFID extends Metric {
         duration: number;
     }>;
 }
-import { Metric } from '../metric.js';
-import * as Lantern from '../types/lantern.js';
-//# sourceMappingURL=max-potential-fid.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=MaxPotentialFID.d.ts.map

package/core/lib/lantern/metrics/{max-potential-fid.js → MaxPotentialFID.js}

@@ -4,13 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class MaxPotentialFID extends Metric {
+class MaxPotentialFID extends Lantern.Metric {
   /**
    * @return {Lantern.Simulation.MetricCoefficients}
    */
@@ -40,7 +38,7 @@ class MaxPotentialFID extends Metric {
 
   /**
    * @param {Lantern.Simulation.Result} simulation
-   * @param {import('../metric.js').Extras} extras
+   * @param {import('../Metric.js').Extras} extras
    * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
@@ -65,8 +63,8 @@ class MaxPotentialFID extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -84,7 +82,8 @@ class MaxPotentialFID extends Metric {
    */
   static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
     return Array.from(nodeTimings.entries())
-      .filter(([node, timing]) => node.type === BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
+      .filter(([node, timing]) =>
+        node.type === Lantern.BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
       .map(([_, timing]) => timing);
   }
 }

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

@@ -0,0 +1,19 @@
+/**
+ * @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

@@ -0,0 +1,48 @@
+/**
+ * @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/{speed-index.d.ts → SpeedIndex.d.ts}

@@ -1,6 +1,6 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class SpeedIndex extends Metric {
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class SpeedIndex extends Lantern.Metric {
     /**
      * @param {Node} dependencyGraph
      * @return {Node}
@@ -28,6 +28,5 @@ export class SpeedIndex extends Metric {
      */
     static computeLayoutBasedSpeedIndex(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
 }
-import { Metric } from '../metric.js';
-import * as Lantern from '../types/lantern.js';
-//# sourceMappingURL=speed-index.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=SpeedIndex.d.ts.map

package/core/lib/lantern/metrics/{speed-index.js → SpeedIndex.js}

@@ -4,15 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
+import * as Lantern from '../lantern.js';
 
 const mobileSlow4GRtt = 150;
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class SpeedIndex extends Metric {
+class SpeedIndex extends Lantern.Metric {
   /**
    * @return {Lantern.Simulation.MetricCoefficients}
    */
@@ -71,7 +69,7 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {Lantern.Simulation.Result} simulationResult
-   * @param {import('../metric.js').Extras} extras
+   * @param {import('../Metric.js').Extras} extras
    * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
@@ -90,8 +88,8 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -123,7 +121,7 @@ class SpeedIndex extends Metric {
     /** @type {Array<{time: number, weight: number}>} */
     const layoutWeights = [];
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      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);

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

@@ -0,0 +1,83 @@
+/**
+ * @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('../../../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/{total-blocking-time.d.ts → TotalBlockingTime.d.ts}

@@ -1,6 +1,6 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class TotalBlockingTime extends Metric {
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class TotalBlockingTime extends Lantern.Metric {
     /**
      * @param {Node} dependencyGraph
      * @return {Node}
@@ -21,6 +21,5 @@ export class TotalBlockingTime extends Metric {
         duration: number;
     }[];
 }
-import { Metric } from '../metric.js';
-import * as Lantern from '../types/lantern.js';
-//# sourceMappingURL=total-blocking-time.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=TotalBlockingTime.d.ts.map

package/core/lib/lantern/metrics/{total-blocking-time.js → TotalBlockingTime.js}

@@ -4,14 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {BaseNode} from '../base-node.js';
-import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../tbt-utils.js';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class TotalBlockingTime extends Metric {
+class TotalBlockingTime extends Lantern.Metric {
   /**
    * @return {Lantern.Simulation.MetricCoefficients}
    */
@@ -41,7 +38,7 @@ class TotalBlockingTime extends Metric {
 
   /**
    * @param {Lantern.Simulation.Result} simulation
-   * @param {import('../metric.js').Extras} extras
+   * @param {import('../Metric.js').Extras} extras
    * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
@@ -64,7 +61,7 @@ class TotalBlockingTime extends Metric {
       ? extras.interactiveResult.optimisticEstimate.timeInMs
       : extras.interactiveResult.pessimisticEstimate.timeInMs;
 
-    const minDurationMs = BLOCKING_TIME_THRESHOLD;
+    const minDurationMs = Lantern.TBTUtils.BLOCKING_TIME_THRESHOLD;
 
     const events = TotalBlockingTime.getTopLevelEvents(
       simulation.nodeTimings,
@@ -72,7 +69,7 @@ class TotalBlockingTime extends Metric {
     );
 
     return {
-      timeInMs: calculateSumOfBlockingTime(
+      timeInMs: Lantern.TBTUtils.calculateSumOfBlockingTime(
         events,
         fcpTimeInMs,
         interactiveTimeMs
@@ -83,8 +80,8 @@ class TotalBlockingTime extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -110,7 +107,7 @@ class TotalBlockingTime extends Metric {
     const events = [];
 
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
       // Filtering out events below minimum duration.
       if (timing.duration < minDurationMs) continue;
 

package/core/lib/lantern/metrics/__snapshots__/first-contentful-paint-test.js.snap

@@ -0,0 +1,11 @@
+// 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

@@ -0,0 +1,17 @@
+// 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * @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/{simulator/connection-pool.d.ts → simulation/ConnectionPool.d.ts}

@@ -4,7 +4,7 @@ export class ConnectionPool {
      * @param {Required<Lantern.Simulation.Options>} options
      */
     constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>);
-    _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[]>;
@@ -20,7 +20,7 @@ export class ConnectionPool {
     /**
      * @param {Array<TcpConnection>} connections
      */
-    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>): TcpConnection | null;
+    _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
@@ -43,6 +43,6 @@ export class ConnectionPool {
      */
     release(request: Lantern.NetworkRequest): void;
 }
-import * as Lantern from '../types/lantern.js';
-import { TcpConnection } from './tcp-connection.js';
-//# sourceMappingURL=connection-pool.d.ts.map
+import * as Lantern from '../lantern.js';
+import { TcpConnection } from './TcpConnection.js';
+//# sourceMappingURL=ConnectionPool.d.ts.map

package/core/lib/lantern/{simulator/connection-pool.js → simulation/ConnectionPool.js}

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {NetworkAnalyzer} from './network-analyzer.js';
-import {TcpConnection} from './tcp-connection.js';
+import * as Lantern from '../lantern.js';
+import {NetworkAnalyzer} from './NetworkAnalyzer.js';
+import {TcpConnection} from './TcpConnection.js';
 
 const DEFAULT_SERVER_RESPONSE_TIME = 30;
 const TLS_SCHEMES = ['https', 'wss'];