lighthouse 12.0.0 → 12.1.0-dev.20240619

package/core/computed/metrics/timing-summary.js

@@ -9,7 +9,6 @@ import {ProcessedNavigation} from '../processed-navigation.js';
 import {Speedline} from '../speedline.js';
 import {FirstContentfulPaint} from './first-contentful-paint.js';
 import {FirstContentfulPaintAllFrames} from './first-contentful-paint-all-frames.js';
-import {FirstMeaningfulPaint} from './first-meaningful-paint.js';
 import {LargestContentfulPaint} from './largest-contentful-paint.js';
 import {LargestContentfulPaintAllFrames} from './largest-contentful-paint-all-frames.js';
 import {Interactive} from './interactive.js';
@@ -51,7 +50,6 @@ class TimingSummary {
     const speedline = await Speedline.request(trace, context);
     const firstContentfulPaint = await requestOrUndefined(FirstContentfulPaint, metricComputationData);
     const firstContentfulPaintAllFrames = await requestOrUndefined(FirstContentfulPaintAllFrames, metricComputationData);
-    const firstMeaningfulPaint = await requestOrUndefined(FirstMeaningfulPaint, metricComputationData);
     const largestContentfulPaint = await requestOrUndefined(LargestContentfulPaint, metricComputationData);
     const largestContentfulPaintAllFrames = await requestOrUndefined(LargestContentfulPaintAllFrames, metricComputationData);
     const interactive = await requestOrUndefined(Interactive, metricComputationData);
@@ -74,8 +72,6 @@ class TimingSummary {
       firstContentfulPaintTs: firstContentfulPaint?.timestamp,
       firstContentfulPaintAllFrames: firstContentfulPaintAllFrames?.timing,
       firstContentfulPaintAllFramesTs: firstContentfulPaintAllFrames?.timestamp,
-      firstMeaningfulPaint: firstMeaningfulPaint?.timing,
-      firstMeaningfulPaintTs: firstMeaningfulPaint?.timestamp,
       largestContentfulPaint: largestContentfulPaint?.timing,
       largestContentfulPaintTs: largestContentfulPaint?.timestamp,
       largestContentfulPaintAllFrames: largestContentfulPaintAllFrames?.timing,
@@ -107,8 +103,6 @@ class TimingSummary {
       observedFirstContentfulPaintTs: processedNavigation?.timestamps.firstContentfulPaint,
       observedFirstContentfulPaintAllFrames: processedNavigation?.timings.firstContentfulPaintAllFrames,
       observedFirstContentfulPaintAllFramesTs: processedNavigation?.timestamps.firstContentfulPaintAllFrames,
-      observedFirstMeaningfulPaint: processedNavigation?.timings.firstMeaningfulPaint,
-      observedFirstMeaningfulPaintTs: processedNavigation?.timestamps.firstMeaningfulPaint,
       observedLargestContentfulPaint: processedNavigation?.timings.largestContentfulPaint,
       observedLargestContentfulPaintTs: processedNavigation?.timestamps.largestContentfulPaint,
       observedLargestContentfulPaintAllFrames: processedNavigation?.timings.largestContentfulPaintAllFrames,

package/core/computed/metrics/total-blocking-time.js

@@ -4,12 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../../lib/lantern/lantern.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
 import ComputedMetric from './metric.js';
 import {TraceProcessor} from '../../lib/tracehouse/trace-processor.js';
 import {LanternTotalBlockingTime} from './lantern-total-blocking-time.js';
 import {Interactive} from './interactive.js';
-import {calculateSumOfBlockingTime} from './tbt-utils.js';
+
+const {calculateSumOfBlockingTime} = Lantern.TBTUtils;
 
 /**
  * @fileoverview This audit determines Total Blocking Time.

package/core/computed/navigation-insights.d.ts

@@ -2,16 +2,7 @@ export { NavigationInsightsComputed as NavigationInsights };
 declare const NavigationInsightsComputed: typeof NavigationInsights & {
     request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<{
-        AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
-        Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
-        LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
-        NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
-        Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
-        Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
-        Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
-        PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
-    }>>;
+    }>) => Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<typeof import("@paulirish/trace_engine/models/trace/handlers/ModelHandlers.js")>>;
 };
 /**
  * @fileoverview Gets insights from the shared trace engine for the navigation audited by Lighthouse.
@@ -22,15 +13,6 @@ declare class NavigationInsights {
       * @param {LH.Trace} trace
       * @param {LH.Artifacts.ComputedContext} context
      */
-    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<{
-        AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
-        Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
-        LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
-        NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
-        Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
-        Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
-        Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
-        PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
-    }>>;
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<import("@paulirish/trace_engine/models/trace/insights/types.js").NavigationInsightData<typeof import("@paulirish/trace_engine/models/trace/handlers/ModelHandlers.js")>>;
 }
 //# sourceMappingURL=navigation-insights.d.ts.map

package/core/computed/network-analysis.d.ts

@@ -5,11 +5,6 @@ declare const NetworkAnalysisComputed: typeof NetworkAnalysis & {
     }>) => Promise<import("../index.js").Artifacts.NetworkAnalysis>;
 };
 declare class NetworkAnalysis {
-    /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
-     * @return {LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>}
-     */
-    static computeRTTAndServerResponseTime(records: Array<LH.Artifacts.NetworkRequest>): LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>;
     /**
      * @param {LH.DevtoolsLog} devtoolsLog
      * @param {LH.Artifacts.ComputedContext} context

package/core/computed/network-analysis.js

@@ -4,49 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
-import {NetworkAnalyzer} from '../lib/lantern/simulator/network-analyzer.js';
 import {NetworkRecords} from './network-records.js';
 
 class NetworkAnalysis {
-  /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
-   * @return {LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>}
-   */
-  static computeRTTAndServerResponseTime(records) {
-    // First pass compute the estimated observed RTT to each origin's servers.
-    /** @type {Map<string, number>} */
-    const rttByOrigin = new Map();
-    for (const [origin, summary] of NetworkAnalyzer.estimateRTTByOrigin(records).entries()) {
-      rttByOrigin.set(origin, summary.min);
-    }
-
-    // We'll use the minimum RTT as the assumed connection latency since we care about how much addt'l
-    // latency each origin introduces as Lantern will be simulating with its own connection latency.
-    const minimumRtt = Math.min(...Array.from(rttByOrigin.values()));
-    // We'll use the observed RTT information to help estimate the server response time
-    const responseTimeSummaries = NetworkAnalyzer.estimateServerResponseTimeByOrigin(records, {
-      rttByOrigin,
-    });
-
-    /** @type {Map<string, number>} */
-    const additionalRttByOrigin = new Map();
-    /** @type {Map<string, number>} */
-    const serverResponseTimeByOrigin = new Map();
-    for (const [origin, summary] of responseTimeSummaries.entries()) {
-      // Not all origins have usable timing data, we'll default to using no additional latency.
-      const rttForOrigin = rttByOrigin.get(origin) || minimumRtt;
-      additionalRttByOrigin.set(origin, rttForOrigin - minimumRtt);
-      serverResponseTimeByOrigin.set(origin, summary.median);
-    }
-
-    return {
-      rtt: minimumRtt,
-      additionalRttByOrigin,
-      serverResponseTimeByOrigin,
-    };
-  }
-
   /**
    * @param {LH.DevtoolsLog} devtoolsLog
    * @param {LH.Artifacts.ComputedContext} context
@@ -54,9 +16,7 @@ class NetworkAnalysis {
    */
   static async compute_(devtoolsLog, context) {
     const records = await NetworkRecords.request(devtoolsLog, context);
-    const throughput = NetworkAnalyzer.estimateThroughput(records);
-    const rttAndServerResponseTime = NetworkAnalysis.computeRTTAndServerResponseTime(records);
-    return {throughput, ...rttAndServerResponseTime};
+    return Lantern.Simulation.NetworkAnalyzer.analyze(records);
   }
 }
 

