lighthouse 10.1.1 → 10.2.0

package/core/computed/metrics/first-meaningful-paint.d.ts

@@ -5,11 +5,17 @@ declare const FirstMeaningfulPaintComputed: typeof FirstMeaningfulPaint & {
     }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
 };
 declare class FirstMeaningfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @return {Promise<LH.Artifacts.Metric>}
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=first-meaningful-paint.d.ts.map

package/core/computed/metrics/interactive.d.ts

@@ -51,11 +51,17 @@ declare class Interactive extends NavigationMetric {
         cpuQuietPeriods: Array<TimePeriod>;
         networkQuietPeriods: Array<TimePeriod>;
     };
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @return {Promise<LH.Artifacts.Metric>}
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=interactive.d.ts.map

package/core/computed/metrics/lantern-first-contentful-paint.d.ts

@@ -44,5 +44,5 @@ declare class LanternFirstContentfulPaint extends LanternMetric {
      */
     static getFirstPaintBasedGraph(dependencyGraph: Node, paintTs: number, blockingResourcesFilter: (arg0: NetworkNode) => boolean, extraBlockingCpuNodesToIncludeFilter?: ((arg0: CPUNode) => boolean) | undefined): Node;
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-first-contentful-paint.d.ts.map

package/core/computed/metrics/lantern-first-meaningful-paint.d.ts

@@ -8,5 +8,5 @@ declare const LanternFirstMeaningfulPaintComputed: typeof LanternFirstMeaningful
 /** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
 declare class LanternFirstMeaningfulPaint extends LanternMetric {
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-first-meaningful-paint.d.ts.map

package/core/computed/metrics/lantern-interactive.d.ts

@@ -27,5 +27,5 @@ declare class LanternInteractive extends LanternMetric {
      */
     static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-interactive.d.ts.map

package/core/computed/metrics/lantern-largest-contentful-paint.d.ts

@@ -21,5 +21,5 @@ declare class LanternLargestContentfulPaint extends LanternMetric {
      */
     static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result): LH.Gatherer.Simulation.Result;
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-largest-contentful-paint.d.ts.map

package/core/computed/metrics/lantern-max-potential-fid.d.ts

@@ -26,5 +26,5 @@ declare class LanternMaxPotentialFID extends LanternMetric {
         duration: number;
     }>;
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-max-potential-fid.d.ts.map

package/core/computed/metrics/lantern-metric.d.ts

@@ -74,5 +74,5 @@ export class LanternMetric {
      */
     static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { ProcessedNavigation } from "../processed-navigation.js";
+import { ProcessedNavigation } from '../processed-navigation.js';
 //# sourceMappingURL=lantern-metric.d.ts.map

package/core/computed/metrics/lantern-speed-index.d.ts

@@ -34,5 +34,5 @@ declare class LanternSpeedIndex extends LanternMetric {
      */
     static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-speed-index.d.ts.map

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

@@ -27,5 +27,5 @@ declare class LanternTotalBlockingTime extends LanternMetric {
         duration: number;
     }[];
 }
-import { LanternMetric } from "./lantern-metric.js";
+import { LanternMetric } from './lantern-metric.js';
 //# sourceMappingURL=lantern-total-blocking-time.d.ts.map

package/core/computed/metrics/largest-contentful-paint-all-frames.d.ts

@@ -16,5 +16,5 @@ declare class LargestContentfulPaintAllFrames extends NavigationMetric {
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=largest-contentful-paint-all-frames.d.ts.map

package/core/computed/metrics/largest-contentful-paint.d.ts

@@ -5,11 +5,17 @@ declare const LargestContentfulPaintComputed: typeof LargestContentfulPaint & {
     }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
 };
 declare class LargestContentfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @return {Promise<LH.Artifacts.Metric>}
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=largest-contentful-paint.d.ts.map

package/core/computed/metrics/lcp-breakdown.d.ts

@@ -0,0 +1,23 @@
+export { LCPBreakdownComputed as LCPBreakdown };
+declare const LCPBreakdownComputed: typeof LCPBreakdown & {
+    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<{
+        ttfb: number;
+        loadStart?: number | undefined;
+        loadEnd?: number | undefined;
+    }>;
+};
+declare class LCPBreakdown {
+    /**
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{ttfb: number, loadStart?: number, loadEnd?: number}>}
+     */
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<{
+        ttfb: number;
+        loadStart?: number | undefined;
+        loadEnd?: number | undefined;
+    }>;
+}
+//# sourceMappingURL=lcp-breakdown.d.ts.map

package/core/computed/metrics/lcp-breakdown.js

@@ -0,0 +1,58 @@
+/**
+ * @license Copyright 2023 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 {LighthouseError} from '../../lib/lh-error.js';
+import {LargestContentfulPaint} from './largest-contentful-paint.js';
+import {ProcessedNavigation} from '../processed-navigation.js';
+import {TimeToFirstByte} from './time-to-first-byte.js';
+import {LCPImageRecord} from '../lcp-image-record.js';
+
+class LCPBreakdown {
+  /**
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<{ttfb: number, loadStart?: number, loadEnd?: number}>}
+   */
+  static async compute_(data, context) {
+    const processedNavigation = await ProcessedNavigation.request(data.trace, context);
+    const observedLcp = processedNavigation.timings.largestContentfulPaint;
+    if (observedLcp === undefined) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP);
+    }
+    const timeOrigin = processedNavigation.timestamps.timeOrigin / 1000;
+
+    const {timing: ttfb} = await TimeToFirstByte.request(data, context);
+
+    const lcpRecord = await LCPImageRecord.request(data, context);
+    if (!lcpRecord) {
+      return {ttfb};
+    }
+
+    // Official LCP^tm. Will be lantern result if simulated, otherwise same as observedLcp.
+    const {timing: metricLcp} = await LargestContentfulPaint.request(data, context);
+    const throttleRatio = metricLcp / observedLcp;
+
+    const unclampedLoadStart = (lcpRecord.networkRequestTime - timeOrigin) * throttleRatio;
+    const loadStart = Math.max(ttfb, Math.min(unclampedLoadStart, metricLcp));
+
+    const unclampedLoadEnd = (lcpRecord.networkEndTime - timeOrigin) * throttleRatio;
+    const loadEnd = Math.max(loadStart, Math.min(unclampedLoadEnd, metricLcp));
+
+    return {
+      ttfb,
+      loadStart,
+      loadEnd,
+    };
+  }
+}
+
+const LCPBreakdownComputed = makeComputedArtifact(
+  LCPBreakdown,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LCPBreakdownComputed as LCPBreakdown};
+

