lighthouse 11.6.0-dev.20240304 → 11.6.0-dev.20240305

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

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

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

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

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

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

package/core/lib/lantern/simulator/network-analyzer.js

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../lantern.js';
+/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
+
 import UrlUtils from '../../url-utils.js';
 
 const INITIAL_CWD = 14 * 1024;
@@ -32,8 +33,8 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
-   * @return {Map<string, Lantern.NetworkRequest[]>}
+   * @param {NetworkRequest[]} records
+   * @return {Map<string, NetworkRequest[]>}
    */
   static groupByOrigin(records) {
     const grouped = new Map();
@@ -88,10 +89,10 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{record: NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
    * @return {Map<string, number[]>}
    */
@@ -250,7 +251,7 @@ class NetworkAnalyzer {
   /**
    * Given the RTT to each origin, estimates the observed server response times.
    *
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {Map<string, number>} rttByOrigin
    * @return {Map<string, number[]>}
    */
@@ -271,7 +272,7 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @return {boolean}
    */
   static canTrustConnectionInformation(records) {
@@ -291,7 +292,7 @@ class NetworkAnalyzer {
    * Returns a map of requestId -> connectionReused, estimating the information if the information
    * available in the records themselves appears untrustworthy.
    *
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {{forceCoarseEstimates: boolean}} [options]
    * @return {Map<string, boolean>}
    */
@@ -335,7 +336,7 @@ class NetworkAnalyzer {
    * Attempts to use the most accurate information first and falls back to coarser estimates when it
    * is unavailable.
    *
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {RTTEstimateOptions} [options]
    * @return {Map<string, Summary>}
    */
@@ -416,7 +417,7 @@ class NetworkAnalyzer {
    * Estimates the server response time of each origin. RTT times can be passed in or will be
    * estimated automatically if not provided.
    *
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
    * @return {Map<string, Summary>}
    */
@@ -442,7 +443,7 @@ class NetworkAnalyzer {
    * Excludes data URI, failed or otherwise incomplete, and cached requests.
    * Returns Infinity if there were no analyzable network records.
    *
-   * @param {Array<Lantern.NetworkRequest>} networkRecords
+   * @param {Array<NetworkRequest>} networkRecords
    * @return {number}
    */
   static estimateThroughput(networkRecords) {
@@ -495,7 +496,7 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @template {Lantern.NetworkRequest} T
+   * @template {NetworkRequest} T
    * @param {Array<T>} records
    * @param {string} resourceUrl
    * @return {T|undefined}
@@ -509,7 +510,7 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @template {Lantern.NetworkRequest} T
+   * @template {NetworkRequest} T
    * @param {Array<T>} records
    * @param {string} resourceUrl
    * @return {T|undefined}
@@ -529,7 +530,7 @@ class NetworkAnalyzer {
    * Resolves redirect chain given a main document.
    * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
    *
-   * @template {Lantern.NetworkRequest} T
+   * @template {NetworkRequest} T
    * @param {T} request
    * @return {T}
    */

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

@@ -1,9 +1,16 @@
+export type NetworkRequest = import('../../../../types/internal/lantern.js').Lantern.NetworkRequest;
+export type SimulationOptions = import('../../../../types/internal/lantern.js').Lantern.Simulation.Options;
+export type SimulationNodeTiming = import('../../../../types/internal/lantern.js').Lantern.Simulation.NodeTiming;
+export type SimulationResult<T> = import('../../../../types/internal/lantern.js').Lantern.Simulation.Result<T>;
 export type Node = import('../base-node.js').Node;
 export type NetworkNode = import('../network-node.js').NetworkNode;
 export type CpuNode = import('../cpu-node.js').CPUNode;
 export type CompleteNodeTiming = import('./simulator-timing-map.js').CpuNodeTimingComplete | import('./simulator-timing-map.js').NetworkNodeTimingComplete;
 export type ConnectionTiming = import('./simulator-timing-map.js').ConnectionTiming;
-export class Simulator {
+/**
+ * @template [T=any]
+ */
+export class Simulator<T = any> {
     /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */
     static get ALL_NODE_TIMINGS(): Map<string, Map<Node, CompleteNodeTiming>>;
     /**
@@ -14,11 +21,11 @@ export class Simulator {
      */
     static _computeNodeStartPosition(node: Node): number;
     /**
-     * @param {LH.Gatherer.Simulation.Options} [options]
+     * @param {SimulationOptions} [options]
      */
-    constructor(options?: LH.Gatherer.Simulation.Options | undefined);
-    /** @type {Required<LH.Gatherer.Simulation.Options>} */
-    _options: Required<LH.Gatherer.Simulation.Options>;
+    constructor(options?: import("../../../../types/internal/lantern.js").Lantern.Simulation.Options | undefined);
+    /** @type {Required<SimulationOptions>} */
+    _options: Required<SimulationOptions>;
     _rtt: number;
     _throughput: number;
     _maximumConcurrentRequests: number;
@@ -67,10 +74,10 @@ export class Simulator {
      */
     _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./simulator-timing-map.js").ConnectionTiming | undefined): void;
     /**
-     * @param {Lantern.NetworkRequest} record
+     * @param {NetworkRequest} record
      * @return {?TcpConnection}
      */
-    _acquireConnection(record: import("../../../../types/internal/lantern.js").NetworkRequest<any>): TcpConnection | null;
+    _acquireConnection(record: NetworkRequest): TcpConnection | null;
     /**
      * @return {Node[]}
      */
@@ -114,16 +121,16 @@ export class Simulator {
      */
     _updateProgressMadeInTimePeriod(node: Node, timePeriodLength: number, totalElapsedTime: number): number | void;
     /**
-     * @return {{nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
+     * @return {{nodeTimings: Map<Node, SimulationNodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
      */
     _computeFinalNodeTimings(): {
-        nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>;
+        nodeTimings: Map<Node, SimulationNodeTiming>;
         completeNodeTimings: Map<Node, CompleteNodeTiming>;
     };
     /**
-     * @return {Required<LH.Gatherer.Simulation.Options>}
+     * @return {Required<SimulationOptions>}
      */
-    getOptions(): Required<LH.Gatherer.Simulation.Options>;
+    getOptions(): Required<SimulationOptions>;
     /**
      * Estimates the time taken to process all of the graph's nodes, returns the overall time along with
      * each node annotated by start/end times.
@@ -135,18 +142,17 @@ export class Simulator {
      *
      * @param {Node} graph
      * @param {{flexibleOrdering?: boolean, label?: string}=} options
-     * @return {LH.Gatherer.Simulation.Result}
+     * @return {SimulationResult<T>}
      */
     simulate(graph: Node, options?: {
         flexibleOrdering?: boolean;
         label?: string;
-    } | undefined): LH.Gatherer.Simulation.Result;
+    } | undefined): SimulationResult<T>;
     /**
      * @param {number} wastedBytes
      */
     computeWastedMsFromWastedBytes(wastedBytes: number): number;
 }
-import * as LH from '../../../../types/lh.js';
 import { SimulatorTimingMap } from './simulator-timing-map.js';
 import { DNSCache } from './dns-cache.js';
 import { ConnectionPool } from './connection-pool.js';

package/core/lib/lantern/simulator/simulator.js

@@ -4,8 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../lantern.js';
-import * as LH from '../../../../types/lh.js';
+// This could be replaced by jsdoc namespace import, when ready.
+// https://github.com/microsoft/TypeScript/issues/41825
+/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
+/** @typedef {import('../../../../types/internal/lantern.js').Lantern.Simulation.Options} SimulationOptions */
+/** @typedef {import('../../../../types/internal/lantern.js').Lantern.Simulation.NodeTiming} SimulationNodeTiming */
+/** @template T @typedef {import('../../../../types/internal/lantern.js').Lantern.Simulation.Result<T>} SimulationResult */
+
 import {BaseNode} from '../base-node.js';
 import {TcpConnection} from './tcp-connection.js';
 import {ConnectionPool} from './connection-pool.js';
@@ -47,12 +52,15 @@ const PriorityStartTimePenalty = {
 /** @type {Map<string, Map<Node, CompleteNodeTiming>>} */
 const ALL_SIMULATION_NODE_TIMINGS = new Map();
 
+/**
+ * @template [T=any]
+ */
 class Simulator {
   /**
-   * @param {LH.Gatherer.Simulation.Options} [options]
+   * @param {SimulationOptions} [options]
    */
   constructor(options) {
-    /** @type {Required<LH.Gatherer.Simulation.Options>} */
+    /** @type {Required<SimulationOptions>} */
     this._options = Object.assign(
       {
         rtt: mobileSlow4G.rttMs,
@@ -102,7 +110,7 @@ class Simulator {
    * @param {Node} graph
    */
   _initializeConnectionPool(graph) {
-    /** @type {Lantern.NetworkRequest[]} */
+    /** @type {NetworkRequest[]} */
     const records = [];
     graph.getRootNode().traverse(node => {
       if (node.type === BaseNode.TYPES.NETWORK) {
@@ -191,7 +199,7 @@ class Simulator {
   }
 
   /**
-   * @param {Lantern.NetworkRequest} record
+   * @param {NetworkRequest} record
    * @return {?TcpConnection}
    */
   _acquireConnection(record) {
@@ -385,7 +393,7 @@ class Simulator {
   }
 
   /**
-   * @return {{nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
+   * @return {{nodeTimings: Map<Node, SimulationNodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
    */
   _computeFinalNodeTimings() {
     /** @type {Array<[Node, CompleteNodeTiming]>} */
@@ -396,8 +404,8 @@ class Simulator {
     // Most consumers will want the entries sorted by startTime, so insert them in that order
     completeNodeTimingEntries.sort((a, b) => a[1].startTime - b[1].startTime);
 
-    // Trimmed version of type `LH.Gatherer.Simulation.NodeTiming`.
-    /** @type {Array<[Node, LH.Gatherer.Simulation.NodeTiming]>} */
+    // Trimmed version of type `SimulationNodeTiming`.
+    /** @type {Array<[Node, SimulationNodeTiming]>} */
     const nodeTimingEntries = completeNodeTimingEntries.map(([node, timing]) => {
       return [node, {
         startTime: timing.startTime,
@@ -413,7 +421,7 @@ class Simulator {
   }
 
   /**
-   * @return {Required<LH.Gatherer.Simulation.Options>}
+   * @return {Required<SimulationOptions>}
    */
   getOptions() {
     return this._options;
@@ -430,7 +438,7 @@ class Simulator {
    *
    * @param {Node} graph
    * @param {{flexibleOrdering?: boolean, label?: string}=} options
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {SimulationResult<T>}
    */
   simulate(graph, options) {
     if (BaseNode.hasCycle(graph)) {

package/core/lib/network-recorder.js

@@ -10,7 +10,7 @@ import log from 'lighthouse-logger';
 
 import * as LH from '../../types/lh.js';
 import {NetworkRequest} from './network-request.js';
-import {PageDependencyGraph} from '../computed/page-dependency-graph.js';
+import {PageDependencyGraph} from '../lib/lantern/page-dependency-graph.js';
 
 /**
  * @typedef {{

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

@@ -1,3 +1,4 @@
+export type LanternNetworkRequest<T> = import('../../types/internal/lantern.js').Lantern.NetworkRequest<T>;
 export type HeaderEntry = {
     name: string;
     value: string;
@@ -49,9 +50,9 @@ export class NetworkRequest {
     static get TYPES(): LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
     /**
      * @param {NetworkRequest} record
-     * @return {Lantern.NetworkRequest<NetworkRequest>}
+     * @return {LanternNetworkRequest<NetworkRequest>}
      */
-    static asLanternNetworkRequest(record: NetworkRequest): import("../../types/internal/lantern.js").NetworkRequest<any>;
+    static asLanternNetworkRequest(record: NetworkRequest): LanternNetworkRequest<NetworkRequest>;
     /**
      * @param {NetworkRequest} record
      * @return {boolean}
@@ -258,6 +259,7 @@ export namespace NetworkRequest {
     export { HEADER_PROTOCOL_IS_H2 };
 }
 import * as LH from '../../types/lh.js';
+/** @template T @typedef {import('../../types/internal/lantern.js').Lantern.NetworkRequest<T>} LanternNetworkRequest */
 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,9 +53,10 @@
  */
 
 import * as LH from '../../types/lh.js';
-import * as Lantern from './lantern/lantern.js';
 import UrlUtils from './url-utils.js';
 
+/** @template T @typedef {import('../../types/internal/lantern.js').Lantern.NetworkRequest<T>} LanternNetworkRequest */
+
 // Lightrider X-Header names for timing information.
 // See: _updateTransferSizeForLightrider and _updateTimingsForLightrider.
 const HEADER_TCP = 'X-TCPMs'; // Note: this should have been called something like ConnectMs, as it includes SSL.
@@ -571,7 +572,7 @@ class NetworkRequest {
 
   /**
    * @param {NetworkRequest} record
-   * @return {Lantern.NetworkRequest<NetworkRequest>}
+   * @return {LanternNetworkRequest<NetworkRequest>}
    */
   static asLanternNetworkRequest(record) {
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "11.6.0-dev.20240304",
+  "version": "11.6.0-dev.20240305",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/tsconfig.json

@@ -69,6 +69,7 @@
     "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/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",