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

package/core/lib/lantern/simulation/TCPConnection.test.js

@@ -0,0 +1,374 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from '../lantern.js';
+
+const {TcpConnection} = Lantern.Simulation;
+
+describe('DependencyGraph/Simulator/TcpConnection', () => {
+  describe('#constructor', () => {
+    it('should create the connection', () => {
+      const rtt = 150;
+      const throughput = 1600 * 1024;
+      const connection = new TcpConnection(rtt, throughput);
+      assert.ok(connection);
+      assert.equal(connection._rtt, rtt);
+    });
+  });
+
+  describe('#maximumSaturatedConnections', () => {
+    it('should compute number of supported simulated requests', () => {
+      const availableThroughput = 1460 * 8 * 10; // 10 TCP segments/second
+      assert.equal(TcpConnection.maximumSaturatedConnections(100, availableThroughput), 1);
+      assert.equal(TcpConnection.maximumSaturatedConnections(300, availableThroughput), 3);
+      assert.equal(TcpConnection.maximumSaturatedConnections(1000, availableThroughput), 10);
+    });
+  });
+
+  describe('.setWarmed', () => {
+    it('adjusts the time to download appropriately', () => {
+      const connection = new TcpConnection(100, Infinity);
+      assert.equal(connection.simulateDownloadUntil(0).timeElapsed, 300);
+      connection.setWarmed(true);
+      assert.equal(connection.simulateDownloadUntil(0).timeElapsed, 100);
+    });
+  });
+
+  describe('.setCongestionWindow', () => {
+    it('adjusts the time to download appropriately', () => {
+      const connection = new TcpConnection(100, Infinity);
+      assert.deepEqual(connection.simulateDownloadUntil(50000), {
+        bytesDownloaded: 50000,
+        extraBytesDownloaded: 0,
+        congestionWindow: 40,
+        roundTrips: 5,
+        timeElapsed: 500,
+        connectionTiming: {
+          connectionTime: 250,
+          dnsResolutionTime: 0,
+          sslTime: 100,
+          timeToFirstByte: 300,
+        },
+      });
+      connection.setCongestionWindow(40); // will download all in one round trip
+      assert.deepEqual(connection.simulateDownloadUntil(50000), {
+        bytesDownloaded: 50000,
+        extraBytesDownloaded: 0,
+        congestionWindow: 40,
+        roundTrips: 3,
+        timeElapsed: 300,
+        connectionTiming: {
+          connectionTime: 250,
+          dnsResolutionTime: 0,
+          sslTime: 100,
+          timeToFirstByte: 300,
+        },
+      });
+    });
+  });
+
+  describe('.setH2OverflowBytesDownloaded', () => {
+    it('adjusts the time to download appropriately for H2 connections', () => {
+      const connection = new TcpConnection(100, Infinity, 0, true, true);
+      connection.setWarmed(true);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
+      connection.setH2OverflowBytesDownloaded(20000);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 100);
+      connection.setH2OverflowBytesDownloaded(50000);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 0);
+    });
+
+    it('does not adjust the time to download for non-H2 connections', () => {
+      const connection = new TcpConnection(100, Infinity, 0, true, false);
+      connection.setWarmed(true);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
+      connection.setH2OverflowBytesDownloaded(20000);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
+      connection.setH2OverflowBytesDownloaded(50000);
+      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
+    });
+  });
+
+  describe('.simulateDownloadUntil', () => {
+    describe('when maximumTime is not set', () => {
+      it('should provide the correct values small payload non-SSL', () => {
+        const connection = new TcpConnection(100, Infinity, 0, false);
+        assert.deepEqual(connection.simulateDownloadUntil(7300), {
+          bytesDownloaded: 7300,
+          extraBytesDownloaded: 0,
+          congestionWindow: 10,
+          roundTrips: 2,
+          timeElapsed: 200,
+          connectionTiming: {
+            connectionTime: 150,
+            dnsResolutionTime: 0,
+            sslTime: undefined, // non-SSL
+            timeToFirstByte: 200,
+          },
+        });
+      });
+
+      it('should provide the correct values small payload SSL', () => {
+        const connection = new TcpConnection(100, Infinity, 0, true);
+        assert.deepEqual(connection.simulateDownloadUntil(7300), {
+          bytesDownloaded: 7300,
+          extraBytesDownloaded: 0,
+          congestionWindow: 10,
+          roundTrips: 3,
+          timeElapsed: 300,
+          connectionTiming: {
+            connectionTime: 250,
+            dnsResolutionTime: 0,
+            sslTime: 100,
+            timeToFirstByte: 300,
+          },
+        });
+      });
+
+      it('should provide the correct values small payload H2', () => {
+        const connection = new TcpConnection(100, Infinity, 0, true, true);
+        assert.deepEqual(connection.simulateDownloadUntil(7300), {
+          bytesDownloaded: 7300,
+          extraBytesDownloaded: 7300,
+          congestionWindow: 10,
+          roundTrips: 3,
+          timeElapsed: 300,
+          connectionTiming: {
+            connectionTime: 250,
+            dnsResolutionTime: 0,
+            sslTime: 100,
+            timeToFirstByte: 300,
+          },
+        });
+      });
+
+      it('should provide the correct values response time', () => {
+        const responseTime = 78;
+        const connection = new TcpConnection(100, Infinity, responseTime, true);
+        assert.deepEqual(connection.simulateDownloadUntil(7300), {
+          bytesDownloaded: 7300,
+          extraBytesDownloaded: 0,
+          congestionWindow: 10,
+          roundTrips: 3,
+          timeElapsed: 300 + responseTime,
+          connectionTiming: {
+            connectionTime: 250,
+            dnsResolutionTime: 0,
+            sslTime: 100,
+            timeToFirstByte: 378,
+          },
+        });
+      });
+
+      it('should provide the correct values large payload', () => {
+        const connection = new TcpConnection(100, 8 * 1000 * 1000);
+        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
+        assert.deepEqual(connection.simulateDownloadUntil(bytesToDownload), {
+          bytesDownloaded: bytesToDownload,
+          extraBytesDownloaded: 0,
+          congestionWindow: 68,
+          roundTrips: 105,
+          timeElapsed: 10500,
+          connectionTiming: {
+            connectionTime: 250,
+            dnsResolutionTime: 0,
+            sslTime: 100,
+            timeToFirstByte: 300,
+          },
+        });
+      });
+
+      it('should provide the correct values resumed small payload', () => {
+        const connection = new TcpConnection(100, Infinity, 0, true);
+        assert.deepEqual(connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 250}), {
+          bytesDownloaded: 7300,
+          extraBytesDownloaded: 0,
+          congestionWindow: 10,
+          roundTrips: 3,
+          timeElapsed: 50,
+          connectionTiming: {
+            connectionTime: 250,
+            dnsResolutionTime: 0,
+            sslTime: 100,
+            timeToFirstByte: 300,
+          },
+        });
+      });
+
+      it('should provide the correct values resumed small payload H2', () => {
+        const connection = new TcpConnection(100, Infinity, 0, true, true);
+        connection.setWarmed(true);
+        connection.setH2OverflowBytesDownloaded(10000);
+        assert.deepEqual(connection.simulateDownloadUntil(7300), {
+          bytesDownloaded: 0,
+          extraBytesDownloaded: 2700, // 10000 - 7300
+          congestionWindow: 10,
+          roundTrips: 0,
+          timeElapsed: 0,
+          connectionTiming: {
+            timeToFirstByte: 0,
+          },
+        });
+      });
+
+      it('should provide the correct values resumed large payload', () => {
+        const connection = new TcpConnection(100, 8 * 1000 * 1000);
+        const bytesToDownload = 5 * 1000 * 1000; // 5 mb
+        connection.setCongestionWindow(68);
+        assert.deepEqual(
+          connection.simulateDownloadUntil(bytesToDownload, {timeAlreadyElapsed: 5234}),
+          {
+            bytesDownloaded: bytesToDownload,
+            extraBytesDownloaded: 0,
+            congestionWindow: 68,
+            roundTrips: 51, // 5 mb / (1460 * 68)
+            timeElapsed: 5100,
+            connectionTiming: {
+              connectionTime: 250,
+              dnsResolutionTime: 0,
+              sslTime: 100,
+              timeToFirstByte: 300,
+            },
+          }
+        );
+      });
+    });
+
+    describe('when maximumTime is set', () => {
+      it('should provide the correct values less than TTFB', () => {
+        const connection = new TcpConnection(100, Infinity, 0, false);
+        assert.deepEqual(
+          connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 0, maximumTimeToElapse: 68}),
+          {
+            bytesDownloaded: 7300,
+            extraBytesDownloaded: 0,
+            congestionWindow: 10,
+            roundTrips: 2,
+            timeElapsed: 200,
+            connectionTiming: {
+              connectionTime: 150,
+              dnsResolutionTime: 0,
+              sslTime: undefined, // non-SSL
+              timeToFirstByte: 200,
+            },
+          }
+        );
+      });
+
+      it('should provide the correct values just over TTFB', () => {
+        const connection = new TcpConnection(100, Infinity, 0, false);
+        assert.deepEqual(
+          connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 0, maximumTimeToElapse: 250}),
+          {
+            bytesDownloaded: 7300,
+            extraBytesDownloaded: 0,
+            congestionWindow: 10,
+            roundTrips: 2,
+            timeElapsed: 200,
+            connectionTiming: {
+              connectionTime: 150,
+              dnsResolutionTime: 0,
+              sslTime: undefined, // non-SSL
+              timeToFirstByte: 200,
+            },
+          }
+        );
+      });
+
+      it('should provide the correct values with already elapsed', () => {
+        const connection = new TcpConnection(100, Infinity, 0, false);
+        assert.deepEqual(
+          connection.simulateDownloadUntil(7300, {
+            timeAlreadyElapsed: 75,
+            maximumTimeToElapse: 250,
+          }),
+          {
+            bytesDownloaded: 7300,
+            extraBytesDownloaded: 0,
+            congestionWindow: 10,
+            roundTrips: 2,
+            timeElapsed: 125,
+            connectionTiming: {
+              connectionTime: 150,
+              dnsResolutionTime: 0,
+              sslTime: undefined, // non-SSL
+              timeToFirstByte: 200,
+            },
+          }
+        );
+      });
+
+      it('should provide the correct values large payloads', () => {
+        const connection = new TcpConnection(100, 8 * 1000 * 1000);
+        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
+        assert.deepEqual(
+          connection.simulateDownloadUntil(bytesToDownload, {
+            timeAlreadyElapsed: 500,
+            maximumTimeToElapse: 740,
+          }),
+          {
+            bytesDownloaded: 683280, // should be less than 68 * 1460 * 8
+            extraBytesDownloaded: 0,
+            congestionWindow: 68,
+            roundTrips: 8,
+            timeElapsed: 800, // skips the handshake because time already elapsed
+            connectionTiming: {
+              connectionTime: 250,
+              dnsResolutionTime: 0,
+              sslTime: 100,
+              timeToFirstByte: 300,
+            },
+          }
+        );
+      });
+
+      it('should all add up', () => {
+        const connection = new TcpConnection(100, 8 * 1000 * 1000);
+        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
+        const firstStoppingPoint = 5234;
+        const secondStoppingPoint = 315;
+        const thirdStoppingPoint = 10500 - firstStoppingPoint - secondStoppingPoint;
+
+        const firstSegment = connection.simulateDownloadUntil(bytesToDownload, {
+          timeAlreadyElapsed: 0,
+          maximumTimeToElapse: firstStoppingPoint,
+        });
+        const firstOvershoot = firstSegment.timeElapsed - firstStoppingPoint;
+
+        connection.setCongestionWindow(firstSegment.congestionWindow);
+        const secondSegment = connection.simulateDownloadUntil(
+          bytesToDownload - firstSegment.bytesDownloaded,
+          {
+            timeAlreadyElapsed: firstSegment.timeElapsed,
+            maximumTimeToElapse: secondStoppingPoint - firstOvershoot,
+          }
+        );
+        const secondOvershoot = firstOvershoot + secondSegment.timeElapsed - secondStoppingPoint;
+
+        connection.setCongestionWindow(secondSegment.congestionWindow);
+        const thirdSegment = connection.simulateDownloadUntil(
+          bytesToDownload - firstSegment.bytesDownloaded - secondSegment.bytesDownloaded,
+          {timeAlreadyElapsed: firstSegment.timeElapsed + secondSegment.timeElapsed}
+        );
+        const thirdOvershoot = secondOvershoot + thirdSegment.timeElapsed - thirdStoppingPoint;
+
+        assert.equal(thirdOvershoot, 0);
+        assert.equal(
+          firstSegment.bytesDownloaded +
+            secondSegment.bytesDownloaded +
+            thirdSegment.bytesDownloaded,
+          bytesToDownload
+        );
+        assert.equal(
+          firstSegment.timeElapsed + secondSegment.timeElapsed + thirdSegment.timeElapsed,
+          10500
+        );
+      });
+    });
+  });
+});

