lighthouse 9.6.8 → 10.0.0-dev.20230209

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

@@ -0,0 +1,157 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {ProcessedTrace} from '../processed-trace.js';
+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';
+import {CumulativeLayoutShift} from './cumulative-layout-shift.js';
+import {SpeedIndex} from './speed-index.js';
+import {MaxPotentialFID} from './max-potential-fid.js';
+import {TotalBlockingTime} from './total-blocking-time.js';
+import {makeComputedArtifact} from '../computed-artifact.js';
+
+class TimingSummary {
+  /**
+     * @param {LH.Trace} trace
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @param {LH.Artifacts['GatherContext']} gatherContext
+     * @param {LH.Util.ImmutableObject<LH.Config.Settings>} settings
+     * @param {LH.Artifacts['URL']} URL
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
+     */
+  static async summarize(trace, devtoolsLog, gatherContext, settings, URL, context) {
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL};
+    /**
+     * @template TArtifacts
+     * @template TReturn
+     * @param {{request: (artifact: TArtifacts, context: LH.Artifacts.ComputedContext) => Promise<TReturn>}} Artifact
+     * @param {TArtifacts} artifact
+     * @return {Promise<TReturn|undefined>}
+     */
+    const requestOrUndefined = (Artifact, artifact) => {
+      return Artifact.request(artifact, context).catch(_ => undefined);
+    };
+
+    /* eslint-disable max-len */
+
+    const processedTrace = await ProcessedTrace.request(trace, context);
+    const processedNavigation = await requestOrUndefined(ProcessedNavigation, trace);
+    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);
+    const cumulativeLayoutShiftValues = await requestOrUndefined(CumulativeLayoutShift, trace);
+    const maxPotentialFID = await requestOrUndefined(MaxPotentialFID, metricComputationData);
+    const speedIndex = await requestOrUndefined(SpeedIndex, metricComputationData);
+    const totalBlockingTime = await requestOrUndefined(TotalBlockingTime, metricComputationData);
+
+    const {
+      cumulativeLayoutShift,
+      cumulativeLayoutShiftMainFrame,
+      totalCumulativeLayoutShift,
+    } = cumulativeLayoutShiftValues || {};
+
+    /** @type {LH.Artifacts.TimingSummary} */
+    const metrics = {
+      // Include the simulated/observed performance metrics
+      firstContentfulPaint: firstContentfulPaint?.timing,
+      firstContentfulPaintTs: firstContentfulPaint?.timestamp,
+      firstContentfulPaintAllFrames: firstContentfulPaintAllFrames?.timing,
+      firstContentfulPaintAllFramesTs: firstContentfulPaintAllFrames?.timestamp,
+      firstMeaningfulPaint: firstMeaningfulPaint?.timing,
+      firstMeaningfulPaintTs: firstMeaningfulPaint?.timestamp,
+      largestContentfulPaint: largestContentfulPaint?.timing,
+      largestContentfulPaintTs: largestContentfulPaint?.timestamp,
+      largestContentfulPaintAllFrames: largestContentfulPaintAllFrames?.timing,
+      largestContentfulPaintAllFramesTs: largestContentfulPaintAllFrames?.timestamp,
+      interactive: interactive?.timing,
+      interactiveTs: interactive?.timestamp,
+      speedIndex: speedIndex?.timing,
+      speedIndexTs: speedIndex?.timestamp,
+      totalBlockingTime: totalBlockingTime?.timing,
+      maxPotentialFID: maxPotentialFID?.timing,
+      cumulativeLayoutShift,
+      cumulativeLayoutShiftMainFrame,
+      totalCumulativeLayoutShift,
+
+      // Include all timestamps of interest from the processed trace
+      observedTimeOrigin: processedTrace.timings.timeOrigin,
+      observedTimeOriginTs: processedTrace.timestamps.timeOrigin,
+      // For now, navigationStart is always timeOrigin.
+      observedNavigationStart: processedNavigation?.timings.timeOrigin,
+      observedNavigationStartTs: processedNavigation?.timestamps.timeOrigin,
+      observedFirstPaint: processedNavigation?.timings.firstPaint,
+      observedFirstPaintTs: processedNavigation?.timestamps.firstPaint,
+      observedFirstContentfulPaint: processedNavigation?.timings.firstContentfulPaint,
+      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,
+      observedLargestContentfulPaintAllFramesTs: processedNavigation?.timestamps.largestContentfulPaintAllFrames,
+      observedTraceEnd: processedTrace.timings.traceEnd,
+      observedTraceEndTs: processedTrace.timestamps.traceEnd,
+      observedLoad: processedNavigation?.timings.load,
+      observedLoadTs: processedNavigation?.timestamps.load,
+      observedDomContentLoaded: processedNavigation?.timings.domContentLoaded,
+      observedDomContentLoadedTs: processedNavigation?.timestamps.domContentLoaded,
+      observedCumulativeLayoutShift: cumulativeLayoutShift,
+      observedCumulativeLayoutShiftMainFrame: cumulativeLayoutShiftMainFrame,
+      observedTotalCumulativeLayoutShift: totalCumulativeLayoutShift,
+
+      // Include some visual metrics from speedline
+      observedFirstVisualChange: speedline.first,
+      observedFirstVisualChangeTs: (speedline.first + speedline.beginning) * 1000,
+      observedLastVisualChange: speedline.complete,
+      observedLastVisualChangeTs: (speedline.complete + speedline.beginning) * 1000,
+      observedSpeedIndex: speedline.speedIndex,
+      observedSpeedIndexTs: (speedline.speedIndex + speedline.beginning) * 1000,
+    };
+
+    /* eslint-enable max-len */
+
+    /** @type {Record<string,boolean>} */
+    const debugInfo = {
+      lcpInvalidated: !!processedNavigation?.lcpInvalidated,
+    };
+
+    return {metrics, debugInfo};
+  }
+  /**
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
+   */
+  static async compute_(data, context) {
+    return TimingSummary.summarize(
+      data.trace,
+      data.devtoolsLog,
+      data.gatherContext,
+      data.settings,
+      data.URL,
+      context
+    );
+  }
+}
+
+const TimingSummaryComputed = makeComputedArtifact(
+  TimingSummary,
+  ['devtoolsLog', 'gatherContext', 'settings', 'trace', 'URL']
+);
+export {TimingSummaryComputed as TimingSummary};

