lighthouse 10.1.1-dev.20230423 → 10.1.1-dev.20230425

package/core/audits/predictive-perf.js

@@ -11,6 +11,8 @@ import {LanternFirstMeaningfulPaint} from '../computed/metrics/lantern-first-mea
 import {LanternInteractive} from '../computed/metrics/lantern-interactive.js';
 import {LanternSpeedIndex} from '../computed/metrics/lantern-speed-index.js';
 import {LanternLargestContentfulPaint} from '../computed/metrics/lantern-largest-contentful-paint.js';
+import {TimingSummary} from '../computed/metrics/timing-summary.js';
+import {defaultSettings} from '../config/constants.js';
 
 // Parameters (in ms) for log-normal CDF scoring. To see the curve:
 //   https://www.desmos.com/calculator/bksgkihhj8
@@ -47,8 +49,7 @@ class PredictivePerf extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
     /** @type {LH.Config.Settings} */
-    // @ts-expect-error - TODO(bckenny): allow optional `throttling` settings
-    const settings = {}; // Use default settings.
+    const settings = JSON.parse(JSON.stringify(defaultSettings)); // Use default settings.
     const computationData = {trace, devtoolsLog, gatherContext, settings, URL};
     const fcp = await LanternFirstContentfulPaint.request(computationData, context);
     const fmp = await LanternFirstMeaningfulPaint.request(computationData, context);
