lighthouse 11.6.0-dev.20240303 → 11.6.0-dev.20240305

package/core/lib/{dependency-graph → 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 {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+     * @param {NetworkRequest[]} records
+     * @return {Map<string, NetworkRequest[]>}
      */
-    static groupByOrigin(records: LH.Artifacts.NetworkRequest[]): Map<string, LH.Artifacts.NetworkRequest[]>;
+    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: LH.Artifacts.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /** @typedef {{record: NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
      * @return {Map<string, number[]>}
      */
-    static _estimateValueByOrigin(records: LH.Artifacts.NetworkRequest[], iteratee: (e: {
-        record: LH.Artifacts.NetworkRequest;
+    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: LH.Artifacts.NetworkRequest;
+        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: LH.Artifacts.NetworkRequest;
+        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: LH.Artifacts.NetworkRequest;
+        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: LH.Artifacts.NetworkRequest;
+        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 {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @param {Map<string, number>} rttByOrigin
      * @return {Map<string, number[]>}
      */
-    static _estimateResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static _estimateResponseTimeByOrigin(records: NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @return {boolean}
      */
-    static canTrustConnectionInformation(records: LH.Artifacts.NetworkRequest[]): 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 {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @param {{forceCoarseEstimates: boolean}} [options]
      * @return {Map<string, boolean>}
      */
-    static estimateIfConnectionWasReused(records: LH.Artifacts.NetworkRequest[], 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 {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @param {RTTEstimateOptions} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateRTTByOrigin(records: LH.Artifacts.NetworkRequest[], 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 {LH.Artifacts.NetworkRequest[]} records
+     * @param {NetworkRequest[]} records
      * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateServerResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], options?: (RTTEstimateOptions & {
+    static estimateServerResponseTimeByOrigin(records: NetworkRequest[], options?: (RTTEstimateOptions & {
         rttByOrigin?: Map<string, number> | undefined;
     }) | undefined): Map<string, Summary>;
     /**
@@ -164,29 +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<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {Array<NetworkRequest>} networkRecords
      * @return {number}
      */
-    static estimateThroughput(networkRecords: Array<LH.Artifacts.NetworkRequest>): number;
+    static estimateThroughput(networkRecords: Array<NetworkRequest>): number;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findResourceForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    static findResourceForUrl<T extends import("../../../../types/internal/lantern.js").Lantern.NetworkRequest<any>>(records: T[], resourceUrl: string): T | undefined;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findLastDocumentForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | 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.
      *
-     * @param {LH.Artifacts.NetworkRequest} request
-     * @return {LH.Artifacts.NetworkRequest}
+     * @template {NetworkRequest} T
+     * @param {T} request
+     * @return {T}
      */
-    static resolveRedirects(request: LH.Artifacts.NetworkRequest): LH.Artifacts.NetworkRequest;
+    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/{dependency-graph → lantern}/simulator/network-analyzer.js

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/** @typedef {import('../../../../types/internal/lantern.js').Lantern.NetworkRequest} NetworkRequest */
+
 import UrlUtils from '../../url-utils.js';
 
 const INITIAL_CWD = 14 * 1024;
@@ -31,8 +33,8 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+   * @param {NetworkRequest[]} records
+   * @return {Map<string, NetworkRequest[]>}
    */
   static groupByOrigin(records) {
     const grouped = new Map();
@@ -87,10 +89,10 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{record: LH.Artifacts.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{record: NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
    * @return {Map<string, number[]>}
    */
@@ -249,7 +251,7 @@ class NetworkAnalyzer {
   /**
    * Given the RTT to each origin, estimates the observed server response times.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {Map<string, number>} rttByOrigin
    * @return {Map<string, number[]>}
    */
@@ -270,7 +272,7 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @return {boolean}
    */
   static canTrustConnectionInformation(records) {
@@ -290,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 {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {{forceCoarseEstimates: boolean}} [options]
    * @return {Map<string, boolean>}
    */
@@ -334,7 +336,7 @@ class NetworkAnalyzer {
    * Attempts to use the most accurate information first and falls back to coarser estimates when it
    * is unavailable.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {RTTEstimateOptions} [options]
    * @return {Map<string, Summary>}
    */
@@ -415,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 {LH.Artifacts.NetworkRequest[]} records
+   * @param {NetworkRequest[]} records
    * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
    * @return {Map<string, Summary>}
    */
@@ -441,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<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {Array<NetworkRequest>} networkRecords
    * @return {number}
    */
   static estimateThroughput(networkRecords) {
@@ -494,9 +496,10 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @template {NetworkRequest} T
+   * @param {Array<T>} records
    * @param {string} resourceUrl
-   * @return {LH.Artifacts.NetworkRequest|undefined}
+   * @return {T|undefined}
    */
   static findResourceForUrl(records, resourceUrl) {
     // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
@@ -507,9 +510,10 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @template {NetworkRequest} T
+   * @param {Array<T>} records
    * @param {string} resourceUrl
-   * @return {LH.Artifacts.NetworkRequest|undefined}
+   * @return {T|undefined}
    */
   static findLastDocumentForUrl(records, resourceUrl) {
     // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
@@ -526,11 +530,12 @@ class NetworkAnalyzer {
    * Resolves redirect chain given a main document.
    * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
    *
-   * @param {LH.Artifacts.NetworkRequest} request
-   * @return {LH.Artifacts.NetworkRequest}
+   * @template {NetworkRequest} T
+   * @param {T} request
+   * @return {T}
    */
   static resolveRedirects(request) {
-    while (request.redirectDestination) request = request.redirectDestination;
+    while (request.redirectDestination) request = /** @type {T} */(request.redirectDestination);
     return request;
   }
 }

package/core/lib/{dependency-graph → lantern}/simulator/simulator.d.ts

@@ -1,11 +1,18 @@
+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<import("../base-node.js").Node, CompleteNodeTiming>>;
+    static get ALL_NODE_TIMINGS(): Map<string, Map<Node, CompleteNodeTiming>>;
     /**
      * We attempt to start nodes by their observed start time using the record priority as a tie breaker.
      * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
@@ -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 {LH.Artifacts.NetworkRequest} record
+     * @param {NetworkRequest} record
      * @return {?TcpConnection}
      */
-    _acquireConnection(record: LH.Artifacts.NetworkRequest): 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/{dependency-graph → lantern}/simulator/simulator.js

@@ -4,7 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-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';
@@ -46,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,
@@ -101,11 +110,11 @@ class Simulator {
    * @param {Node} graph
    */
   _initializeConnectionPool(graph) {
-    /** @type {LH.Artifacts.NetworkRequest[]} */
+    /** @type {NetworkRequest[]} */
     const records = [];
     graph.getRootNode().traverse(node => {
       if (node.type === BaseNode.TYPES.NETWORK) {
-        records.push(node.record);
+        records.push(node.request);
       }
     });
 
@@ -190,7 +199,7 @@ class Simulator {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest} record
+   * @param {NetworkRequest} record
    * @return {?TcpConnection}
    */
   _acquireConnection(record) {
@@ -228,7 +237,7 @@ class Simulator {
       // Start a network request if we're not at max requests and a connection is available
       const numberOfActiveRequests = this._numberInProgress(node.type);
       if (numberOfActiveRequests >= this._maximumConcurrentRequests) return;
-      const connection = this._acquireConnection(node.record);
+      const connection = this._acquireConnection(node.request);
       if (!connection) return;
     }
 
@@ -286,7 +295,7 @@ class Simulator {
    * @return {number}
    */
   _estimateNetworkTimeRemaining(networkNode) {
-    const record = networkNode.record;
+    const record = networkNode.request;
     const timingData = this._nodeTimings.getNetworkStarted(networkNode);
 
     let timeElapsed = 0;
@@ -354,7 +363,7 @@ class Simulator {
     if (node.type !== BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
     if (!('bytesDownloaded' in timingData)) throw new Error('Invalid timing data');
 
-    const record = node.record;
+    const record = node.request;
     const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
     const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
       requestedAt: timingData.startTime,
@@ -384,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]>} */
@@ -395,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,
@@ -412,7 +421,7 @@ class Simulator {
   }
 
   /**
-   * @return {Required<LH.Gatherer.Simulation.Options>}
+   * @return {Required<SimulationOptions>}
    */
   getOptions() {
     return this._options;
@@ -429,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)) {
@@ -535,7 +544,7 @@ class Simulator {
    */
   static _computeNodeStartPosition(node) {
     if (node.type === 'cpu') return node.startTime;
-    return node.startTime + (PriorityStartTimePenalty[node.record.priority] * 1000 * 1000 || 0);
+    return node.startTime + (PriorityStartTimePenalty[node.request.priority] * 1000 * 1000 || 0);
   }
 }
 

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

@@ -3,15 +3,15 @@ declare namespace _default {
     export { convertNodeTimingsToTrace };
 }
 export default _default;
-export type Node = import('./dependency-graph/base-node.js').Node;
-export type CompleteNodeTiming = import('./dependency-graph/simulator/simulator.js').CompleteNodeTiming;
+export type Node = import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type CompleteNodeTiming = import('./lantern/simulator/simulator.js').CompleteNodeTiming;
 /**
  * @license
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/** @typedef {import('./dependency-graph/base-node.js').Node} Node */
-/** @typedef {import('./dependency-graph/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
+/** @typedef {import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('./lantern/simulator/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('./dependency-graph/base-node.js').Node} Node */
-/** @typedef {import('./dependency-graph/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
+/** @typedef {import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('./lantern/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
 
 /**
  * @param {Map<Node, CompleteNodeTiming>} nodeTimings
@@ -32,9 +32,11 @@ function convertNodeTimingsToTrace(nodeTimings) {
       // Represent all CPU work that was bundled in a task as an EvaluateScript event
       traceEvents.push(...createFakeTaskEvents(node, timing));
     } else {
+      /** @type {LH.Artifacts.NetworkRequest} */
+      const record = node.record;
       // Ignore data URIs as they don't really add much value
-      if (/^data/.test(node.record.url)) continue;
-      traceEvents.push(...createFakeNetworkEvents(requestId, node.record, timing));
+      if (/^data/.test(record.url)) continue;
+      traceEvents.push(...createFakeNetworkEvents(requestId, record, timing));
       requestId++;
     }
   }

package/core/lib/navigation-error.js

@@ -5,7 +5,7 @@
  */
 
 import {LighthouseError} from './lh-error.js';
-import {NetworkAnalyzer} from './dependency-graph/simulator/network-analyzer.js';
+import {NetworkAnalyzer} from './lantern/simulator/network-analyzer.js';
 import {NetworkRequest} from './network-request.js';
 import * as i18n from '../lib/i18n/i18n.js';
 

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;
@@ -47,6 +48,11 @@ export class NetworkRequest {
      */
     static _headersDictToHeadersArray(headersDict: LH.Crdp.Network.Headers): Array<HeaderEntry>;
     static get TYPES(): LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
+    /**
+     * @param {NetworkRequest} record
+     * @return {LanternNetworkRequest<NetworkRequest>}
+     */
+    static asLanternNetworkRequest(record: NetworkRequest): LanternNetworkRequest<NetworkRequest>;
     /**
      * @param {NetworkRequest} record
      * @return {boolean}
@@ -253,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

@@ -55,6 +55,8 @@
 import * as LH from '../../types/lh.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.
@@ -568,6 +570,17 @@ class NetworkRequest {
     return RESOURCE_TYPES;
   }
 
+  /**
+   * @param {NetworkRequest} record
+   * @return {LanternNetworkRequest<NetworkRequest>}
+   */
+  static asLanternNetworkRequest(record) {
+    return {
+      ...record,
+      record,
+    };
+  }
+
   /**
    * @param {NetworkRequest} record
    * @return {boolean}

package/package.json

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

package/shared/localization/locales/en-US.json

@@ -1046,6 +1046,9 @@
   "core/audits/installable-manifest.js | manifest-missing-suitable-icon": {
     "message": "Manifest does not contain a suitable icon - PNG, SVG or WebP format of at least {value0} px is required, the sizes attribute must be set, and the purpose attribute, if set, must include \"any\"."
   },
+  "core/audits/installable-manifest.js | manifest-parsing-or-network-error": {
+    "message": "Manifest could not be fetched, is empty, or could not be parsed"
+  },
   "core/audits/installable-manifest.js | no-acceptable-icon": {
     "message": "No supplied icon is at least {value0} px square in PNG, SVG or WebP format, with the purpose attribute unset or set to \"any\""
   },