package/core/computed/page-dependency-graph.d.ts

@@ -1,19 +1,20 @@
 export { PageDependencyGraphComputed as PageDependencyGraph };
-export type Node = import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type Node = import('../lib/lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>;
 declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
     request: (dependencies: {
         trace: LH.Trace;
         devtoolsLog: import("../index.js").DevtoolsLog;
         URL: LH.Artifacts['URL'];
+        fromTrace?: boolean | undefined;
     }, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<Node>;
 };
 import { NetworkRequest } from '../lib/network-request.js';
-/** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../lib/lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>} Node */
 declare class PageDependencyGraph {
     /**
-     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<Node>}
      */
@@ -21,6 +22,7 @@ declare class PageDependencyGraph {
         trace: LH.Trace;
         devtoolsLog: import("../index.js").DevtoolsLog;
         URL: LH.Artifacts['URL'];
+        fromTrace?: boolean | undefined;
     }, context: LH.Artifacts.ComputedContext): Promise<Node>;
 }
 //# sourceMappingURL=page-dependency-graph.d.ts.map

package/core/computed/page-dependency-graph.js

@@ -4,33 +4,43 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
-import {PageDependencyGraph as LanternPageDependencyGraph} from '../lib/lantern/page-dependency-graph.js';
 import {NetworkRequest} from '../lib/network-request.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