@@ -56,6 +57,8 @@ class PredictivePerf extends Audit {
     const si = await LanternSpeedIndex.request(computationData, context);
     const lcp = await LanternLargestContentfulPaint.request(computationData, context);
 
+    const timingSummary = await TimingSummary.request(computationData, context);
+
     const values = {
       roughEstimateOfFCP: fcp.timing,
       optimisticFCP: fcp.optimisticEstimate.timeInMs,
@@ -76,6 +79,10 @@ class PredictivePerf extends Audit {
       roughEstimateOfLCP: lcp.timing,
       optimisticLCP: lcp.optimisticEstimate.timeInMs,
       pessimisticLCP: lcp.pessimisticEstimate.timeInMs,
+
+      roughEstimateOfTTFB: timingSummary.metrics.timeToFirstByte,
+      roughEstimateOfLCPLoadStart: timingSummary.metrics.lcpLoadStart,
+      roughEstimateOfLCPLoadEnd: timingSummary.metrics.lcpLoadEnd,
     };
 
     const score = Audit.computeLogNormalScore(

package/core/audits/prioritize-lcp-image.d.ts

@@ -42,16 +42,6 @@ declare class PrioritizeLcpImage extends Audit {
         lcpNodeToPreload?: import("../lib/dependency-graph/network-node.js").NetworkNode | undefined;
         initiatorPath?: InitiatorPath | undefined;
     };
-    /**
-     * Match the LCP event with the paint event to get the request of the image actually painted.
-     * This could differ from the `ImageElement` associated with the nodeId if e.g. the LCP
-     * was a pseudo-element associated with a node containing a smaller background-image.
-     * @param {LH.Trace} trace
-     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-     * @param {Array<NetworkRequest>} networkRecords
-     * @return {NetworkRequest|undefined}
-     */
-    static getLcpRecord(trace: LH.Trace, processedNavigation: LH.Artifacts.ProcessedNavigation, networkRecords: Array<NetworkRequest>): NetworkRequest | undefined;
     /**
      * Computes the estimated effect of preloading the LCP image.
      * @param {LH.Artifacts.TraceElement} lcpElement
@@ -81,5 +71,4 @@ export namespace UIStrings {
 }
 import { Audit } from "./audit.js";
 import { NetworkRequest } from "../lib/network-request.js";
-import { ProcessedNavigation } from "../computed/processed-navigation.js";
 //# sourceMappingURL=prioritize-lcp-image.d.ts.map

package/core/audits/prioritize-lcp-image.js

@@ -11,8 +11,7 @@ import {MainResource} from '../computed/main-resource.js';
 import {LanternLargestContentfulPaint} from '../computed/metrics/lantern-largest-contentful-paint.js';
 import {LoadSimulator} from '../computed/load-simulator.js';
 import {ByteEfficiencyAudit} from './byte-efficiency/byte-efficiency-audit.js';
-import {ProcessedNavigation} from '../computed/processed-navigation.js';
-import {NetworkRecords} from '../computed/network-records.js';
+import {LCPImageRecord} from '../computed/lcp-image-record.js';
 
 const UIStrings = {
   /** Title of a lighthouse audit that tells a user to preload an image in order to improve their LCP time. */
@@ -140,55 +139,6 @@ class PrioritizeLcpImage extends Audit {
     };
   }
 
-  /**
-   * Match the LCP event with the paint event to get the request of the image actually painted.
-   * This could differ from the `ImageElement` associated with the nodeId if e.g. the LCP
-   * was a pseudo-element associated with a node containing a smaller background-image.
-   * @param {LH.Trace} trace
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @param {Array<NetworkRequest>} networkRecords
-   * @return {NetworkRequest|undefined}
-   */
-  static getLcpRecord(trace, processedNavigation, networkRecords) {
-    // Use main-frame-only LCP to match the metric value.
-    const lcpEvent = processedNavigation.largestContentfulPaintEvt;
-    if (!lcpEvent) return;
-
-    const lcpImagePaintEvent = trace.traceEvents.filter(e => {
-      return e.name === 'LargestImagePaint::Candidate' &&
-          e.args.frame === lcpEvent.args.frame &&
-          e.args.data?.DOMNodeId === lcpEvent.args.data?.nodeId &&
-          e.args.data?.size === lcpEvent.args.data?.size;
-    // Get last candidate, in case there was more than one.
-    }).sort((a, b) => b.ts - a.ts)[0];
-
-    const lcpUrl = lcpImagePaintEvent?.args.data?.imageUrl;
-    if (!lcpUrl) return;
-
-    const candidates = networkRecords.filter(record => {
-      return record.url === lcpUrl &&
-          record.finished &&
-          // Same frame as LCP trace event.
-          record.frameId === lcpImagePaintEvent.args.frame &&
-          record.networkRequestTime < (processedNavigation.timestamps.largestContentfulPaint || 0);
-    }).map(record => {
-      // Follow any redirects to find the real image request.
-      while (record.redirectDestination) {
-        record = record.redirectDestination;
-      }
-      return record;
-    }).filter(record => {
-      // Don't select if also loaded by some other means (xhr, etc). `resourceType`
-      // isn't set on redirect _sources_, so have to check after following redirects.
-      return record.resourceType === 'Image';
-    });
-
-    // If there are still multiple candidates, at this point it appears the page
-    // simply made multiple requests for the image. The first loaded is the best
-    // guess of the request that made the image available for use.
-    return candidates.sort((a, b) => a.networkEndTime - b.networkEndTime)[0];
-  }
-
   /**
    * Computes the estimated effect of preloading the LCP image.
    * @param {LH.Artifacts.TraceElement} lcpElement
@@ -297,17 +247,15 @@ class PrioritizeLcpImage extends Audit {
       return {score: null, notApplicable: true};
     }
 
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const processedNavigation = await ProcessedNavigation.request(trace, context);
     const mainResource = await MainResource.request({devtoolsLog, URL}, context);
     const lanternLCP = await LanternLargestContentfulPaint.request(metricData, context);
     const simulator = await LoadSimulator.request({devtoolsLog, settings}, context);
 
-    const lcpRecord = PrioritizeLcpImage.getLcpRecord(trace, processedNavigation, networkRecords);
+    const lcpImageRecord = await LCPImageRecord.request({trace, devtoolsLog}, context);
     const graph = lanternLCP.pessimisticGraph;
     // Note: if moving to LCPAllFrames, mainResource would need to be the LCP frame's main resource.
     const {lcpNodeToPreload, initiatorPath} = PrioritizeLcpImage.getLCPNodeToPreload(mainResource,
-        graph, lcpRecord);
+        graph, lcpImageRecord);
 
     const {results, wastedMs} =
       PrioritizeLcpImage.computeWasteWithGraph(lcpElement, lcpNodeToPreload, graph, simulator);

package/core/computed/document-urls.d.ts

@@ -0,0 +1,32 @@
+export { DocumentUrlsComputed as DocumentUrls };
+declare const DocumentUrlsComputed: typeof DocumentUrls & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<{
+        requestedUrl: string;
+        mainDocumentUrl: string;
+    }>;
+};
+/**
+ * @fileoverview Compute the navigation specific URLs `requestedUrl` and `mainDocumentUrl` in situations where
+ * the `URL` artifact is not present. This is not a drop-in replacement for `URL` but can be helpful in situations
+ * where getting the `URL` artifact is difficult.
+ */
+declare class DocumentUrls {
+    /**
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{requestedUrl: string, mainDocumentUrl: string}>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<{
+        requestedUrl: string;
+        mainDocumentUrl: string;
+    }>;
+}
+//# sourceMappingURL=document-urls.d.ts.map

package/core/computed/document-urls.js

@@ -0,0 +1,53 @@
+/**
+ * @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 {NetworkAnalyzer} from '../lib/dependency-graph/simulator/network-analyzer.js';
+import {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkRecords} from './network-records.js';
+import {ProcessedTrace} from './processed-trace.js';
+
+/**
+ * @fileoverview Compute the navigation specific URLs `requestedUrl` and `mainDocumentUrl` in situations where
+ * the `URL` artifact is not present. This is not a drop-in replacement for `URL` but can be helpful in situations
+ * where getting the `URL` artifact is difficult.
+ */
+
+class DocumentUrls {
+  /**
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<{requestedUrl: string, mainDocumentUrl: string}>}
+   */
+  static async compute_(data, context) {
+    const processedTrace = await ProcessedTrace.request(data.trace, context);
+    const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
+
+    const mainFrameId = processedTrace.mainFrameInfo.frameId;
+
+    /** @type {string|undefined} */
+    let requestedUrl;
+    /** @type {string|undefined} */
+    let mainDocumentUrl;
+    for (const event of data.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};
+  }
+}
+
+const DocumentUrlsComputed = makeComputedArtifact(DocumentUrls, ['devtoolsLog', 'trace']);
+export {DocumentUrlsComputed as DocumentUrls};
+

package/core/computed/entity-classification.js

@@ -85,7 +85,6 @@ class EntityClassification {
      */
     function isFirstParty(url) {
       const entityUrl = entityByUrl.get(url);
-      if (!entityUrl) throw new Error('A url not in devtoolsLog was used for first-party check.');
       return entityUrl === firstParty;
     }
 

package/core/computed/lcp-image-record.d.ts

@@ -0,0 +1,26 @@
+export { LCPImageRecordComputed as LCPImageRecord };
+declare const LCPImageRecordComputed: typeof LCPImageRecord & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/network-request.js").NetworkRequest | undefined>;
+};
+/**
+ * @fileoverview Match the LCP event with the paint event to get the request of the image actually painted.
+ * This could differ from the `ImageElement` associated with the nodeId if e.g. the LCP
+ * was a pseudo-element associated with a node containing a smaller background-image.
+ */
+declare class LCPImageRecord {
+    /**
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.NetworkRequest|undefined>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkRequest | undefined>;
+}
+//# sourceMappingURL=lcp-image-record.d.ts.map

package/core/computed/lcp-image-record.js

@@ -0,0 +1,74 @@
+/**
+ * @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 {NetworkRecords} from './network-records.js';
+import {ProcessedNavigation} from './processed-navigation.js';
+import {LighthouseError} from '../lib/lh-error.js';
+
+/**
+ * @fileoverview Match the LCP event with the paint event to get the request of the image actually painted.
+ * This could differ from the `ImageElement` associated with the nodeId if e.g. the LCP
+ * was a pseudo-element associated with a node containing a smaller background-image.
+ */
+
+class LCPImageRecord {
+  /**
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.NetworkRequest|undefined>}
+   */
+  static async compute_(data, context) {
+    const {trace, devtoolsLog} = data;
+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+    const processedNavigation = await ProcessedNavigation.request(trace, context);
+    if (processedNavigation.timings.largestContentfulPaint === undefined) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP);
+    }
+
+    // Use main-frame-only LCP to match the metric value.
+    const lcpEvent = processedNavigation.largestContentfulPaintEvt;
+    if (!lcpEvent) return;
+
+    const lcpImagePaintEvent = trace.traceEvents.filter(e => {
+      return e.name === 'LargestImagePaint::Candidate' &&
+          e.args.frame === lcpEvent.args.frame &&
+          e.args.data?.DOMNodeId === lcpEvent.args.data?.nodeId &&
+          e.args.data?.size === lcpEvent.args.data?.size;
+    // Get last candidate, in case there was more than one.
+    }).sort((a, b) => b.ts - a.ts)[0];
+
+    const lcpUrl = lcpImagePaintEvent?.args.data?.imageUrl;
+    if (!lcpUrl) return;
+
+    const candidates = networkRecords.filter(record => {
+      return record.url === lcpUrl &&
+          record.finished &&
+          // Same frame as LCP trace event.
+          record.frameId === lcpImagePaintEvent.args.frame &&
+          record.networkRequestTime < (processedNavigation.timestamps.largestContentfulPaint || 0);
+    }).map(record => {
+      // Follow any redirects to find the real image request.
+      while (record.redirectDestination) {
+        record = record.redirectDestination;
+      }
+      return record;
+    }).filter(record => {
+      // Don't select if also loaded by some other means (xhr, etc). `resourceType`
+      // isn't set on redirect _sources_, so have to check after following redirects.
+      return record.resourceType === 'Image';
+    });
+
+    // If there are still multiple candidates, at this point it appears the page
+    // simply made multiple requests for the image. The first loaded is the best
+    // guess of the request that made the image available for use.
+    return candidates.sort((a, b) => a.networkEndTime - b.networkEndTime)[0];
+  }
+}
+
+const LCPImageRecordComputed = makeComputedArtifact(LCPImageRecord, ['devtoolsLog', 'trace']);
+export {LCPImageRecordComputed as LCPImageRecord};
+

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

@@ -5,6 +5,12 @@ declare const FirstContentfulPaintComputed: typeof FirstContentfulPaint & {
     }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
 };
 declare class FirstContentfulPaint 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>}

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