package/core/computed/metrics/total-blocking-time.d.ts

@@ -0,0 +1,23 @@
+export { TotalBlockingTimeComputed as TotalBlockingTime };
+declare const TotalBlockingTimeComputed: typeof TotalBlockingTime & {
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+/**
+ * @fileoverview This audit determines Total Blocking Time.
+
+ * We define Blocking Time as any time interval in the loading timeline where task length exceeds
+ * 50ms. For example, if there is a 110ms main thread task, the last 60ms of it is blocking time.
+ * Total Blocking Time is the sum of all Blocking Time between First Contentful Paint and
+ * Interactive Time (TTI).
+ *
+ * This is a new metric designed to accompany Time to Interactive. TTI is strict and does not
+ * reflect incremental improvements to the site performance unless the improvement concerns the last
+ * long task. Total Blocking Time on the other hand is designed to be much more responsive
+ * to smaller improvements to main thread responsiveness.
+ */
+declare class TotalBlockingTime extends ComputedMetric {
+}
+import ComputedMetric from "./metric.js";
+//# sourceMappingURL=total-blocking-time.d.ts.map

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

@@ -0,0 +1,74 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+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';
+
+/**
+ * @fileoverview This audit determines Total Blocking Time.
+
+ * We define Blocking Time as any time interval in the loading timeline where task length exceeds
+ * 50ms. For example, if there is a 110ms main thread task, the last 60ms of it is blocking time.
+ * Total Blocking Time is the sum of all Blocking Time between First Contentful Paint and
+ * Interactive Time (TTI).
+ *
+ * This is a new metric designed to accompany Time to Interactive. TTI is strict and does not
+ * reflect incremental improvements to the site performance unless the improvement concerns the last
+ * long task. Total Blocking Time on the other hand is designed to be much more responsive
+ * to smaller improvements to main thread responsiveness.
+ */
+class TotalBlockingTime extends ComputedMetric {
+  /**
+   * @param {LH.Artifacts.MetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static computeSimulatedMetric(data, context) {
+    const metricData = ComputedMetric.getMetricComputationInput(data);
+    return LanternTotalBlockingTime.request(metricData, context);
+  }
+
+  /**
+   * @param {LH.Artifacts.MetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeObservedMetric(data, context) {
+    const events = TraceProcessor.getMainThreadTopLevelEvents(data.processedTrace);
+
+    if (data.processedNavigation) {
+      const {firstContentfulPaint} = data.processedNavigation.timings;
+      const metricData = ComputedMetric.getMetricComputationInput(data);
+      const interactiveTimeMs = (await Interactive.request(metricData, context)).timing;
+
+      return {
+        timing: calculateSumOfBlockingTime(
+          events,
+          firstContentfulPaint,
+          interactiveTimeMs
+        ),
+      };
+    } else {
+      return {
+        timing: calculateSumOfBlockingTime(
+          events,
+          0,
+          data.processedTrace.timestamps.traceEnd
+        ),
+      };
+    }
+  }
+}
+
+const TotalBlockingTimeComputed = makeComputedArtifact(
+  TotalBlockingTime,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {TotalBlockingTimeComputed as TotalBlockingTime};

package/core/computed/module-duplication.d.ts

@@ -0,0 +1,37 @@
+export { ModuleDuplicationComputed as ModuleDuplication };
+declare const ModuleDuplicationComputed: typeof ModuleDuplication & {
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Map<string, {
+        scriptId: string;
+        scriptUrl: string;
+        resourceSize: number;
+    }[]>>;
+};
+declare class ModuleDuplication {
+    /**
+     * @param {string} source
+     */
+    static normalizeSource(source: string): string;
+    /**
+     * @param {string} source
+     */
+    static _shouldIgnoreSource(source: string): boolean;
+    /**
+     * @param {Map<string, Array<{scriptId: string, resourceSize: number}>>} moduleNameToSourceData
+     */
+    static _normalizeAggregatedData(moduleNameToSourceData: Map<string, Array<{
+        scriptId: string;
+        resourceSize: number;
+    }>>): void;
+    /**
+     * @param {Pick<LH.Artifacts, 'Scripts'|'SourceMaps'>} artifacts
+     * @param {LH.Artifacts.ComputedContext} context
+     */
+    static compute_(artifacts: Pick<LH.Artifacts, 'Scripts' | 'SourceMaps'>, context: LH.Artifacts.ComputedContext): Promise<Map<string, {
+        scriptId: string;
+        scriptUrl: string;
+        resourceSize: number;
+    }[]>>;
+}
+//# sourceMappingURL=module-duplication.d.ts.map

package/core/computed/module-duplication.js

@@ -0,0 +1,138 @@
+/**
+ * @license Copyright 2020 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from './computed-artifact.js';
+import {JSBundles} from './js-bundles.js';
+
+const RELATIVE_SIZE_THRESHOLD = 0.1;
+const ABSOLUTE_SIZE_THRESHOLD_BYTES = 1024 * 0.5;
+
+class ModuleDuplication {
+  /**
+   * @param {string} source
+   */
+  static normalizeSource(source) {
+    // Trim trailing question mark - b/c webpack.
+    source = source.replace(/\?$/, '');
+
+    // Normalize paths for dependencies by only keeping everything after the last `node_modules`.
+    const lastNodeModulesIndex = source.lastIndexOf('node_modules');
+    if (lastNodeModulesIndex !== -1) {
+      source = source.substring(lastNodeModulesIndex);
+    }
+
+    return source;
+  }
+
+  /**
+   * @param {string} source
+   */
+  static _shouldIgnoreSource(source) {
+    // Ignore bundle overhead.
+    if (source.includes('webpack/bootstrap')) return true;
+    if (source.includes('(webpack)/buildin')) return true;
+
+    // Ignore webpack module shims, i.e. aliases of the form `module.exports = window.jQuery`
+    if (source.includes('external ')) return true;
+
+    return false;
+  }
+
+  /**
+   * @param {Map<string, Array<{scriptId: string, resourceSize: number}>>} moduleNameToSourceData
+   */
+  static _normalizeAggregatedData(moduleNameToSourceData) {
+    for (const [key, originalSourceData] of moduleNameToSourceData.entries()) {
+      let sourceData = originalSourceData;
+
+      // Sort by resource size.
+      sourceData.sort((a, b) => b.resourceSize - a.resourceSize);
+
+      // Remove modules smaller than a % size of largest.
+      if (sourceData.length > 1) {
+        const largestResourceSize = sourceData[0].resourceSize;
+        sourceData = sourceData.filter(data => {
+          const percentSize = data.resourceSize / largestResourceSize;
+          return percentSize >= RELATIVE_SIZE_THRESHOLD;
+        });
+      }
+
+      // Remove modules smaller than an absolute theshold.
+      sourceData = sourceData.filter(data => data.resourceSize >= ABSOLUTE_SIZE_THRESHOLD_BYTES);
+
+      // Delete source datas with only one value (no duplicates).
+      if (sourceData.length > 1) {
+        moduleNameToSourceData.set(key, sourceData);
+      } else {
+        moduleNameToSourceData.delete(key);
+      }
+    }
+  }
+
+  /**
+   * @param {Pick<LH.Artifacts, 'Scripts'|'SourceMaps'>} artifacts
+   * @param {LH.Artifacts.ComputedContext} context
+   */
+  static async compute_(artifacts, context) {
+    const bundles = await JSBundles.request(artifacts, context);
+
+    /**
+     * @typedef SourceData
+     * @property {string} source
+     * @property {number} resourceSize
+     */
+
+    /** @type {Map<LH.Artifacts.RawSourceMap, SourceData[]>} */
+    const sourceDatasMap = new Map();
+
+    // Determine size of each `sources` entry.
+    for (const {rawMap, sizes} of bundles) {
+      if ('errorMessage' in sizes) continue;
+
+      /** @type {SourceData[]} */
+      const sourceDataArray = [];
+      sourceDatasMap.set(rawMap, sourceDataArray);
+
+      for (let i = 0; i < rawMap.sources.length; i++) {
+        if (this._shouldIgnoreSource(rawMap.sources[i])) continue;
+
+        const sourceKey = (rawMap.sourceRoot || '') + rawMap.sources[i];
+        const sourceSize = sizes.files[sourceKey];
+        sourceDataArray.push({
+          source: ModuleDuplication.normalizeSource(rawMap.sources[i]),
+          resourceSize: sourceSize,
+        });
+      }
+    }
+
+    /** @type {Map<string, Array<{scriptId: string, scriptUrl: string, resourceSize: number}>>} */
+    const moduleNameToSourceData = new Map();
+    for (const {rawMap, script} of bundles) {
+      const sourceDataArray = sourceDatasMap.get(rawMap);
+      if (!sourceDataArray) continue;
+
+      for (const sourceData of sourceDataArray) {
+        let data = moduleNameToSourceData.get(sourceData.source);
+        if (!data) {
+          data = [];
+          moduleNameToSourceData.set(sourceData.source, data);
+        }
+        data.push({
+          scriptId: script.scriptId,
+          scriptUrl: script.url,
+          resourceSize: sourceData.resourceSize,
+        });
+      }
+    }
+
+    this._normalizeAggregatedData(moduleNameToSourceData);
+    return moduleNameToSourceData;
+  }
+}
+
+const ModuleDuplicationComputed =
+  makeComputedArtifact(ModuleDuplication, ['Scripts', 'SourceMaps']);
+export {ModuleDuplicationComputed as ModuleDuplication};

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

