lighthouse 12.0.0-dev.20240610 → 12.0.0-dev.20240612

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

@@ -4,7 +4,58 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as LH from '../../../../types/lh.js';
+import * as Protocol from '@paulirish/trace_engine/generated/protocol.js';
+
+declare module Util {
+    /** An object with the keys in the union K mapped to themselves as values. */
+    type SelfMap<K extends string> = {
+        [P in K]: P;
+    };
+}
+
+type TraceEvent = {
+    name: string;
+    cat: string;
+    args: {
+        name?: string;
+        fileName?: string;
+        snapshot?: string;
+        sync_id?: string;
+        beginData?: {
+            frame?: string;
+            startLine?: number;
+            url?: string;
+        };
+        data?: {
+            frame?: string;
+            readyState?: number;
+            stackTrace?: {
+                url: string
+            }[];
+            url?: string;
+        };
+    };
+    pid: number;
+    tid: number;
+    /** Timestamp of the event in microseconds. */
+    ts: number;
+    dur: number;
+}
+type Trace = {traceEvents: TraceEvent[]};
+type ResourcePriority = ('VeryLow' | 'Low' | 'Medium' | 'High' | 'VeryHigh');
+type ResourceType = ('Document' | 'Stylesheet' | 'Image' | 'Media' | 'Font' | 'Script' | 'TextTrack' | 'XHR' | 'Fetch' | 'Prefetch' | 'EventSource' | 'WebSocket' | 'Manifest' | 'SignedExchange' | 'Ping' | 'CSPViolationReport' | 'Preflight' | 'Other');
+type InitiatorType = ('parser' | 'script' | 'preload' | 'SignedExchange' | 'preflight' | 'other');
+type ResourceTiming = Protocol.Network.ResourceTiming;
+type CallStack = {
+    callFrames: Array<{
+        scriptId: string;
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+        functionName: string;
+    }>;
+    parent?: CallStack;
+}
 
 type ParsedURL = {
     /**
@@ -80,28 +131,49 @@ export class NetworkRequest<T = any> {
     redirectSource: NetworkRequest<T> | undefined;
     /** The network request that this one redirected to */
     redirectDestination: NetworkRequest<T> | undefined;
-    initiator: LH.Crdp.Network.Initiator;
+    // TODO: can't use Protocol.Network.Initiator because of type mismatch in Lighthouse initiator.
+    initiator: {
+        type: InitiatorType;
+        url?: string;
+        stack?: CallStack;
+    };
     initiatorRequest: NetworkRequest<T> | undefined;
     /** The chain of network requests that redirected to this one */
     redirects: NetworkRequest[] | undefined;
-    timing: LH.Crdp.Network.ResourceTiming | undefined;
+    timing: Protocol.Network.ResourceTiming | undefined;
     /**
      * Optional value for how long the server took to respond to this request.
      * When not provided, the server response time is derived from the timing object.
      */
     serverResponseTime?: number;
-    resourceType: LH.Crdp.Network.ResourceType | undefined;
+    resourceType: ResourceType | undefined;
     mimeType: string;
-    priority: LH.Crdp.Network.ResourcePriority;
+    priority: ResourcePriority;
     frameId: string | undefined;
     fromWorker: boolean;
 }
 
+interface MetricResult<T = any> {
+    timing: number;
+    timestamp?: never;
+    optimisticEstimate: Simulation.Result<T>;
+    pessimisticEstimate: Simulation.Result<T>;
+    optimisticGraph: Simulation.GraphNode<T>;
+    pessimisticGraph: Simulation.GraphNode<T>;
+}
+
 export namespace Simulation {
-    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 URL = {
+        /** URL of the initially requested URL */
+        requestedUrl?: string;
+        /** URL of the last document request */
+        mainDocumentUrl?: string;
+    };
+
+    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
@@ -116,7 +116,7 @@ function convertNodeTimingsToTrace(nodeTimings) {
       const ts = eventTs + (event.ts - nestedBaseTs) * multiplier;
       const newEvent = {...event, ...{pid: baseEvent.pid, tid: baseEvent.tid}, ts};
       if (event.dur) newEvent.dur = event.dur * multiplier;
-      events.push(newEvent);
+      events.push(/** @type {LH.TraceEvent} */(newEvent));
     }
 
     return events;

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.