package/core/computed/metrics/max-potential-fid.d.ts

@@ -5,11 +5,17 @@ declare const MaxPotentialFIDComputed: typeof MaxPotentialFID & {
     }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
 };
 declare class MaxPotentialFID extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @return {Promise<LH.Artifacts.Metric>}
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=max-potential-fid.d.ts.map

package/core/computed/metrics/metric.d.ts

@@ -19,9 +19,9 @@ declare class Metric {
     /**
      * @param {LH.Artifacts.MetricComputationData} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<LH.Artifacts.LanternMetric>}
+     * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
      */
-    static computeSimulatedMetric(data: LH.Artifacts.MetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
+    static computeSimulatedMetric(data: LH.Artifacts.MetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric | LH.Artifacts.Metric>;
     /**
      * @param {LH.Artifacts.MetricComputationData} data
      * @param {LH.Artifacts.ComputedContext} context

package/core/computed/metrics/metric.js

@@ -40,7 +40,7 @@ class Metric {
   /**
    * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
    */
   static computeSimulatedMetric(data, context) { // eslint-disable-line no-unused-vars
     throw new Error('Unimplemented');

package/core/computed/metrics/navigation-metric.d.ts

@@ -2,9 +2,9 @@ export class NavigationMetric extends Metric {
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<LH.Artifacts.LanternMetric>}
+     * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
      */
-    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric | LH.Artifacts.Metric>;
     /**
      * @param {LH.Artifacts.NavigationMetricComputationData} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -12,5 +12,5 @@ export class NavigationMetric extends Metric {
      */
     static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.Metric>;
 }
-import Metric from "./metric.js";
+import Metric from './metric.js';
 //# sourceMappingURL=navigation-metric.d.ts.map

package/core/computed/metrics/navigation-metric.js

@@ -14,7 +14,7 @@ class NavigationMetric extends Metric {
   /**
    * @param {LH.Artifacts.NavigationMetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
    */
   static computeSimulatedMetric(data, context) { // eslint-disable-line no-unused-vars
     throw new Error('Unimplemented');

package/core/computed/metrics/responsiveness.d.ts

@@ -83,5 +83,5 @@ declare class Responsiveness {
         settings: LH.Audit.Context['settings'];
     }, context: LH.Artifacts.ComputedContext): Promise<EventTimingEvent | FallbackTimingEvent | null>;
 }
-import { ProcessedTrace } from "../processed-trace.js";
+import { ProcessedTrace } from '../processed-trace.js';
 //# sourceMappingURL=responsiveness.d.ts.map

package/core/computed/metrics/speed-index.d.ts

@@ -5,6 +5,12 @@ declare const SpeedIndexComputed: typeof SpeedIndex & {
     }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
 };
 declare class SpeedIndex extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import { NavigationMetric } from "./navigation-metric.js";
+import { NavigationMetric } from './navigation-metric.js';
 //# sourceMappingURL=speed-index.d.ts.map

package/core/computed/metrics/time-to-first-byte.d.ts

@@ -0,0 +1,16 @@
+export { TimeToFirstByteComputed as TimeToFirstByte };
+declare const TimeToFirstByteComputed: typeof TimeToFirstByte & {
+    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>;
+};
+declare class TimeToFirstByte extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from './navigation-metric.js';
+//# sourceMappingURL=time-to-first-byte.d.ts.map

package/core/computed/metrics/time-to-first-byte.js

@@ -0,0 +1,60 @@
+/**
+ * @license Copyright 2023 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 {NavigationMetric} from './navigation-metric.js';
+import {MainResource} from '../main-resource.js';
+import {NetworkAnalysis} from '../network-analysis.js';
+
+class TimeToFirstByte extends NavigationMetric {
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeSimulatedMetric(data, context) {
+    const mainResource = await MainResource.request(data, context);
+    const networkAnalysis = await NetworkAnalysis.request(data.devtoolsLog, context);
+
+    const observedTTFB = (await this.computeObservedMetric(data, context)).timing;
+    const observedResponseTime =
+      networkAnalysis.serverResponseTimeByOrigin.get(mainResource.parsedURL.securityOrigin);
+    if (observedResponseTime === undefined) throw new Error('No response time for origin');
+
+    // Estimate when the connection is not warm.
+    // TTFB = DNS + (SSL)? + TCP handshake + 1 RT for request + server response time
+    let roundTrips = 3;
+    if (mainResource.parsedURL.scheme === 'https') roundTrips += 1;
+    const estimatedTTFB = data.settings.throttling.rttMs * roundTrips + observedResponseTime;
+
+    const timing = Math.max(observedTTFB, estimatedTTFB);
+    return {timing};
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeObservedMetric(data, context) {
+    const {processedNavigation} = data;
+    const timeOriginTs = processedNavigation.timestamps.timeOrigin;
+    const mainResource = await MainResource.request(data, context);
+
+    // Technically TTFB is the start of the response headers not the end.
+    // That signal isn't available to us so we use header end time as a best guess.
+    const timestamp = mainResource.responseHeadersEndTime * 1000;
+    const timing = (timestamp - timeOriginTs) / 1000;
+
+    return {timing, timestamp};
+  }
+}
+
+const TimeToFirstByteComputed = makeComputedArtifact(
+  TimeToFirstByte,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {TimeToFirstByteComputed as TimeToFirstByte};

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

@@ -18,6 +18,8 @@ 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';
+import {TimeToFirstByte} from './time-to-first-byte.js';
+import {LCPBreakdown} from './lcp-breakdown.js';
 
 class TimingSummary {
   /**
@@ -57,6 +59,8 @@ class TimingSummary {
     const maxPotentialFID = await requestOrUndefined(MaxPotentialFID, metricComputationData);
     const speedIndex = await requestOrUndefined(SpeedIndex, metricComputationData);
     const totalBlockingTime = await requestOrUndefined(TotalBlockingTime, metricComputationData);
+    const lcpBreakdown = await requestOrUndefined(LCPBreakdown, metricComputationData);
+    const ttfb = await requestOrUndefined(TimeToFirstByte, metricComputationData);
 
     const {
       cumulativeLayoutShift,
@@ -87,6 +91,12 @@ class TimingSummary {
       cumulativeLayoutShiftMainFrame,
       totalCumulativeLayoutShift,
 
+      lcpLoadStart: lcpBreakdown?.loadStart,
+      lcpLoadEnd: lcpBreakdown?.loadEnd,
+
+      timeToFirstByte: ttfb?.timing,
+      timeToFirstByteTs: ttfb?.timestamp,
+
       // Include all timestamps of interest from the processed trace
       observedTimeOrigin: processedTrace.timings.timeOrigin,
       observedTimeOriginTs: processedTrace.timestamps.timeOrigin,

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

@@ -18,6 +18,12 @@ declare const TotalBlockingTimeComputed: typeof TotalBlockingTime & {
  * to smaller improvements to main thread responsiveness.
  */
 declare class TotalBlockingTime extends ComputedMetric {
+    /**
+     * @param {LH.Artifacts.MetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.MetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
 }
-import ComputedMetric from "./metric.js";
+import ComputedMetric from './metric.js';
 //# sourceMappingURL=total-blocking-time.d.ts.map

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

@@ -11,5 +11,5 @@ declare class NetworkRecords {
      */
     static compute_(devtoolsLog: LH.DevtoolsLog): Promise<Array<LH.Artifacts.NetworkRequest>>;
 }
-import * as LH from "../../types/lh.js";
+import * as LH from '../../types/lh.js';
 //# sourceMappingURL=network-records.d.ts.map

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

@@ -16,7 +16,7 @@ declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
         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";
+import { NetworkNode } from '../lib/dependency-graph/network-node.js';
 declare class PageDependencyGraph {
     /**
      * @param {LH.Artifacts.NetworkRequest} record
@@ -62,15 +62,6 @@ declare class PageDependencyGraph {
      * @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
@@ -82,7 +73,7 @@ declare class PageDependencyGraph {
         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";
+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

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

@@ -12,6 +12,7 @@ import {NetworkRequest} from '../lib/network-request.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {NetworkRecords} from './network-records.js';
 import {NetworkAnalyzer} from '../lib/dependency-graph/simulator/network-analyzer.js';
+import {DocumentUrls} from './document-urls.js';
 
 /** @typedef {import('../lib/dependency-graph/base-node.js').Node} Node */
 /** @typedef {Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>} URLArtifact */
@@ -459,37 +460,6 @@ class PageDependencyGraph {
     });
   }
 
-  /**
-   * 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, networkRecords, processedTrace) {
-    const mainFrameId = processedTrace.mainFrameInfo.frameId;
-
-    /** @type {string|undefined} */
-    let requestedUrl;
-    /** @type {string|undefined} */
-    let mainDocumentUrl;
-    for (const event of devtoolsLog) {
-      if (event.method === 'Page.frameNavigated' && event.params.frame.id === mainFrameId) {
-        const {url} = event.params.frame;
-        // Only set requestedUrl on the first main frame navigation.
-        if (!requestedUrl) requestedUrl = url;
-        mainDocumentUrl = url;
-      }
-    }
-    if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
-
-    const initialRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
-    if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
-
-    return {requestedUrl, mainDocumentUrl};
-  }
-
   /**
    * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -504,8 +474,7 @@ class PageDependencyGraph {
 
     // COMPAT: Backport for pre-10.0 clients that don't pass the URL artifact here (e.g. pubads).
     // Calculates the URL artifact from the processed trace and DT log.
-    const URL = data.URL ||
-      PageDependencyGraph.getDocumentUrls(devtoolsLog, networkRecords, processedTrace);
+    const URL = data.URL || await DocumentUrls.request(data, context);
 
     return PageDependencyGraph.createGraph(processedTrace, networkRecords, URL);
   }

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

@@ -17,5 +17,5 @@ declare class ProcessedNavigation {
      */
     static compute_(traceOrProcessedTrace: LH.Trace | LH.Artifacts.ProcessedTrace, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.ProcessedNavigation>;
 }