package/core/lib/lantern/{simulator/tcp-connection.d.ts → simulation/TcpConnection.d.ts}

@@ -1,4 +1,4 @@
-export type ConnectionTiming = import('./simulator-timing-map.js').ConnectionTiming;
+export type ConnectionTiming = import('./SimulationTimingMap.js').ConnectionTiming;
 export type DownloadOptions = {
     dnsResolutionTime?: number | undefined;
     timeAlreadyElapsed?: number | undefined;
@@ -86,4 +86,4 @@ export class TcpConnection {
      */
     simulateDownloadUntil(bytesToDownload: number, options?: DownloadOptions | undefined): DownloadResults;
 }
-//# sourceMappingURL=tcp-connection.d.ts.map
+//# sourceMappingURL=TcpConnection.d.ts.map

package/core/lib/lantern/{simulator/tcp-connection.js → simulation/TcpConnection.js}

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @typedef {import('./simulator-timing-map.js').ConnectionTiming} ConnectionTiming */
+/** @typedef {import('./SimulationTimingMap.js').ConnectionTiming} ConnectionTiming */
 
 const INITIAL_CONGESTION_WINDOW = 10;
 const TCP_SEGMENT_SIZE = 1460;

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

@@ -0,0 +1,21 @@
+export { ConnectionPool } from "./ConnectionPool.js";
+export { Constants } from "./Constants.js";
+export { DNSCache } from "./DNSCache.js";
+export { NetworkAnalyzer } from "./NetworkAnalyzer.js";
+export { Simulator } from "./Simulator.js";
+export { SimulatorTimingMap } from "./SimulationTimingMap.js";
+export { TcpConnection } from "./TcpConnection.js";
+export type GraphNetworkNode<T = any> = Lantern.Simulation.GraphNetworkNode<T>;
+export type GraphNode<T = any> = Lantern.Simulation.GraphNode<T>;
+export type Result<T = any> = Lantern.Simulation.Result<T>;
+export type GraphCPUNode = Lantern.Simulation.GraphCPUNode;
+export type MetricCoefficients = Lantern.Simulation.MetricCoefficients;
+export type MetricComputationDataInput = Lantern.Simulation.MetricComputationDataInput;
+export type NodeTiming = Lantern.Simulation.NodeTiming;
+export type Options = Lantern.Simulation.Options;
+export type PrecomputedLanternData = Lantern.Simulation.PrecomputedLanternData;
+export type ProcessedNavigation = Lantern.Simulation.ProcessedNavigation;
+export type Settings = Lantern.Simulation.Settings;
+export type URL = Lantern.Simulation.URL;
+import * as Lantern from '../types/lantern.js';
+//# sourceMappingURL=simulation.d.ts.map

package/core/lib/lantern/simulation/simulation.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+
+export {ConnectionPool} from './ConnectionPool.js';
+export {Constants} from './Constants.js';
+export {DNSCache} from './DNSCache.js';
+export {NetworkAnalyzer} from './NetworkAnalyzer.js';
+export {Simulator} from './Simulator.js';
+export {SimulatorTimingMap} from './SimulationTimingMap.js';
+export {TcpConnection} from './TcpConnection.js';
+
+/** @template [T=any] @typedef {Lantern.Simulation.GraphNetworkNode<T>} GraphNetworkNode */
+/** @template [T=any] @typedef {Lantern.Simulation.GraphNode<T>} GraphNode */
+/** @template [T=any] @typedef {Lantern.Simulation.Result<T>} Result */
+/** @typedef {Lantern.Simulation.GraphCPUNode} GraphCPUNode */
+/** @typedef {Lantern.Simulation.MetricCoefficients} MetricCoefficients */
+/** @typedef {Lantern.Simulation.MetricComputationDataInput} MetricComputationDataInput */
+/** @typedef {Lantern.Simulation.NodeTiming} NodeTiming */
+/** @typedef {Lantern.Simulation.Options} Options */
+/** @typedef {Lantern.Simulation.PrecomputedLanternData} PrecomputedLanternData */
+/** @typedef {Lantern.Simulation.ProcessedNavigation} ProcessedNavigation */
+/** @typedef {Lantern.Simulation.Settings} Settings */
+/** @typedef {Lantern.Simulation.URL} URL */

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

@@ -153,7 +153,7 @@ export class NetworkRequest<T = any> {
     fromWorker: boolean;
 }
 
-interface Metric<T = any> {
+interface MetricResult<T = any> {
     timing: number;
     timestamp?: never;
     optimisticEstimate: Simulation.Result<T>;
@@ -170,10 +170,10 @@ export namespace Simulation {
         mainDocumentUrl?: string;
     };
 
-    type GraphNode<T> = import('../base-node.js').Node<T>;
-    type GraphNetworkNode<T> = import('../network-node.js').NetworkNode<T>;
-    type GraphCPUNode = import('../cpu-node.js').CPUNode;
-    type Simulator<T> = import('../simulator/simulator.js').Simulator<T>;
+    type GraphNode<T> = import('../BaseNode.js').Node<T>;
+    type GraphNetworkNode<T> = import('../NetworkNode.js').NetworkNode<T>;
+    type GraphCPUNode = import('../CpuNode.js').CPUNode;
+    type Simulator<T> = import('../simulation/Simulator.js').Simulator<T>;
 
     interface MetricCoefficients {
         intercept: number;

package/core/lib/lantern-trace-saver.d.ts

@@ -3,15 +3,15 @@ declare namespace _default {
     export { convertNodeTimingsToTrace };
 }
 export default _default;
-export type Node = import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
-export type CompleteNodeTiming = import('./lantern/simulator/simulator.js').CompleteNodeTiming;
+export type Node = import('./lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>;
+export type CompleteNodeTiming = import('./lantern/simulation/Simulator.js').CompleteNodeTiming;
 /**
  * @license
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/** @typedef {import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-/** @typedef {import('./lantern/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
+/** @typedef {import('./lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('./lantern/simulation/Simulator.js').CompleteNodeTiming} CompleteNodeTiming */
 /**
  * @param {Map<Node, CompleteNodeTiming>} nodeTimings
  * @return {LH.Trace}

package/core/lib/lantern-trace-saver.js

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @typedef {import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
-/** @typedef {import('./lantern/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
+/** @typedef {import('./lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('./lantern/simulation/Simulator.js').CompleteNodeTiming} CompleteNodeTiming */
 
 /**
  * @param {Map<Node, CompleteNodeTiming>} nodeTimings

package/core/lib/navigation-error.js

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from './lantern/lantern.js';
 import {LighthouseError} from './lh-error.js';
-import {NetworkAnalyzer} from './lantern/simulator/network-analyzer.js';
 import {NetworkRequest} from './network-request.js';
 import * as i18n from '../lib/i18n/i18n.js';
 
@@ -131,7 +131,7 @@ function getNonHtmlError(finalRecord) {
 function getPageLoadError(navigationError, context) {
   const {url, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
-  let mainRecord = NetworkAnalyzer.findResourceForUrl(networkRecords, url);
+  let mainRecord = Lantern.Simulation.NetworkAnalyzer.findResourceForUrl(networkRecords, url);
 
   // If the url doesn't give us a network request, it's possible we landed on a chrome-error:// page
   // In this case, just get the first document request.
@@ -149,7 +149,7 @@ function getPageLoadError(navigationError, context) {
   // MIME Type is only set on the final redirected document request. Use this for the HTML check instead of root.
   let finalRecord;
   if (mainRecord) {
-    finalRecord = NetworkAnalyzer.resolveRedirects(mainRecord);
+    finalRecord = Lantern.Simulation.NetworkAnalyzer.resolveRedirects(mainRecord);
   } else {
     // We have no network requests to process, use the navError
     return navigationError;

package/core/lib/network-recorder.js

@@ -9,8 +9,8 @@ import {EventEmitter} from 'events';
 import log from 'lighthouse-logger';
 
 import * as LH from '../../types/lh.js';
+import * as Lantern from './lantern/lantern.js';
 import {NetworkRequest} from './network-request.js';
-import {PageDependencyGraph} from '../lib/lantern/page-dependency-graph.js';
 
 /**
  * @typedef {{
@@ -253,7 +253,7 @@ class NetworkRecorder extends RequestEventEmitter {
       return record.redirectSource;
     }
 
-    const initiatorURL = PageDependencyGraph.getNetworkInitiators(record)[0];
+    const initiatorURL = Lantern.PageDependencyGraph.getNetworkInitiators(record)[0];
     let candidates = recordsByURL.get(initiatorURL) || [];
     // The (valid) initiator must come before the initiated request.
     candidates = candidates.filter(c => {

package/core/lib/network-request.d.ts

@@ -285,7 +285,7 @@ export namespace NetworkRequest {
 /** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 export const RESOURCE_TYPES: LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
 import * as LH from '../../types/lh.js';
-import * as Lantern from './lantern/types/lantern.js';
+import * as Lantern from './lantern/lantern.js';
 declare const HEADER_TCP: "X-TCPMs";
 declare const HEADER_SSL: "X-SSLMs";
 declare const HEADER_REQ: "X-RequestMs";

package/core/lib/network-request.js

@@ -53,7 +53,7 @@
  */
 
 import * as LH from '../../types/lh.js';
-import * as Lantern from './lantern/types/lantern.js';
+import * as Lantern from './lantern/lantern.js';
 import UrlUtils from './url-utils.js';
 
 // Lightrider X-Header names for timing information.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "12.0.0-dev.20240611",
+  "version": "12.0.0-dev.20240613",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -184,7 +184,7 @@
     "@paulirish/trace_engine": "^0.0.23",
     "@sentry/node": "^6.17.4",
     "axe-core": "^4.9.1",
-    "chrome-launcher": "^1.1.1",
+    "chrome-launcher": "^1.1.2",
     "configstore": "^5.0.1",
     "csp_evaluator": "1.1.1",
     "devtools-protocol": "0.0.1312386",

package/tsconfig.json

@@ -66,13 +66,15 @@
     "core/test/lib/emulation-test.js",
     "core/test/lib/i18n/i18n-test.js",
     "core/test/lib/icons-test.js",
-    "core/test/lib/lantern/base-node-test.js",
-    "core/test/lib/lantern/metrics/*",
-    "core/test/lib/lantern/page-dependency-graph-test.js",
-    "core/test/lib/lantern/simulator/connection-pool-test.js",
-    "core/test/lib/lantern/simulator/dns-cache-test.js",
-    "core/test/lib/lantern/simulator/network-analyzer-test.js",
-    "core/test/lib/lantern/simulator/simulator-test.js",
+    // TODO(15841): remove when importing Lantern from npm
+    "core/lib/lantern/BaseNode.test.js",
+    "core/lib/lantern/metrics/*.test.js",
+    "core/lib/lantern/PageDependencyGraph.test.js",
+    "core/lib/lantern/simulation/ConnectionPool.test.js",
+    "core/lib/lantern/simulation/DNSCache.test.js",
+    "core/lib/lantern/simulation/NetworkAnalyzer.test.js",
+    "core/lib/lantern/simulation/Simulator.test.js",
+    // ------ done TODO
     "core/test/lib/lh-element-test.js",
     "core/test/lib/lighthouse-compatibility-test.js",
     "core/test/lib/manifest-parser-test.js",
@@ -109,6 +111,6 @@
     "core/test/computed/metrics/interactive-test.js",
     "core/test/computed/tbt-impact-tasks-test.js",
     "core/test/fixtures/config-plugins/lighthouse-plugin-simple/plugin-simple.js",
-    "core/test/lib/lantern/metrics/metric-test-utils.js",
+    "core/lib/lantern/metrics/MetricTestUtils.js",
   ],
 }

package/types/artifacts.d.ts

@@ -6,11 +6,10 @@
 
 import {Protocol as Crdp} from 'devtools-protocol/types/protocol.js';
 import * as TraceEngine from '@paulirish/trace_engine';
-import * as Lantern from '../core/lib/lantern/types/lantern.js';
+import * as Lantern from '../core/lib/lantern/lantern.js';
 import {LayoutShiftRootCausesData} from '@paulirish/trace_engine/models/trace/root-causes/LayoutShift.js';
 
 import {parseManifest} from '../core/lib/manifest-parser.js';
-import {Simulator} from '../core/lib/lantern/simulator/simulator.js';
 import {LighthouseError} from '../core/lib/lh-error.js';
 import {NetworkRequest as _NetworkRequest} from '../core/lib/network-request.js';
 import speedline from 'speedline-core';
@@ -566,7 +565,7 @@ declare module Artifacts {
     trace: Trace;
     settings: Audit.Context['settings'];
     gatherContext: Artifacts['GatherContext'];
-    simulator?: InstanceType<typeof Simulator>;
+    simulator?: InstanceType<typeof Lantern.Simulation.Simulator>;
     URL: Artifacts['URL'];
   }
 
@@ -592,7 +591,7 @@ declare module Artifacts {
     throughput: number;
   }
 
-  type LanternMetric = Lantern.Metric<Artifacts.NetworkRequest>;
+  type LanternMetric = Lantern.Metrics.Result<Artifacts.NetworkRequest>;
 
   type Speedline = speedline.Output<'speedIndex'>;
 

package/types/gatherer.d.ts

@@ -17,7 +17,7 @@ import Config from './config.js';
 import Result from './lhr/lhr.js';
 import Protocol from './protocol.js';
 import Puppeteer from './puppeteer.js';
-import * as Lantern from '../core/lib/lantern/types/lantern.js';
+import * as Lantern from '../core/lib/lantern/lantern.js';
 
 type CrdpEvents = CrdpMappings.Events;
 type CrdpCommands = CrdpMappings.Commands;