@@ -5,6 +5,12 @@ 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>}

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

@@ -51,6 +51,12 @@ 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>}

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

@@ -5,6 +5,12 @@ 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>}

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,6 +5,12 @@ 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>}

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

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/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";
 //# 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";
 //# sourceMappingURL=total-blocking-time.d.ts.map

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

@@ -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

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/gather/navigation-runner.js

@@ -353,7 +353,7 @@ async function navigationGather(page, requestor, options = {}) {
       // therefore we connect to the browser in the gatherFn callback.
       if (!page) {
         const {hostname = DEFAULT_HOSTNAME, port = DEFAULT_PORT} = flags;
-        lhBrowser = await puppeteer.connect({browserURL: `http://${hostname}:${port}`});
+        lhBrowser = await puppeteer.connect({browserURL: `http://${hostname}:${port}`, defaultViewport: null});
         lhPage = await lhBrowser.newPage();
         page = lhPage;
       }

package/dist/report/bundle.esm.js

@@ -221,6 +221,8 @@ class Util {
 
     const MAX_LENGTH = 64;
     if (parsedUrl.protocol !== 'data:') {
+      // Even non-data uris can be 10k characters long.
+      name = name.slice(0, 200);
       // Always elide hexadecimal hash
       name = name.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g, `$1${ELLIPSIS}`);
       // Also elide other hash-like mixed-case strings

package/dist/report/flow.js

@@ -14,7 +14,7 @@
    * 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.
-   */const oe="…",re={PASS:{label:"pass",minScore:.9},AVERAGE:{label:"average",minScore:.5},FAIL:{label:"fail"},ERROR:{label:"error"}},se=["com","co","gov","edu","ac","org","go","gob","or","net","in","ne","nic","gouv","web","spb","blog","jus","kiev","mil","wi","qc","ca","bel","on"];class le{static get RATINGS(){return re}static get PASS_THRESHOLD(){return.9}static get MS_DISPLAY_VALUE(){return"%10d ms"}static getFinalDisplayedUrl(e){if(e.finalDisplayedUrl)return e.finalDisplayedUrl;if(e.finalUrl)return e.finalUrl;throw new Error("Could not determine final displayed URL")}static getMainDocumentUrl(e){return e.mainDocumentUrl||e.finalUrl}static getFullPageScreenshot(e){if(e.fullPageScreenshot)return e.fullPageScreenshot;return e.audits["full-page-screenshot"]?.details}static splitMarkdownCodeSpans(e){const a=[],n=e.split(/`(.*?)`/g);for(let e=0;e<n.length;e++){const t=n[e];if(!t)continue;const i=e%2!=0;a.push({isCode:i,text:t})}return a}static splitMarkdownLink(e){const a=[],n=e.split(/\[([^\]]+?)\]\((https?:\/\/.*?)\)/g);for(;n.length;){const[e,t,i]=n.splice(0,3);e&&a.push({isLink:!1,text:e}),t&&i&&a.push({isLink:!0,text:t,linkHref:i})}return a}static truncate(e,a,n="…"){if(e.length<=a)return e;const t=new Intl.Segmenter(void 0,{granularity:"grapheme"}).segment(e)[Symbol.iterator]();let i=0;for(let o=0;o<=a-n.length;o++){const a=t.next();if(a.done)return e;i=a.value.index}for(let a=0;a<n.length;a++)if(t.next().done)return e;return e.slice(0,i)+n}static getURLDisplayName(e,a){const n=void 0!==(a=a||{numPathParts:void 0,preserveQuery:void 0,preserveHost:void 0}).numPathParts?a.numPathParts:2,t=void 0===a.preserveQuery||a.preserveQuery,i=a.preserveHost||!1;let o;if("about:"===e.protocol||"data:"===e.protocol)o=e.href;else{o=e.pathname;const a=o.split("/").filter((e=>e.length));n&&a.length>n&&(o=oe+a.slice(-1*n).join("/")),i&&(o=`${e.host}/${o.replace(/^\//,"")}`),t&&(o=`${o}${e.search}`)}if("data:"!==e.protocol&&(o=o.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g,"$1…"),o=o.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,"$1…"),o=o.replace(/(\d{3})\d{6,}/g,"$1…"),o=o.replace(/\u2026+/g,oe),o.length>64&&o.includes("?")&&(o=o.replace(/\?([^=]*)(=)?.*/,"?$1$2…"),o.length>64&&(o=o.replace(/\?.*/,"?…")))),o.length>64){const e=o.lastIndexOf(".");o=e>=0?o.slice(0,63-(o.length-e))+`…${o.slice(e)}`:o.slice(0,63)+oe}return o}static parseURL(e){const a=new URL(e);return{file:le.getURLDisplayName(a),hostname:a.hostname,origin:a.origin}}static createOrReturnURL(e){return e instanceof URL?e:new URL(e)}static getTld(e){const a=e.split(".").slice(-2);return se.includes(a[0])?`.${a.join(".")}`:`.${a[a.length-1]}`}static getRootDomain(e){const a=le.createOrReturnURL(e).hostname,n=le.getTld(a).split(".");return a.split(".").slice(-n.length).join(".")}static filterRelevantLines(e,a,n){if(0===a.length)return e.slice(0,2*n+1);const t=new Set;return(a=a.sort(((e,a)=>(e.lineNumber||0)-(a.lineNumber||0)))).forEach((({lineNumber:e})=>{let a=e-n,i=e+n;for(;a<1;)a++,i++;t.has(a-3-1)&&(a-=3);for(let e=a;e<=i;e++){const a=e;t.add(a)}})),e.filter((e=>t.has(e.lineNumber)))}}
+   */const oe="…",re={PASS:{label:"pass",minScore:.9},AVERAGE:{label:"average",minScore:.5},FAIL:{label:"fail"},ERROR:{label:"error"}},se=["com","co","gov","edu","ac","org","go","gob","or","net","in","ne","nic","gouv","web","spb","blog","jus","kiev","mil","wi","qc","ca","bel","on"];class le{static get RATINGS(){return re}static get PASS_THRESHOLD(){return.9}static get MS_DISPLAY_VALUE(){return"%10d ms"}static getFinalDisplayedUrl(e){if(e.finalDisplayedUrl)return e.finalDisplayedUrl;if(e.finalUrl)return e.finalUrl;throw new Error("Could not determine final displayed URL")}static getMainDocumentUrl(e){return e.mainDocumentUrl||e.finalUrl}static getFullPageScreenshot(e){if(e.fullPageScreenshot)return e.fullPageScreenshot;return e.audits["full-page-screenshot"]?.details}static splitMarkdownCodeSpans(e){const a=[],n=e.split(/`(.*?)`/g);for(let e=0;e<n.length;e++){const t=n[e];if(!t)continue;const i=e%2!=0;a.push({isCode:i,text:t})}return a}static splitMarkdownLink(e){const a=[],n=e.split(/\[([^\]]+?)\]\((https?:\/\/.*?)\)/g);for(;n.length;){const[e,t,i]=n.splice(0,3);e&&a.push({isLink:!1,text:e}),t&&i&&a.push({isLink:!0,text:t,linkHref:i})}return a}static truncate(e,a,n="…"){if(e.length<=a)return e;const t=new Intl.Segmenter(void 0,{granularity:"grapheme"}).segment(e)[Symbol.iterator]();let i=0;for(let o=0;o<=a-n.length;o++){const a=t.next();if(a.done)return e;i=a.value.index}for(let a=0;a<n.length;a++)if(t.next().done)return e;return e.slice(0,i)+n}static getURLDisplayName(e,a){const n=void 0!==(a=a||{numPathParts:void 0,preserveQuery:void 0,preserveHost:void 0}).numPathParts?a.numPathParts:2,t=void 0===a.preserveQuery||a.preserveQuery,i=a.preserveHost||!1;let o;if("about:"===e.protocol||"data:"===e.protocol)o=e.href;else{o=e.pathname;const a=o.split("/").filter((e=>e.length));n&&a.length>n&&(o=oe+a.slice(-1*n).join("/")),i&&(o=`${e.host}/${o.replace(/^\//,"")}`),t&&(o=`${o}${e.search}`)}if("data:"!==e.protocol&&(o=o.slice(0,200),o=o.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g,"$1…"),o=o.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,"$1…"),o=o.replace(/(\d{3})\d{6,}/g,"$1…"),o=o.replace(/\u2026+/g,oe),o.length>64&&o.includes("?")&&(o=o.replace(/\?([^=]*)(=)?.*/,"?$1$2…"),o.length>64&&(o=o.replace(/\?.*/,"?…")))),o.length>64){const e=o.lastIndexOf(".");o=e>=0?o.slice(0,63-(o.length-e))+`…${o.slice(e)}`:o.slice(0,63)+oe}return o}static parseURL(e){const a=new URL(e);return{file:le.getURLDisplayName(a),hostname:a.hostname,origin:a.origin}}static createOrReturnURL(e){return e instanceof URL?e:new URL(e)}static getTld(e){const a=e.split(".").slice(-2);return se.includes(a[0])?`.${a.join(".")}`:`.${a[a.length-1]}`}static getRootDomain(e){const a=le.createOrReturnURL(e).hostname,n=le.getTld(a).split(".");return a.split(".").slice(-n.length).join(".")}static filterRelevantLines(e,a,n){if(0===a.length)return e.slice(0,2*n+1);const t=new Set;return(a=a.sort(((e,a)=>(e.lineNumber||0)-(a.lineNumber||0)))).forEach((({lineNumber:e})=>{let a=e-n,i=e+n;for(;a<1;)a++,i++;t.has(a-3-1)&&(a-=3);for(let e=a;e<=i;e++){const a=e;t.add(a)}})),e.filter((e=>t.has(e.lineNumber)))}}
 /**
    * @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

package/dist/report/standalone.js

@@ -14,7 +14,7 @@
    * 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.
-   */const e="…",t={PASS:{label:"pass",minScore:.9},AVERAGE:{label:"average",minScore:.5},FAIL:{label:"fail"},ERROR:{label:"error"}},n=["com","co","gov","edu","ac","org","go","gob","or","net","in","ne","nic","gouv","web","spb","blog","jus","kiev","mil","wi","qc","ca","bel","on"];class r{static get RATINGS(){return t}static get PASS_THRESHOLD(){return.9}static get MS_DISPLAY_VALUE(){return"%10d ms"}static getFinalDisplayedUrl(e){if(e.finalDisplayedUrl)return e.finalDisplayedUrl;if(e.finalUrl)return e.finalUrl;throw new Error("Could not determine final displayed URL")}static getMainDocumentUrl(e){return e.mainDocumentUrl||e.finalUrl}static getFullPageScreenshot(e){if(e.fullPageScreenshot)return e.fullPageScreenshot;return e.audits["full-page-screenshot"]?.details}static splitMarkdownCodeSpans(e){const t=[],n=e.split(/`(.*?)`/g);for(let e=0;e<n.length;e++){const r=n[e];if(!r)continue;const o=e%2!=0;t.push({isCode:o,text:r})}return t}static splitMarkdownLink(e){const t=[],n=e.split(/\[([^\]]+?)\]\((https?:\/\/.*?)\)/g);for(;n.length;){const[e,r,o]=n.splice(0,3);e&&t.push({isLink:!1,text:e}),r&&o&&t.push({isLink:!0,text:r,linkHref:o})}return t}static truncate(e,t,n="…"){if(e.length<=t)return e;const r=new Intl.Segmenter(void 0,{granularity:"grapheme"}).segment(e)[Symbol.iterator]();let o=0;for(let i=0;i<=t-n.length;i++){const t=r.next();if(t.done)return e;o=t.value.index}for(let t=0;t<n.length;t++)if(r.next().done)return e;return e.slice(0,o)+n}static getURLDisplayName(t,n){const r=void 0!==(n=n||{numPathParts:void 0,preserveQuery:void 0,preserveHost:void 0}).numPathParts?n.numPathParts:2,o=void 0===n.preserveQuery||n.preserveQuery,i=n.preserveHost||!1;let a;if("about:"===t.protocol||"data:"===t.protocol)a=t.href;else{a=t.pathname;const n=a.split("/").filter((e=>e.length));r&&n.length>r&&(a=e+n.slice(-1*r).join("/")),i&&(a=`${t.host}/${a.replace(/^\//,"")}`),o&&(a=`${a}${t.search}`)}if("data:"!==t.protocol&&(a=a.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g,"$1…"),a=a.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,"$1…"),a=a.replace(/(\d{3})\d{6,}/g,"$1…"),a=a.replace(/\u2026+/g,e),a.length>64&&a.includes("?")&&(a=a.replace(/\?([^=]*)(=)?.*/,"?$1$2…"),a.length>64&&(a=a.replace(/\?.*/,"?…")))),a.length>64){const t=a.lastIndexOf(".");a=t>=0?a.slice(0,63-(a.length-t))+`…${a.slice(t)}`:a.slice(0,63)+e}return a}static parseURL(e){const t=new URL(e);return{file:r.getURLDisplayName(t),hostname:t.hostname,origin:t.origin}}static createOrReturnURL(e){return e instanceof URL?e:new URL(e)}static getTld(e){const t=e.split(".").slice(-2);return n.includes(t[0])?`.${t.join(".")}`:`.${t[t.length-1]}`}static getRootDomain(e){const t=r.createOrReturnURL(e).hostname,n=r.getTld(t).split(".");return t.split(".").slice(-n.length).join(".")}static filterRelevantLines(e,t,n){if(0===t.length)return e.slice(0,2*n+1);const r=new Set;return(t=t.sort(((e,t)=>(e.lineNumber||0)-(t.lineNumber||0)))).forEach((({lineNumber:e})=>{let t=e-n,o=e+n;for(;t<1;)t++,o++;r.has(t-3-1)&&(t-=3);for(let e=t;e<=o;e++){const t=e;r.add(t)}})),e.filter((e=>r.has(e.lineNumber)))}}
+   */const e="…",t={PASS:{label:"pass",minScore:.9},AVERAGE:{label:"average",minScore:.5},FAIL:{label:"fail"},ERROR:{label:"error"}},n=["com","co","gov","edu","ac","org","go","gob","or","net","in","ne","nic","gouv","web","spb","blog","jus","kiev","mil","wi","qc","ca","bel","on"];class r{static get RATINGS(){return t}static get PASS_THRESHOLD(){return.9}static get MS_DISPLAY_VALUE(){return"%10d ms"}static getFinalDisplayedUrl(e){if(e.finalDisplayedUrl)return e.finalDisplayedUrl;if(e.finalUrl)return e.finalUrl;throw new Error("Could not determine final displayed URL")}static getMainDocumentUrl(e){return e.mainDocumentUrl||e.finalUrl}static getFullPageScreenshot(e){if(e.fullPageScreenshot)return e.fullPageScreenshot;return e.audits["full-page-screenshot"]?.details}static splitMarkdownCodeSpans(e){const t=[],n=e.split(/`(.*?)`/g);for(let e=0;e<n.length;e++){const r=n[e];if(!r)continue;const o=e%2!=0;t.push({isCode:o,text:r})}return t}static splitMarkdownLink(e){const t=[],n=e.split(/\[([^\]]+?)\]\((https?:\/\/.*?)\)/g);for(;n.length;){const[e,r,o]=n.splice(0,3);e&&t.push({isLink:!1,text:e}),r&&o&&t.push({isLink:!0,text:r,linkHref:o})}return t}static truncate(e,t,n="…"){if(e.length<=t)return e;const r=new Intl.Segmenter(void 0,{granularity:"grapheme"}).segment(e)[Symbol.iterator]();let o=0;for(let i=0;i<=t-n.length;i++){const t=r.next();if(t.done)return e;o=t.value.index}for(let t=0;t<n.length;t++)if(r.next().done)return e;return e.slice(0,o)+n}static getURLDisplayName(t,n){const r=void 0!==(n=n||{numPathParts:void 0,preserveQuery:void 0,preserveHost:void 0}).numPathParts?n.numPathParts:2,o=void 0===n.preserveQuery||n.preserveQuery,i=n.preserveHost||!1;let a;if("about:"===t.protocol||"data:"===t.protocol)a=t.href;else{a=t.pathname;const n=a.split("/").filter((e=>e.length));r&&n.length>r&&(a=e+n.slice(-1*r).join("/")),i&&(a=`${t.host}/${a.replace(/^\//,"")}`),o&&(a=`${a}${t.search}`)}if("data:"!==t.protocol&&(a=a.slice(0,200),a=a.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g,"$1…"),a=a.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,"$1…"),a=a.replace(/(\d{3})\d{6,}/g,"$1…"),a=a.replace(/\u2026+/g,e),a.length>64&&a.includes("?")&&(a=a.replace(/\?([^=]*)(=)?.*/,"?$1$2…"),a.length>64&&(a=a.replace(/\?.*/,"?…")))),a.length>64){const t=a.lastIndexOf(".");a=t>=0?a.slice(0,63-(a.length-t))+`…${a.slice(t)}`:a.slice(0,63)+e}return a}static parseURL(e){const t=new URL(e);return{file:r.getURLDisplayName(t),hostname:t.hostname,origin:t.origin}}static createOrReturnURL(e){return e instanceof URL?e:new URL(e)}static getTld(e){const t=e.split(".").slice(-2);return n.includes(t[0])?`.${t.join(".")}`:`.${t[t.length-1]}`}static getRootDomain(e){const t=r.createOrReturnURL(e).hostname,n=r.getTld(t).split(".");return t.split(".").slice(-n.length).join(".")}static filterRelevantLines(e,t,n){if(0===t.length)return e.slice(0,2*n+1);const r=new Set;return(t=t.sort(((e,t)=>(e.lineNumber||0)-(t.lineNumber||0)))).forEach((({lineNumber:e})=>{let t=e-n,o=e+n;for(;t<1;)t++,o++;r.has(t-3-1)&&(t-=3);for(let e=t;e<=o;e++){const t=e;r.add(t)}})),e.filter((e=>r.has(e.lineNumber)))}}
 /**
    * @license
    * Copyright 2017 The Lighthouse Authors. All Rights Reserved.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "10.1.1-dev.20230423",
+  "version": "10.1.1-dev.20230425",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -113,6 +113,7 @@
     "@types/chrome": "^0.0.154",
     "@types/configstore": "^4.0.0",
     "@types/cpy": "^5.1.0",
+    "@types/debug": "^4.1.7",
     "@types/eslint": "^8.2.1",
     "@types/estree": "^0.0.50",
     "@types/gh-pages": "^2.0.0",
@@ -168,7 +169,7 @@
     "pako": "^2.0.3",
     "preact": "^10.7.2",
     "pretty-json-stringify": "^0.0.2",
-    "puppeteer": "^19.6.0",
+    "puppeteer": "^19.11.0",
     "resolve": "^1.20.0",
     "rollup": "^2.52.7",
     "rollup-plugin-node-resolve": "^5.2.0",
@@ -204,7 +205,7 @@
     "open": "^8.4.0",
     "parse-cache-control": "1.0.1",
     "ps-list": "^8.0.0",
-    "puppeteer-core": "^19.6.0",
+    "puppeteer-core": "^19.11.0",
     "robots-parser": "^3.0.0",
     "semver": "^5.3.0",
     "speedline-core": "^1.4.3",

package/shared/util.js

@@ -221,6 +221,8 @@ class Util {
 
     const MAX_LENGTH = 64;
     if (parsedUrl.protocol !== 'data:') {
+      // Even non-data uris can be 10k characters long.
+      name = name.slice(0, 200);
       // Always elide hexadecimal hash
       name = name.replace(/([a-f0-9]{7})[a-f0-9]{13}[a-f0-9]*/g, `$1${ELLIPSIS}`);
       // Also elide other hash-like mixed-case strings

package/types/artifacts.d.ts

@@ -789,6 +789,10 @@ declare module Artifacts {
     largestContentfulPaintTs: number | undefined;
     largestContentfulPaintAllFrames: number | undefined;
     largestContentfulPaintAllFramesTs: number | undefined;
+    timeToFirstByte: number | undefined;
+    timeToFirstByteTs: number | undefined;
+    lcpLoadStart: number | undefined;
+    lcpLoadEnd: number | undefined;
     interactive: number | undefined;
     interactiveTs: number | undefined;
     speedIndex: number | undefined;