-import { ProcessedTrace } from "./processed-trace.js";
+import { ProcessedTrace } from './processed-trace.js';
 //# sourceMappingURL=processed-navigation.d.ts.map

package/core/computed/resource-summary.d.ts

@@ -39,8 +39,8 @@ declare class ResourceSummary {
         budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
     }, context: LH.Artifacts.ComputedContext): Promise<Record<LH.Budget.ResourceType, ResourceEntry>>;
 }
-import { Util } from "../../shared/util.js";
-import { Budget } from "../config/budget.js";
-import { NetworkRequest } from "../lib/network-request.js";
-import { EntityClassification } from "./entity-classification.js";
+import { Util } from '../../shared/util.js';
+import { Budget } from '../config/budget.js';
+import { NetworkRequest } from '../lib/network-request.js';
+import { EntityClassification } from './entity-classification.js';
 //# sourceMappingURL=resource-summary.d.ts.map

package/core/config/default-config.d.ts

@@ -1,5 +1,5 @@
 export default defaultConfig;
 /** @type {LH.Config} */
 declare const defaultConfig: LH.Config;
-import * as LH from "../../types/lh.js";
+import * as LH from '../../types/lh.js';
 //# sourceMappingURL=default-config.d.ts.map

package/core/config/desktop-config.d.ts

