lighthouse 9.5.0-dev.20220329 → 9.5.0-dev.20220401

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

@@ -8,13 +8,14 @@
 const makeComputedArtifact = require('./computed-artifact.js');
 const NetworkNode = require('../lib/dependency-graph/network-node.js');
 const CPUNode = require('../lib/dependency-graph/cpu-node.js');
-const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 const TracingProcessor = require('../lib/tracehouse/trace-processor.js');
 const NetworkRequest = require('../lib/network-request.js');
 const ProcessedTrace = require('./processed-trace.js');
 const NetworkRecords = require('./network-records.js');
+const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 
 /** @typedef {import('../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {Omit<LH.Artifacts['URL'], 'initialUrl'|'finalUrl'>} URLArtifact */
 
 // Shorter tasks have negligible impact on simulation results.
 const SIGNIFICANT_DUR_THRESHOLD_MS = 10;
@@ -388,37 +389,24 @@ class PageDependencyGraph {
   /**
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {URLArtifact} URL
    * @return {Node}
    */
-  static createGraph(processedTrace, networkRecords) {
+  static createGraph(processedTrace, networkRecords, URL) {
     const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
     const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
+    const {requestedUrl, mainDocumentUrl} = URL;
+    if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');
 
-    // TODO: Remove this usage of `findMainDocument` and create a new function to get the first document request.
-    // https://github.com/GoogleChrome/lighthouse/issues/8984
-    //
-    // The main document request is the earliest network request *of type document*.
-    // This will be different from the root request when there are server redirects.
-    const mainDocumentRequest = NetworkAnalyzer.findMainDocument(networkRecords);
-    const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
-    if (!mainDocumentNode) {
-      // mainDocumentNode should always be found.
-      throw new Error('mainDocumentNode not found.');
-    }
+    const rootRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+    if (!rootRequest) throw new Error('rootRequest not found');
+    const rootNode = networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
+    if (!rootNode) throw new Error('rootNode not found');
 
-    // The root request is the earliest request in the main document redirect chain.
-    // Will be undefined if there were no redirects.
-    const rootRequest = mainDocumentNode.record.redirects?.[0];
-
-    let rootNode;
-    if (rootRequest) {
-      // rootNode should always be found.
-      rootNode = rootRequest && networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
-      if (!rootNode) throw new Error('rootNode not found');
-    } else {
-      // Use main document as root if there were no redirects.
-      rootNode = mainDocumentNode;
-    }
+    const mainDocumentRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, mainDocumentUrl);
+    if (!mainDocumentRequest) throw new Error('mainDocumentRequest not found');
+    const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
+    if (!mainDocumentNode) throw new Error('mainDocumentNode not found');
 
     PageDependencyGraph.linkNetworkNodes(rootNode, networkNodeOutput);
     PageDependencyGraph.linkCPUNodes(rootNode, networkNodeOutput, cpuNodes);
@@ -464,23 +452,58 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+   * 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.mainFrameIds.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
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
-    const trace = data.trace;
-    const devtoolsLog = data.devtoolsLog;
+    const {trace, devtoolsLog} = data;
     const [processedTrace, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    return PageDependencyGraph.createGraph(processedTrace, networkRecords);
+    // 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);
+
+    return PageDependencyGraph.createGraph(processedTrace, networkRecords, URL);
   }
 }
 
-module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace']);
+module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL']);
 
 /**
  * @typedef {Object} NetworkNodeOutput

package/lighthouse-core/fraggle-rock/gather/runner-helpers.js

@@ -15,7 +15,6 @@
  * @property {LH.Gatherer.GatherMode} gatherMode
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
  * @property {LH.Config.Settings} settings
- * @property {string} url
  */
 
 /** @typedef {Record<string, Promise<any>>} IntermediateArtifacts */
@@ -75,7 +74,6 @@ async function collectPhaseArtifacts(options) {
     gatherMode,
     computedCache,
     settings,
-    url,
   } = options;
   const priorPhase = phaseToPriorPhase[phase];
   const priorPhaseArtifacts = (priorPhase && artifactState[priorPhase]) || {};
@@ -92,7 +90,6 @@ async function collectPhaseArtifacts(options) {
         : /** @type {Dependencies} */ ({});
 
       return gatherer[phase]({
-        url,
         gatherMode,
         driver,
         baseArtifacts,

package/lighthouse-core/fraggle-rock/gather/snapshot-runner.js

@@ -46,7 +46,6 @@ async function snapshotGather(options) {
       const artifactDefinitions = config.artifacts || [];
       const artifactState = getEmptyArtifactState();
       await collectPhaseArtifacts({
-        url,
         phase: 'getArtifact',
         gatherMode: 'snapshot',
         driver,

package/lighthouse-core/fraggle-rock/gather/timespan-runner.js

@@ -37,7 +37,6 @@ async function startTimespanGather(options) {
   const artifactState = getEmptyArtifactState();
   /** @type {Omit<import('./runner-helpers.js').CollectPhaseArtifactOptions, 'phase'>} */
   const phaseOptions = {
-    url: initialUrl,
     driver,
     artifactDefinitions,
     artifactState,
@@ -54,7 +53,6 @@ async function startTimespanGather(options) {
   return {
     async endTimespanGather() {
       const finalUrl = await driver.url();
-      phaseOptions.url = finalUrl;
 
       const runnerOptions = {config, computedCache};
       const artifacts = await Runner.gather(

package/lighthouse-core/gather/connections/cri.js

@@ -88,6 +88,7 @@ class CriConnection extends Connection {
         path: '/json/' + command,
       }, response => {
         let data = '';
+        response.setEncoding('utf8');
         response.on('data', chunk => {
           data += chunk;
         });

package/lighthouse-core/gather/driver/execution-context.js

@@ -97,7 +97,8 @@ class ExecutionContext {
             .catch(${pageFunctions.wrapRuntimeEvalErrorInBrowserString})
             .then(resolve);
         });
-      }())`,
+      }())
+      //# sourceURL=_lighthouse-eval.js`,
       includeCommandLineAPI: true,
       awaitPromise: true,
       returnByValue: true,
@@ -195,7 +196,8 @@ class ExecutionContext {
       ${ExecutionContext._cachedNativesPreamble};
       ${depsSerialized};
       (${mainFn})(${argsSerialized});
-    })()`;
+    })()
+    //# sourceURL=_lighthouse-eval.js`;
 
     await this._session.sendCommand('Page.addScriptToEvaluateOnNewDocument', {source: expression});
   }

package/lighthouse-core/gather/gatherers/js-usage.js

@@ -50,12 +50,13 @@ class JsUsage extends FRGatherer {
     const usageByScriptId = {};
 
     for (const scriptUsage of this._scriptUsages) {
-      // If `url` is blank, that means the script was anonymous (eval, new Function, onload, ...).
-      // Or, it's because it was code Lighthouse over the protocol via `Runtime.evaluate`.
-      // We currently don't consider coverage of anonymous scripts, and we definitely don't want
-      // coverage of code Lighthouse ran to inspect the page, so we ignore this ScriptCoverage if
-      // url is blank.
-      if (scriptUsage.url === '') {
+      // If `url` is blank, that means the script was dynamically
+      // created (eval, new Function, onload, ...)
+      if (scriptUsage.url === '' || scriptUsage.url === '_lighthouse-eval.js') {
+        // We currently don't consider coverage of dynamic scripts, and we definitely don't want
+        // coverage of code Lighthouse ran to inspect the page, so we ignore this ScriptCoverage.
+        // Audits would work the same without this, it is only an optimization (not tracking coverage
+        // for scripts we don't care about).
         continue;
       }
 

package/lighthouse-core/gather/gatherers/scripts.js

@@ -28,6 +28,23 @@ async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   }
 }
 
+/**
+ * Returns true if the script was created via our own calls
+ * to Runtime.evaluate.
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ */
+function isLighthouseRuntimeEvaluateScript(script) {
+  // Scripts created by Runtime.evaluate that run on the main session/frame
+  // result in an empty string for the embedderName.
+  // Or, it means the script was dynamically created (eval, new Function, onload, ...)
+  if (!script.embedderName) return true;
+
+  // Otherwise, when running our own code inside other frames, the embedderName
+  // is set to the frame's url. In that case, we rely on the special sourceURL that
+  // we set.
+  return script.hasSourceURL && script.url === '_lighthouse-eval.js';
+}
+
 /**
  * @fileoverview Gets JavaScript file contents.
  */
@@ -68,8 +85,9 @@ class Scripts extends FRGatherer {
     // it also blocks scripts from the same origin but that happen to run in a different process,
     // like a worker.
     if (event.method === 'Debugger.scriptParsed' && !sessionId) {
-      // Events without an embedderName (read: a url) are for JS that we ran over the protocol.
-      if (event.params.embedderName) this._scriptParsedEvents.push(event.params);
+      if (!isLighthouseRuntimeEvaluateScript(event.params)) {
+        this._scriptParsedEvents.push(event.params);
+      }
     }
   }
 

package/lighthouse-core/gather/gatherers/seo/robots-txt.js

@@ -46,7 +46,8 @@ class RobotsTxt extends FRGatherer {
       });
     }
 
-    const robotsUrl = new URL('/robots.txt', passContext.url).href;
+    const {finalUrl} = passContext.baseArtifacts.URL;
+    const robotsUrl = new URL('/robots.txt', finalUrl).href;
     await passContext.driver.fetcher.enable();
     return passContext.driver.fetcher.fetchResource(robotsUrl)
       .catch(err => ({status: null, content: null, errorMessage: err.message}));

package/lighthouse-core/gather/gatherers/web-app-manifest.js

@@ -94,8 +94,8 @@ class WebAppManifest extends FRGatherer {
    */
   getArtifact(context) {
     const driver = context.driver;
-
-    return WebAppManifest.getWebAppManifest(driver.defaultSession, context.url);
+    const {finalUrl} = context.baseArtifacts.URL;
+    return WebAppManifest.getWebAppManifest(driver.defaultSession, finalUrl);
   }
 }
 

package/lighthouse-core/lib/dependency-graph/simulator/network-analyzer.js

@@ -6,7 +6,6 @@
 'use strict';
 
 const INITIAL_CWD = 14 * 1024;
-const NetworkRequest = require('../../network-request.js');
 const URL = require('../../url-shim.js');
 
 // Assume that 40% of TTFB was server response time by default for static assets
@@ -434,40 +433,20 @@ class NetworkAnalyzer {
 
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} records
-   * @param {string} [finalURL]
-   * @return {LH.Artifacts.NetworkRequest}
-   */
-  static findMainDocument(records, finalURL) {
-    const mainDocument = NetworkAnalyzer.findOptionalMainDocument(records, finalURL);
-    if (!mainDocument) throw new Error('Unable to identify the main resource');
-    return mainDocument;
-  }
-
-  /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
-   * @param {string} [finalURL]
+   * @param {string} resourceUrl
    * @return {LH.Artifacts.NetworkRequest|undefined}
    */
-  static findOptionalMainDocument(records, finalURL) {
-    // Try to find an exact match with the final URL first if we have one
-    if (finalURL) {
-      // equalWithExcludedFragments is expensive, so check that the finalUrl starts with the request first
-      const mainResource = records.find(request => finalURL.startsWith(request.url) &&
-        URL.equalWithExcludedFragments(request.url, finalURL));
-      if (mainResource) return mainResource;
-      // TODO: beacon !mainResource to Sentry, https://github.com/GoogleChrome/lighthouse/issues/7041
-    }
-
-    const documentRequests = records.filter(record => record.resourceType ===
-        NetworkRequest.TYPES.Document);
-    if (!documentRequests.length) return undefined;
-    // The main document is the earliest document request, using position in networkRecords array to break ties.
-    return documentRequests.reduce((min, r) => (r.startTime < min.startTime ? r : min));
+  static findResourceForUrl(records, resourceUrl) {
+    // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
+    return records.find(request =>
+      resourceUrl.startsWith(request.url) &&
+      URL.equalWithExcludedFragments(request.url, resourceUrl)
+    );
   }
 
   /**
    * Resolves redirect chain given a main document.
-   * See: {@link NetworkAnalyzer.findMainDocument}) for how to retrieve main document.
+   * See: {@link NetworkAnalyzer.findResourceForUrl}) for how to retrieve main document.
    *
    * @param {LH.Artifacts.NetworkRequest} request
    * @return {LH.Artifacts.NetworkRequest}

package/lighthouse-core/lib/navigation-error.js

@@ -7,6 +7,7 @@
 
 const LHError = require('./lh-error.js');
 const NetworkAnalyzer = require('./dependency-graph/simulator/network-analyzer.js');
+const NetworkRequest = require('./network-request.js');
 
 /**
  * Returns an error if the original network request failed or wasn't found.
@@ -100,10 +101,18 @@ function getNonHtmlError(finalRecord) {
 function getPageLoadError(navigationError, context) {
   const {url, loadFailureMode, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
-  let mainRecord;
-  try {
-    mainRecord = NetworkAnalyzer.findMainDocument(networkRecords, url);
-  } catch (_) {}
+  let mainRecord = NetworkAnalyzer.findResourceForUrl(networkRecords, url);
+
+  // If the url doesn't give us a network request, it's possible we landed on a chrome-error:// page
+  // In this case, just get the first document request.
+  if (!mainRecord) {
+    const documentRequests = networkRecords.filter(record =>
+      record.resourceType === NetworkRequest.TYPES.Document
+    );
+    if (documentRequests.length) {
+      mainRecord = documentRequests.reduce((min, r) => (r.startTime < min.startTime ? r : min));
+    }
+  }
 
   // MIME Type is only set on the final redirected document request. Use this for the HTML check instead of root.
   let finalRecord;

package/lighthouse-core/util-commonjs.js

@@ -318,24 +318,26 @@ class Util {
     }
 
     const MAX_LENGTH = 64;
-    // 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
-    name = name.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,
-      `$1${ELLIPSIS}`);
-    // Also elide long number sequences
-    name = name.replace(/(\d{3})\d{6,}/g, `$1${ELLIPSIS}`);
-    // Merge any adjacent ellipses
-    name = name.replace(/\u2026+/g, ELLIPSIS);
-
-    // Elide query params first
-    if (name.length > MAX_LENGTH && name.includes('?')) {
-      // Try to leave the first query parameter intact
-      name = name.replace(/\?([^=]*)(=)?.*/, `?$1$2${ELLIPSIS}`);
-
-      // Remove it all if it's still too long
-      if (name.length > MAX_LENGTH) {
-        name = name.replace(/\?.*/, `?${ELLIPSIS}`);
+    if (parsedUrl.protocol !== 'data:') {
+      // 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
+      name = name.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,
+        `$1${ELLIPSIS}`);
+      // Also elide long number sequences
+      name = name.replace(/(\d{3})\d{6,}/g, `$1${ELLIPSIS}`);
+      // Merge any adjacent ellipses
+      name = name.replace(/\u2026+/g, ELLIPSIS);
+
+      // Elide query params first
+      if (name.length > MAX_LENGTH && name.includes('?')) {
+        // Try to leave the first query parameter intact
+        name = name.replace(/\?([^=]*)(=)?.*/, `?$1$2${ELLIPSIS}`);
+
+        // Remove it all if it's still too long
+        if (name.length > MAX_LENGTH) {
+          name = name.replace(/\?.*/, `?${ELLIPSIS}`);
+        }
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse",
-  "version": "9.5.0-dev.20220329",
+  "version": "9.5.0-dev.20220401",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./lighthouse-core/index.js",
   "bin": {
@@ -89,8 +89,8 @@
     "compile-proto": "protoc --python_out=./ ./proto/lighthouse-result.proto && mv ./proto/*_pb2.py ./proto/scripts || (echo \"❌ Install protobuf ≥ 3.7.1 to compile the proto file.\" && false)",
     "build-proto-roundtrip": "mkdir -p .tmp && cross-env PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION=2 python proto/scripts/json_roundtrip_via_proto.py",
     "static-server": "node lighthouse-cli/test/fixtures/static-server.js",
-    "serve-dist": "cd dist && python -m SimpleHTTPServer",
-    "serve-gh-pages": "cd dist/gh-pages && python -m SimpleHTTPServer",
+    "serve-dist": "cd dist && python3 -m http.server",
+    "serve-gh-pages": "cd dist/gh-pages && python3 -m http.server",
     "serve-treemap": "yarn serve-gh-pages",
     "serve-viewer": "yarn serve-gh-pages",
     "flow-report": "yarn build-report --flow && node ./lighthouse-core/scripts/build-test-flow-report.js"
@@ -203,7 +203,7 @@
     "robots-parser": "^3.0.0",
     "semver": "^5.3.0",
     "speedline-core": "^1.4.3",
-    "third-party-web": "^0.12.7",
+    "third-party-web": "^0.15.0",
     "ws": "^7.0.0",
     "yargs": "^17.3.1",
     "yargs-parser": "^21.0.0"

package/report/renderer/util.js

@@ -315,24 +315,26 @@ class Util {
     }
 
     const MAX_LENGTH = 64;
-    // 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
-    name = name.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,
-      `$1${ELLIPSIS}`);
-    // Also elide long number sequences
-    name = name.replace(/(\d{3})\d{6,}/g, `$1${ELLIPSIS}`);
-    // Merge any adjacent ellipses
-    name = name.replace(/\u2026+/g, ELLIPSIS);
-
-    // Elide query params first
-    if (name.length > MAX_LENGTH && name.includes('?')) {
-      // Try to leave the first query parameter intact
-      name = name.replace(/\?([^=]*)(=)?.*/, `?$1$2${ELLIPSIS}`);
-
-      // Remove it all if it's still too long
-      if (name.length > MAX_LENGTH) {
-        name = name.replace(/\?.*/, `?${ELLIPSIS}`);
+    if (parsedUrl.protocol !== 'data:') {
+      // 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
+      name = name.replace(/([a-zA-Z0-9-_]{9})(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9-_]{10,}/g,
+        `$1${ELLIPSIS}`);
+      // Also elide long number sequences
+      name = name.replace(/(\d{3})\d{6,}/g, `$1${ELLIPSIS}`);
+      // Merge any adjacent ellipses
+      name = name.replace(/\u2026+/g, ELLIPSIS);
+
+      // Elide query params first
+      if (name.length > MAX_LENGTH && name.includes('?')) {
+        // Try to leave the first query parameter intact
+        name = name.replace(/\?([^=]*)(=)?.*/, `?$1$2${ELLIPSIS}`);
+
+        // Remove it all if it's still too long
+        if (name.length > MAX_LENGTH) {
+          name = name.replace(/\?.*/, `?${ELLIPSIS}`);
+        }
       }
     }
 

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

@@ -1272,7 +1272,7 @@
     "message": "Fonts with `font-display: optional` are preloaded"
   },
   "lighthouse-core/audits/preload-lcp-image.js | description": {
-    "message": "Preload the image used by the LCP element in order to improve your LCP time. [Learn more](https://web.dev/optimize-lcp/#preload-important-resources)."
+    "message": "If the LCP element is dynamically added to the page, you should preload the image in order to improve LCP. [Learn more](https://web.dev/optimize-lcp/#preload-important-resources)."
   },
   "lighthouse-core/audits/preload-lcp-image.js | title": {
     "message": "Preload Largest Contentful Paint image"

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

@@ -1272,7 +1272,7 @@
     "message": "F̂ón̂t́ŝ ẃît́ĥ `font-display: optional` ár̂é p̂ŕêĺôád̂éd̂"
   },
   "lighthouse-core/audits/preload-lcp-image.js | description": {
-    "message": "P̂ŕêĺôád̂ t́ĥé îḿâǵê úŝéd̂ b́ŷ t́ĥé L̂ĆP̂ él̂ém̂én̂t́ îń ôŕd̂ér̂ t́ô ím̂ṕr̂óv̂é ŷóûŕ L̂ĆP̂ t́îḿê. [Ĺêár̂ń m̂ór̂é](https://web.dev/optimize-lcp/#preload-important-resources)."
+    "message": "Îf́ t̂h́ê ĹĈṔ êĺêḿêńt̂ íŝ d́ŷńâḿîćâĺl̂ý âd́d̂éd̂ t́ô t́ĥé p̂áĝé, ŷóû śĥóûĺd̂ ṕr̂él̂óâd́ t̂h́ê ím̂áĝé îń ôŕd̂ér̂ t́ô ím̂ṕr̂óv̂é L̂ĆP̂. [Ĺêár̂ń m̂ór̂é](https://web.dev/optimize-lcp/#preload-important-resources)."
   },
   "lighthouse-core/audits/preload-lcp-image.js | title": {
     "message": "P̂ŕêĺôád̂ Ĺâŕĝéŝt́ Ĉón̂t́êńt̂f́ûĺ P̂áîńt̂ ím̂áĝé"

package/types/artifacts.d.ts

@@ -641,6 +641,7 @@ declare module Artifacts {
     settings: Immutable<Config.Settings>;
     gatherContext: Artifacts['GatherContext'];
     simulator?: InstanceType<typeof LanternSimulator>;
+    URL: Artifacts['URL'];
   }
 
   interface MetricComputationData extends MetricComputationDataInput {

package/types/gatherer.d.ts

@@ -47,8 +47,6 @@ declare module Gatherer {
 
   /** The limited context interface shared between pre and post Fraggle Rock Lighthouse. */
   interface FRTransitionalContext<TDependencies extends DependencyKey = DefaultDependenciesKey> {
-    /** The URL of the page that is currently active. Might be `about:blank` in the before phases */
-    url: string;
     /** The gather mode Lighthouse is currently in. */
     gatherMode: GatherMode;
     /** The connection to the page being analyzed. */