@@ -0,0 +1,20 @@
+export { NetworkAnalysisComputed as NetworkAnalysis };
+declare const NetworkAnalysisComputed: typeof NetworkAnalysis & {
+    request: (dependencies: import("../index.js").DevtoolsLog, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => 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
+     * @return {Promise<LH.Artifacts.NetworkAnalysis>}
+     */
+    static compute_(devtoolsLog: import("../index.js").DevtoolsLog, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkAnalysis>;
+}
+//# sourceMappingURL=network-analysis.d.ts.map

package/core/computed/network-analysis.js

@@ -0,0 +1,64 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkAnalyzer} from '../lib/dependency-graph/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
+   * @return {Promise<LH.Artifacts.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};
+  }
+}
+
+const NetworkAnalysisComputed = makeComputedArtifact(NetworkAnalysis, null);
+export {NetworkAnalysisComputed as NetworkAnalysis};

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

@@ -0,0 +1,15 @@
+export { NetworkRecordsComputed as NetworkRecords };
+declare const NetworkRecordsComputed: typeof NetworkRecords & {
+    request: (dependencies: LH.DevtoolsLog, context: LH.Util.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/network-request.js").NetworkRequest[]>;
+};
+declare class NetworkRecords {
+    /**
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @return {Promise<Array<LH.Artifacts.NetworkRequest>>} networkRecords
+     */
+    static compute_(devtoolsLog: LH.DevtoolsLog): Promise<Array<LH.Artifacts.NetworkRequest>>;
+}
+import * as LH from "../../types/lh.js";
+//# sourceMappingURL=network-records.d.ts.map

package/core/computed/network-records.js

@@ -0,0 +1,22 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import * as LH from '../../types/lh.js';
+import {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkRecorder} from '../lib/network-recorder.js';
+
+class NetworkRecords {
+  /**
+   * @param {LH.DevtoolsLog} devtoolsLog
+   * @return {Promise<Array<LH.Artifacts.NetworkRequest>>} networkRecords
+   */
+  static async compute_(devtoolsLog) {
+    return NetworkRecorder.recordsFromLogs(devtoolsLog);
+  }
+}
+
+const NetworkRecordsComputed = makeComputedArtifact(NetworkRecords, null);
+export {NetworkRecordsComputed as NetworkRecords};

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

@@ -0,0 +1,88 @@
+export { PageDependencyGraphComputed as PageDependencyGraph };
+export type Node = import('../lib/dependency-graph/base-node.js').Node;
+export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
+export type NetworkNodeOutput = {
+    nodes: Array<NetworkNode>;
+    idToNodeMap: Map<string, NetworkNode>;
+    urlToNodeMap: Map<string, Array<NetworkNode>>;
+    frameIdToNodeMap: Map<string, NetworkNode | null>;
+};
+declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts['URL'];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/dependency-graph/base-node.js").Node>;
+};
+import { NetworkNode } from "../lib/dependency-graph/network-node.js";
+declare class PageDependencyGraph {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {Array<string>}
+     */
+    static getNetworkInitiators(record: LH.Artifacts.NetworkRequest): Array<string>;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {NetworkNodeOutput}
+     */
+    static getNetworkNodeOutput(networkRecords: Array<LH.Artifacts.NetworkRequest>): NetworkNodeOutput;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {Array<CPUNode>}
+     */
+    static getCPUNodes({ mainThreadEvents }: LH.Artifacts.ProcessedTrace): Array<CPUNode>;
+    /**
+     * @param {NetworkNode} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     */
+    static linkNetworkNodes(rootNode: NetworkNode, networkNodeOutput: NetworkNodeOutput): void;
+    /**
+     * @param {Node} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     * @param {Array<CPUNode>} cpuNodes
+     */
+    static linkCPUNodes(rootNode: Node, networkNodeOutput: NetworkNodeOutput, cpuNodes: Array<CPUNode>): void;
+    /**
+     * Removes the given node from the graph, but retains all paths between its dependencies and
+     * dependents.
+     * @param {Node} node
+     */
+    static _pruneNode(node: Node): void;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {URLArtifact} URL
+     * @return {Node}
+     */
+    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<LH.Artifacts.NetworkRequest>, URL: URLArtifact): Node;
+    /**
+     *
+     * @param {Node} rootNode
+     */
+    static printGraph(rootNode: Node, widthInCharacters?: number): void;
+    /**
+     * Recalculate `artifacts.URL` for clients that don't provide it.
+     *
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {URLArtifact}
+     */
+    static getDocumentUrls(devtoolsLog: import("../index.js").DevtoolsLog, networkRecords: LH.Artifacts.NetworkRequest[], processedTrace: LH.Artifacts.ProcessedTrace): URLArtifact;
+    /**
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Node>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts['URL'];
+    }, context: LH.Artifacts.ComputedContext): Promise<Node>;
+}
+import { NetworkRequest } from "../lib/network-request.js";
+import { ProcessedTrace } from "./processed-trace.js";
+import { CPUNode } from "../lib/dependency-graph/cpu-node.js";
+//# sourceMappingURL=page-dependency-graph.d.ts.map