@@ -1,5 +1,5 @@
 export default config;
 /** @type {LH.Config} */
 declare const config: LH.Config;
-import * as LH from "../../types/lh.js";
+import * as LH from '../../types/lh.js';
 //# sourceMappingURL=desktop-config.d.ts.map

package/core/gather/base-gatherer.d.ts

@@ -68,5 +68,5 @@ declare class FRGatherer implements LH.Gatherer.GathererInstance, LH.Gatherer.FR
      */
     afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Gatherer.PhaseResultNonPromise>;
 }
-import * as LH from "../../types/lh.js";
+import * as LH from '../../types/lh.js';
 //# sourceMappingURL=base-gatherer.d.ts.map

package/core/gather/driver/execution-context.d.ts

@@ -97,5 +97,5 @@ export class ExecutionContext {
      */
     cacheNativesOnNewDocument(): Promise<void>;
 }
-import * as LH from "../../../types/lh.js";
+import * as LH from '../../../types/lh.js';
 //# sourceMappingURL=execution-context.d.ts.map

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

@@ -76,7 +76,7 @@ export class NetworkMonitor extends NetworkMonitor_base {
      */
     _emitNetworkStatus(): void;
 }
-import { NetworkRecorder } from "../../lib/network-recorder.js";
-import { NetworkRequest } from "../../lib/network-request.js";
+import { NetworkRecorder } from '../../lib/network-recorder.js';
+import { NetworkRequest } from '../../lib/network-request.js';
 export {};
 //# sourceMappingURL=network-monitor.d.ts.map

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

@@ -45,9 +45,10 @@ export class TargetManager extends TargetManager_base {
     /**
      * Returns a listener for all protocol events from session, and augments the
      * event with the sessionId.
+     * @param {LH.Protocol.TargetType} targetType
      * @param {string} sessionId
      */
-    _getProtocolEventListener(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("puppeteer-core").ProtocolMapping.Events>(method: EventName, params: import("../../../types/protocol.js").default.RawEventMessageRecord[EventName]["params"]) => void;
     /**
      * @return {Promise<void>}
      */