+import {TraceEngineResult} from './trace-engine-result.js';
 
-/** @typedef {import('../lib/lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('../lib/lantern/BaseNode.js').Node<LH.Artifacts.NetworkRequest>} Node */
 
 class PageDependencyGraph {
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL'], fromTrace?: boolean}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
     const {trace, devtoolsLog, URL} = data;
-    const [processedTrace, networkRecords] = await Promise.all([
+    const [{mainThreadEvents}, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    const mainThreadEvents = processedTrace.mainThreadEvents;
+    if (data.fromTrace) {
+      const traceEngineResult = await TraceEngineResult.request({trace}, context);
+      const traceEngineData = traceEngineResult.data;
+      const requests =
+        Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
+      const graph =
+        Lantern.TraceEngineComputationData.createGraph(requests, trace, traceEngineData, URL);
+      return graph;
+    }
+
     const lanternRequests = networkRecords.map(NetworkRequest.asLanternNetworkRequest);
-    return LanternPageDependencyGraph.createGraph(mainThreadEvents, lanternRequests, URL);
+    return Lantern.PageDependencyGraph.createGraph(mainThreadEvents, lanternRequests, URL);
   }
 }
 
 const PageDependencyGraphComputed =
-  makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL']);
+  makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL', 'fromTrace']);
 export {PageDependencyGraphComputed as PageDependencyGraph};

package/core/computed/processed-navigation.d.ts

@@ -1,6 +1,6 @@
 export { ProcessedNavigationComputed as ProcessedNavigation };
 declare const ProcessedNavigationComputed: typeof ProcessedNavigation & {
-    request: (dependencies: import("../index.js").Artifacts.ProcessedTrace | import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+    request: (dependencies: import("../index.js").Trace | import("../index.js").Artifacts.ProcessedTrace, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../index.js").Artifacts.ProcessedNavigation>;
 };

package/core/computed/tbt-impact-tasks.js

@@ -4,13 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../lib/lantern/lantern.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {MainThreadTasks} from './main-thread-tasks.js';
 import {FirstContentfulPaint} from './metrics/first-contentful-paint.js';
 import {Interactive} from './metrics/interactive.js';
 import {TotalBlockingTime} from './metrics/total-blocking-time.js';
 import {ProcessedTrace} from './processed-trace.js';
-import {calculateTbtImpactForEvent} from './metrics/tbt-utils.js';
+
+const {calculateTbtImpactForEvent} = Lantern.TBTUtils;
 
 class TBTImpactTasks {
   /**
@@ -132,7 +134,7 @@ class TBTImpactTasks {
     /** @type {Map<LH.Artifacts.TaskNode, {start: number, end: number, duration: number}>} */
     const topLevelTaskToEvent = new Map();
 
-    /** @type {Map<LH.TraceEvent, LH.Artifacts.TaskNode>} */
+    /** @type {Map<Lantern.TraceEvent, LH.Artifacts.TaskNode>} */
     const traceEventToTask = new Map();
     for (const task of tasks) {
       traceEventToTask.set(task.event, task);

package/core/computed/trace-engine-result.d.ts

@@ -1,5 +1,4 @@
 export { TraceEngineResultComputed as TraceEngineResult };
-export type EnabledHandlers = typeof ENABLED_HANDLERS;
 declare const TraceEngineResultComputed: typeof TraceEngineResult & {
     request: (dependencies: {
         trace: LH.Trace;
@@ -7,16 +6,6 @@ declare const TraceEngineResultComputed: typeof TraceEngineResult & {
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<LH.Artifacts.TraceEngineResult>;
 };
-declare namespace ENABLED_HANDLERS {
-    const AuctionWorklets: typeof import("@paulirish/trace_engine/models/trace/handlers/AuctionWorkletsHandler.js");
-    const Initiators: typeof import("@paulirish/trace_engine/models/trace/handlers/InitiatorsHandler.js");
-    const LayoutShifts: typeof import("@paulirish/trace_engine/models/trace/handlers/LayoutShiftsHandler.js");
-    const NetworkRequests: typeof import("@paulirish/trace_engine/models/trace/handlers/NetworkRequestsHandler.js");
-    const Renderer: typeof import("@paulirish/trace_engine/models/trace/handlers/RendererHandler.js");
-    const Samples: typeof import("@paulirish/trace_engine/models/trace/handlers/SamplesHandler.js");
-    const Screenshots: typeof import("@paulirish/trace_engine/models/trace/handlers/ScreenshotsHandler.js");
-    const PageLoadMetrics: typeof import("@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js");
-}
 /**
  * @fileoverview Processes trace with the shared trace engine.
  */

package/core/computed/trace-engine-result.js

@@ -10,19 +10,6 @@ import {CumulativeLayoutShift} from './metrics/cumulative-layout-shift.js';
 import {ProcessedTrace} from './processed-trace.js';
 import * as LH from '../../types/lh.js';
 
-/** @typedef {typeof ENABLED_HANDLERS} EnabledHandlers */
-
-const ENABLED_HANDLERS = {
-  AuctionWorklets: TraceEngine.TraceHandlers.AuctionWorklets,
-  Initiators: TraceEngine.TraceHandlers.Initiators,
-  LayoutShifts: TraceEngine.TraceHandlers.LayoutShifts,
-  NetworkRequests: TraceEngine.TraceHandlers.NetworkRequests,
-  Renderer: TraceEngine.TraceHandlers.Renderer,
-  Samples: TraceEngine.TraceHandlers.Samples,
-  Screenshots: TraceEngine.TraceHandlers.Screenshots,
-  PageLoadMetrics: TraceEngine.TraceHandlers.PageLoadMetrics,
-};
-
 /**
  * @fileoverview Processes trace with the shared trace engine.
  */
@@ -32,15 +19,14 @@ class TraceEngineResult {
    * @return {Promise<LH.Artifacts.TraceEngineResult>}
    */
   static async runTraceEngine(traceEvents) {
-    const engine = new TraceEngine.TraceProcessor(ENABLED_HANDLERS);
+    const processor = TraceEngine.TraceProcessor.createWithAllHandlers();
     // eslint-disable-next-line max-len
-    await engine.parse(/** @type {import('@paulirish/trace_engine').Types.TraceEvents.TraceEventData[]} */ (
+    await processor.parse(/** @type {import('@paulirish/trace_engine').Types.TraceEvents.TraceEventData[]} */ (
       traceEvents
     ));
-    // TODO: use TraceEngine.TraceProcessor.createWithAllHandlers above.
-    if (!engine.traceParsedData) throw new Error('No data');
-    if (!engine.insights) throw new Error('No insights');
-    return {data: engine.traceParsedData, insights: engine.insights};
+    if (!processor.traceParsedData) throw new Error('No data');
+    if (!processor.insights) throw new Error('No insights');
+    return {data: processor.traceParsedData, insights: processor.insights};
   }
 
   /**

package/core/config/constants.d.ts

@@ -1,43 +1,31 @@
-export namespace throttling {
-    export { DEVTOOLS_RTT_ADJUSTMENT_FACTOR };
-    export { DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR };
-    export namespace mobileSlow4G {
-        const rttMs: number;
-        const throughputKbps: number;
-        const requestLatencyMs: number;
-        const downloadThroughputKbps: number;
-        const uploadThroughputKbps: number;
-        const cpuSlowdownMultiplier: number;
-    }
-    export namespace mobileRegular3G {
-        const rttMs_1: number;
-        export { rttMs_1 as rttMs };
-        const throughputKbps_1: number;
-        export { throughputKbps_1 as throughputKbps };
-        const requestLatencyMs_1: number;
-        export { requestLatencyMs_1 as requestLatencyMs };
-        const downloadThroughputKbps_1: number;
-        export { downloadThroughputKbps_1 as downloadThroughputKbps };
-        const uploadThroughputKbps_1: number;
-        export { uploadThroughputKbps_1 as uploadThroughputKbps };
-        const cpuSlowdownMultiplier_1: number;
-        export { cpuSlowdownMultiplier_1 as cpuSlowdownMultiplier };
-    }
-    export namespace desktopDense4G {
-        const rttMs_2: number;
-        export { rttMs_2 as rttMs };
-        const throughputKbps_2: number;
-        export { throughputKbps_2 as throughputKbps };
-        const cpuSlowdownMultiplier_2: number;
-        export { cpuSlowdownMultiplier_2 as cpuSlowdownMultiplier };
-        const requestLatencyMs_2: number;
-        export { requestLatencyMs_2 as requestLatencyMs };
-        const downloadThroughputKbps_2: number;
-        export { downloadThroughputKbps_2 as downloadThroughputKbps };
-        const uploadThroughputKbps_2: number;
-        export { uploadThroughputKbps_2 as uploadThroughputKbps };
-    }
-}
+export const throttling: {
+    DEVTOOLS_RTT_ADJUSTMENT_FACTOR: number;
+    DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR: number;
+    mobileSlow4G: {
+        rttMs: number;
+        throughputKbps: number;
+        requestLatencyMs: number;
+        downloadThroughputKbps: number;
+        uploadThroughputKbps: number;
+        cpuSlowdownMultiplier: number;
+    };
+    mobileRegular3G: {
+        rttMs: number;
+        throughputKbps: number;
+        requestLatencyMs: number;
+        downloadThroughputKbps: number;
+        uploadThroughputKbps: number;
+        cpuSlowdownMultiplier: number;
+    };
+    desktopDense4G: {
+        rttMs: number;
+        throughputKbps: number;
+        cpuSlowdownMultiplier: number;
+        requestLatencyMs: number;
+        downloadThroughputKbps: number;
+        uploadThroughputKbps: number;
+    };
+};
 export namespace screenEmulationMetrics {
     export { MOTOGPOWER_EMULATION_METRICS as mobile };
     export { DESKTOP_EMULATION_METRICS as desktop };
@@ -54,19 +42,6 @@ export namespace nonSimulatedSettingsOverrides {
     const networkQuietThresholdMs: number;
     const cpuQuietThresholdMs: number;
 }
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Adjustments needed for DevTools network throttling to simulate
- * more realistic network conditions.
- * @see https://crbug.com/721112
- * @see https://docs.google.com/document/d/10lfVdS1iDWCRKQXPfbxEn4Or99D64mvNlugP1AQuFlE/edit
- */
-declare const DEVTOOLS_RTT_ADJUSTMENT_FACTOR: 3.75;
-declare const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR: 0.9;
 /**
  * @type {Required<LH.SharedFlagsSettings['screenEmulation']>}
  */

package/core/config/constants.js

@@ -4,50 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/**
- * Adjustments needed for DevTools network throttling to simulate
- * more realistic network conditions.
- * @see https://crbug.com/721112
- * @see https://docs.google.com/document/d/10lfVdS1iDWCRKQXPfbxEn4Or99D64mvNlugP1AQuFlE/edit
- */
-const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
-const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
+import * as Lantern from '../lib/lantern/lantern.js';
 
-const throttling = {
-  DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-  DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-  // These values align with WebPageTest's definition of "Fast 3G"
-  // But offer similar characteristics to roughly the 75th percentile of 4G connections.
-  mobileSlow4G: {
-    rttMs: 150,
-    throughputKbps: 1.6 * 1024,
-    requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-    downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    cpuSlowdownMultiplier: 4,
-  },
-  // These values partially align with WebPageTest's definition of "Regular 3G".
-  // These values are meant to roughly align with Chrome UX report's 3G definition which are based
-  // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.
-  mobileRegular3G: {
-    rttMs: 300,
-    throughputKbps: 700,
-    requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-    downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    cpuSlowdownMultiplier: 4,
-  },
-  // Using a "broadband" connection type
-  // Corresponds to "Dense 4G 25th percentile" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v
-  desktopDense4G: {
-    rttMs: 40,
-    throughputKbps: 10 * 1024,
-    cpuSlowdownMultiplier: 1,
-    requestLatencyMs: 0, // 0 means unset
-    downloadThroughputKbps: 0,
-    uploadThroughputKbps: 0,
-  },
-};
+const throttling = Lantern.Simulation.Constants.throttling;
 
 /**
  * @type {Required<LH.SharedFlagsSettings['screenEmulation']>}

package/core/gather/driver/navigation.js

@@ -123,7 +123,7 @@ async function gotoURL(driver, requestor, options) {
   }
 
   const waitConditions = await Promise.race([
-    driver.fatalRejection.promise,
+    session.onCrashPromise(),
     Promise.all(waitConditionPromises),
   ]);
   const timedOut = waitConditions.some(condition => condition.timedOut);

package/core/gather/driver/network-monitor.d.ts

@@ -8,9 +8,10 @@ export class NetworkMonitor extends NetworkMonitor_base {
     /**
      * Finds all time periods where the number of inflight requests is less than or equal to the
      * number of allowed concurrent requests.
+     * The time periods returned are in ms.
      * @param {Array<LH.Artifacts.NetworkRequest>} requests
      * @param {number} allowedConcurrentRequests
-     * @param {number=} endTime
+     * @param {number=} endTime In ms
      * @return {Array<{start: number, end: number}>}
      */
     static findNetworkQuietPeriods(requests: Array<LH.Artifacts.NetworkRequest>, allowedConcurrentRequests: number, endTime?: number | undefined): Array<{

package/core/gather/driver/network-monitor.js

@@ -202,9 +202,10 @@ class NetworkMonitor extends NetworkMonitorEventEmitter {
   /**
    * Finds all time periods where the number of inflight requests is less than or equal to the
    * number of allowed concurrent requests.
+   * The time periods returned are in ms.
    * @param {Array<LH.Artifacts.NetworkRequest>} requests
    * @param {number} allowedConcurrentRequests
-   * @param {number=} endTime
+   * @param {number=} endTime In ms
    * @return {Array<{start: number, end: number}>}
    */
   static findNetworkQuietPeriods(requests, allowedConcurrentRequests, endTime = Infinity) {
@@ -215,10 +216,9 @@ class NetworkMonitor extends NetworkMonitorEventEmitter {
       if (UrlUtils.isNonNetworkProtocol(request.protocol)) return;
       if (request.protocol === 'ws' || request.protocol === 'wss') return;
 
-      // convert the network timestamp to ms
-      timeBoundaries.push({time: request.networkRequestTime * 1000, isStart: true});
+      timeBoundaries.push({time: request.networkRequestTime, isStart: true});
       if (request.finished) {
-        timeBoundaries.push({time: request.networkEndTime * 1000, isStart: false});
+        timeBoundaries.push({time: request.networkEndTime, isStart: false});
       }
     });
 

package/core/gather/driver/target-manager.d.ts

@@ -66,7 +66,7 @@ export class TargetManager extends TargetManager_base {
      * @param {LH.Protocol.TargetType} targetType
      * @param {string} sessionId
      */
-    _getProtocolEventListener(targetType: LH.Protocol.TargetType, sessionId: string): <EventName extends keyof import("puppeteer-core").ProtocolMapping.Events>(method: EventName, params: import("../../../types/protocol.js").default.RawEventMessageRecord[EventName]["params"]) => void;
+    _getProtocolEventListener(targetType: LH.Protocol.TargetType, sessionId: string): <EventName extends keyof import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Events>(method: EventName, params: import("../../../types/protocol.js").default.RawEventMessageRecord[EventName]["params"]) => void;
     /**
      * @return {Promise<void>}
      */

package/core/gather/driver.d.ts

@@ -14,10 +14,6 @@ export class Driver implements LH.Gatherer.Driver {
     /** @type {Fetcher|undefined} */
     _fetcher: Fetcher | undefined;
     defaultSession: import("../../types/gatherer.js").default.ProtocolSession;
-    fatalRejection: {
-        promise: Promise<never>;
-        rej: (_: Error) => void;
-    };
     /** @return {LH.Gatherer.Driver['executionContext']} */
     get executionContext(): ExecutionContext;
     get fetcher(): any;
@@ -27,14 +23,6 @@ export class Driver implements LH.Gatherer.Driver {
     url(): Promise<string>;
     /** @return {Promise<void>} */
     connect(): Promise<void>;
-    /**
-     * If the target crashes, we can't continue gathering.
-     *
-     * FWIW, if the target unexpectedly detaches (eg the user closed the tab), pptr will
-     * catch that and reject into our this._cdpSession.send, which we'll alrady handle appropriately
-     * @return {void}
-     */
-    listenForCrashes(): void;
     /** @return {Promise<void>} */
     disconnect(): Promise<void>;
 }

package/core/gather/driver.js

@@ -8,7 +8,6 @@ import log from 'lighthouse-logger';
 
 import {ExecutionContext} from './driver/execution-context.js';
 import {TargetManager} from './driver/target-manager.js';
-import {LighthouseError} from '../lib/lh-error.js';
 import {Fetcher} from './fetcher.js';
 import {NetworkMonitor} from './driver/network-monitor.js';
 
@@ -29,6 +28,7 @@ const throwingSession = {
   sendCommand: throwNotConnectedFn,
   sendCommandAndIgnore: throwNotConnectedFn,
   dispose: throwNotConnectedFn,
+  onCrashPromise: throwNotConnectedFn,
 };
 
 /** @implements {LH.Gatherer.Driver} */
@@ -48,12 +48,6 @@ class Driver {
     this._fetcher = undefined;
 
     this.defaultSession = throwingSession;
-
-    // Poor man's Promise.withResolvers()
-    /** @param {Error} _ */
-    let rej = _ => {};
-    const promise = /** @type {Promise<never>} */ (new Promise((_, theRej) => rej = theRej));
-    this.fatalRejection = {promise, rej};
   }
 
   /** @return {LH.Gatherer.Driver['executionContext']} */
@@ -93,30 +87,11 @@ class Driver {
     this._networkMonitor = new NetworkMonitor(this._targetManager);
     await this._networkMonitor.enable();
     this.defaultSession = this._targetManager.rootSession();
-    this.listenForCrashes();
     this._executionContext = new ExecutionContext(this.defaultSession);
     this._fetcher = new Fetcher(this.defaultSession);
     log.timeEnd(status);
   }
 
-  /**
-   * If the target crashes, we can't continue gathering.
-   *
-   * FWIW, if the target unexpectedly detaches (eg the user closed the tab), pptr will
-   * catch that and reject into our this._cdpSession.send, which we'll alrady handle appropriately
-   * @return {void}
-   */
-  listenForCrashes() {
-    this.defaultSession.on('Inspector.targetCrashed', async _ => {
-      log.error('Driver', 'Inspector.targetCrashed');
-      // Manually detach so no more CDP traffic is attempted.
-      // Don't await, else our rejection will be a 'Target closed' protocol error on cross-talk CDP calls.
-      void this.defaultSession.dispose();
-      this.fatalRejection.rej(new LighthouseError(LighthouseError.errors.TARGET_CRASHED));
-    });
-  }
-
-
   /** @return {Promise<void>} */
   async disconnect() {
     if (this.defaultSession === throwingSession) return;

package/core/gather/gatherers/inspector-issues.js

@@ -80,6 +80,7 @@ class InspectorIssues extends BaseGatherer {
       quirksModeIssue: [],
       cookieIssue: [],
       sharedArrayBufferIssue: [],
+      sharedDictionaryIssue: [],
       stylesheetLoadingIssue: [],
       federatedAuthUserInfoRequestIssue: [],
     };