lighthouse 10.4.0-dev.20230710 → 10.4.0-dev.20230711

package/cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -136,11 +136,6 @@ async function begin() {
         default: false,
         describe: 'Save test artifacts and output verbose logs',
       },
-      'legacy-navigation': {
-        type: 'boolean',
-        default: false,
-        describe: 'Use the legacy navigation runner',
-      },
       'jobs': {
         type: 'number',
         alias: 'j',
@@ -218,7 +213,6 @@ async function begin() {
       jobs,
       retries,
       isDebug: argv.debug,
-      useLegacyNavigation: argv.legacyNavigation,
       lighthouseRunner: runLighthouse,
       takeNetworkRequestUrls,
       setup,
@@ -229,17 +223,25 @@ async function begin() {
     servers?.forEach(s => s.close());
   }
 
+  let smokehouseOutputDir;
+  let testResultsToOutput;
   if (!smokehouseResult.success) {
-    const failedTestResults = smokehouseResult.testResults.filter(r => r.failed);
-
     // Save failed runs to directory. In CI, this is uploaded as an artifact.
-    const failuresDir = `${LH_ROOT}/.tmp/smokehouse-failures`;
-    fs.rmSync(failuresDir, {recursive: true, force: true});
-    fs.mkdirSync(failuresDir);
+    smokehouseOutputDir = `${LH_ROOT}/.tmp/smokehouse-failures`;
+    testResultsToOutput = smokehouseResult.testResults.filter(r => r.failed);
+  } else if (!process.env.CI) {
+    // Otherwise, only write to disk in debug mode.
+    smokehouseOutputDir = `${LH_ROOT}/.tmp/smokehouse-output`;
+    testResultsToOutput = smokehouseResult.testResults;
+  }
 
-    for (const testResult of failedTestResults) {
+  if (smokehouseOutputDir && testResultsToOutput) {
+    fs.rmSync(smokehouseOutputDir, {recursive: true, force: true});
+    fs.mkdirSync(smokehouseOutputDir);
+
+    for (const testResult of testResultsToOutput) {
       for (let i = 0; i < testResult.runs.length; i++) {
-        const runDir = `${failuresDir}/${i}/${testResult.id}`;
+        const runDir = `${smokehouseOutputDir}/${i}/${testResult.id}`;
         fs.mkdirSync(runDir, {recursive: true});
 
         const run = testResult.runs[i];
@@ -250,10 +252,18 @@ async function begin() {
         if (run.networkRequests) {
           fs.writeFileSync(`${runDir}/networkRequests.txt`, run.networkRequests.join('\n'));
         }
+        const config = testDefns.find(test => test.id === testResult.id)?.config;
+        if (config) {
+          fs.writeFileSync(`${runDir}/config.json`, JSON.stringify(config, null, 2));
+        }
       }
     }
 
-    const cmd = `yarn smoke ${failedTestResults.map(r => r.id).join(' ')}`;
+    console.log(`smokehouse artifacts written to ${smokehouseOutputDir}`);
+  }
+
+  if (!smokehouseResult.success && testResultsToOutput) {
+    const cmd = `yarn smoke ${testResultsToOutput.map(r => r.id).join(' ')}`;
     console.log(`rerun failures: ${cmd}`);
   }
 

package/cli/test/smokehouse/lighthouse-runners/bundle.d.ts

@@ -2,12 +2,11 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

package/cli/test/smokehouse/lighthouse-runners/bundle.js

@@ -19,7 +19,6 @@ import {once} from 'events';
 import puppeteer from 'puppeteer-core';
 import ChromeLauncher from 'chrome-launcher';
 
-import {CriConnection} from '../../../../core/legacy/gather/connections/cri.js';
 import {LH_ROOT} from '../../../../root.js';
 import {loadArtifacts, saveArtifacts} from '../../../../core/lib/asset-saver.js';
 
@@ -39,7 +38,7 @@ if (!isMainThread && parentPort) {
       parentPort?.postMessage({type: 'result', value});
     } catch (err) {
       console.error(err);
-      parentPort?.postMessage({type: 'error', value: err});
+      parentPort?.postMessage({type: 'error', value: err.toString()});
     }
   })();
 }
@@ -47,7 +46,7 @@ if (!isMainThread && parentPort) {
 /**
  * @param {string} url
  * @param {LH.Config|undefined} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}} testRunnerOptions
+ * @param {{isDebug?: boolean}} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
  */
 async function runBundledLighthouse(url, config, testRunnerOptions) {
@@ -72,10 +71,6 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
   // @ts-expect-error - not worth giving test global an actual type.
   const lighthouse = global.runBundledLighthouse;
 
-  /** @type {import('../../../../core/index.js')['legacyNavigation']} */
-  // @ts-expect-error - not worth giving test global an actual type.
-  const legacyNavigation = global.runBundledLighthouseLegacyNavigation;
-
   // Launch and connect to Chrome.
   const launchedChrome = await ChromeLauncher.launch();
   const port = launchedChrome.port;
@@ -83,17 +78,11 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
   // Run Lighthouse.
   try {
     const logLevel = testRunnerOptions.isDebug ? 'verbose' : 'info';
-    let runnerResult;
-    if (testRunnerOptions.useLegacyNavigation) {
-      const connection = new CriConnection(port);
-      runnerResult =
-        await legacyNavigation(url, {port, logLevel}, config, connection);
-    } else {
-      // Puppeteer is not included in the bundle, we must create the page here.
-      const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
-      const page = await browser.newPage();
-      runnerResult = await lighthouse(url, {port, logLevel}, config, page);
-    }
+
+    // Puppeteer is not included in the bundle, we must create the page here.
+    const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
+    const page = await browser.newPage();
+    const runnerResult = await lighthouse(url, {port, logLevel}, config, page);
     if (!runnerResult) throw new Error('No runnerResult');
 
     return {
@@ -110,7 +99,7 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {

package/cli/test/smokehouse/lighthouse-runners/cli.d.ts

@@ -3,12 +3,11 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean | undefined;
-    useFraggleRock?: boolean | undefined;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

package/cli/test/smokehouse/lighthouse-runners/cli.js

@@ -28,7 +28,7 @@ const execFileAsync = promisify(execFile);
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -46,11 +46,11 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
  * @param {string} url
  * @param {string} tmpPath
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} options
+ * @param {{isDebug?: boolean}=} options
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function internalRun(url, tmpPath, config, options) {
-  const {isDebug = false, useLegacyNavigation = false} = options || {};
+  const {isDebug = false} = options || {};
   const localConsole = new LocalConsole();
 
   const outputPath = `${tmpPath}/smokehouse.report.json`;
@@ -67,10 +67,6 @@ async function internalRun(url, tmpPath, config, options) {
     '--quiet',
   ];
 
-  if (useLegacyNavigation) {
-    args.push('--legacy-navigation');
-  }
-
   // Config can be optionally provided.
   if (config) {
     const configPath = `${tmpPath}/config.json`;

package/cli/test/smokehouse/lighthouse-runners/devtools.d.ts

@@ -5,12 +5,11 @@
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

package/cli/test/smokehouse/lighthouse-runners/devtools.js

@@ -8,8 +8,6 @@
  * @fileoverview A runner that launches Chrome and executes Lighthouse via DevTools.
  */
 
-import fs from 'fs';
-import os from 'os';
 import {execFileSync} from 'child_process';
 
 import {LH_ROOT} from '../../../../root.js';
@@ -42,7 +40,7 @@ async function setup() {
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -52,16 +50,8 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
   const {lhr, artifacts, logs} = await testUrlFromDevtools(url, {
     config,
     chromeFlags,
-    useLegacyNavigation: testRunnerOptions.useLegacyNavigation,
   });
 
-  if (testRunnerOptions.isDebug) {
-    const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
-    fs.writeFileSync(`${outputDir}/lhr.json`, JSON.stringify(lhr));
-    fs.writeFileSync(`${outputDir}/artifacts.json`, JSON.stringify(artifacts));
-    console.log(`${url} results saved at ${outputDir}`);
-  }
-
   const log = logs.join('') + '\n';
   return {lhr, artifacts, log};
 }

package/cli/test/smokehouse/readme.md

@@ -118,8 +118,6 @@ All pruning checks:
 
 - `_minChromiumVersion`
 - `_maxChromiumVersion`
-- `_legacyOnly`
-- `_fraggleRockOnly`
 - `_runner` (set to same value provided to CLI --runner flag, ex: `'devtools'`)
 - `_excludeRunner` (set to same value provided to CLI --runner flag, ex: `'devtools'`)
 

package/cli/test/smokehouse/report-assert.d.ts

@@ -16,7 +16,7 @@ export type Comparison = {
  * summary. Returns count of passed and failed tests.
  * @param {{lhr: LH.Result, artifacts: LH.Artifacts, networkRequests?: string[]}} actual
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, isDebug?: boolean, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string, isDebug?: boolean}=} reportOptions
  * @return {{passed: number, failed: number, log: string}}
  */
 export function getAssertionReport(actual: {
@@ -26,7 +26,6 @@ export function getAssertionReport(actual: {
 }, expected: Smokehouse.ExpectedRunnerResult, reportOptions?: {
     runner?: string;
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): {
     passed: number;
     failed: number;

package/cli/test/smokehouse/report-assert.js

@@ -237,11 +237,9 @@ function makeComparison(name, actualResult, expectedResult) {
  * @param {LocalConsole} localConsole
  * @param {LH.Result} lhr
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string}=} reportOptions
  */
 function pruneExpectations(localConsole, lhr, expected, reportOptions) {
-  const isLegacyNavigation = reportOptions?.useLegacyNavigation;
-
   /**
    * Lazily compute the Chrome version because some reports are explicitly asserting error conditions.
    * @returns {string}
@@ -295,19 +293,6 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
           `Actual Chromium version: ${getChromeVersionString()}`,
         ].join(' '));
         remove(key);
-      } else if (value._legacyOnly && !isLegacyNavigation) {
-        localConsole.log([
-          `[${key}] marked legacy only but run is Fraggle Rock, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-        ].join(' '));
-        remove(key);
-      } else if (value._fraggleRockOnly && isLegacyNavigation) {
-        localConsole.log([
-          `[${key}] marked Fraggle Rock only but run is legacy, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-          `Actual channel: ${lhr.configSettings.channel}`,
-        ].join(' '));
-        remove(key);
       } else if (value._runner && reportOptions?.runner !== value._runner) {
         localConsole.log([
           `[${key}] is only for runner ${value._runner}, pruning expectation:`,
@@ -325,8 +310,6 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
       }
     }
 
-    delete obj._legacyOnly;
-    delete obj._fraggleRockOnly;
     delete obj._skipInBundled;
     delete obj._minChromiumVersion;
     delete obj._maxChromiumVersion;
@@ -483,7 +466,7 @@ function reportAssertion(localConsole, assertion) {
  * summary. Returns count of passed and failed tests.
  * @param {{lhr: LH.Result, artifacts: LH.Artifacts, networkRequests?: string[]}} actual
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, isDebug?: boolean, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string, isDebug?: boolean}=} reportOptions
  * @return {{passed: number, failed: number, log: string}}
  */
 function getAssertionReport(actual, expected, reportOptions = {}) {

package/cli/test/smokehouse/smokehouse.js

@@ -53,7 +53,6 @@ const DEFAULT_RETRIES = 0;
 async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
   const {
     isDebug,
-    useLegacyNavigation,
     jobs = DEFAULT_CONCURRENT_RUNS,
     retries = DEFAULT_RETRIES,
     lighthouseRunner = Object.assign(cliLighthouseRunner, {runnerName: 'cli'}),
@@ -76,7 +75,6 @@ async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
 
   const testOptions = {
     isDebug,
-    useLegacyNavigation,
     retries,
     lighthouseRunner,
     takeNetworkRequestUrls,
@@ -133,39 +131,18 @@ function purpleify(str) {
   return `${log.purple}${str}${log.reset}`;
 }
 
-/**
- * @param {LH.Config=} config
- * @return {LH.Config|undefined}
- */
-function convertToLegacyConfig(config) {
-  if (!config) return config;
-
-  return {
-    ...config,
-    passes: [{
-      passName: 'defaultPass',
-      pauseAfterFcpMs: config.settings?.pauseAfterFcpMs,
-      pauseAfterLoadMs: config.settings?.pauseAfterLoadMs,
-      networkQuietThresholdMs: config.settings?.networkQuietThresholdMs,
-      cpuQuietThresholdMs: config.settings?.cpuQuietThresholdMs,
-      blankPage: config.settings?.blankPage,
-    }],
-  };
-}
-
 /**
  * Run Lighthouse in the selected runner.
  * @param {Smokehouse.TestDfn} smokeTestDefn
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean, retries: number, lighthouseRunner: Smokehouse.LighthouseRunner, takeNetworkRequestUrls?: () => string[]}} testOptions
+ * @param {{isDebug?: boolean, retries: number, lighthouseRunner: Smokehouse.LighthouseRunner, takeNetworkRequestUrls?: () => string[]}} testOptions
  * @return {Promise<SmokehouseResult>}
  */
 async function runSmokeTest(smokeTestDefn, testOptions) {
-  const {id, expectations} = smokeTestDefn;
+  const {id, expectations, config} = smokeTestDefn;
   const {
     lighthouseRunner,
     retries,
     isDebug,
-    useLegacyNavigation,
     takeNetworkRequestUrls,
   } = testOptions;
   const requestedUrl = expectations.lhr.requestedUrl;
@@ -184,15 +161,10 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
       bufferedConsole.log(`  Retrying run (${i} out of ${retries} retries)…`);
     }
 
-    let config = smokeTestDefn.config;
-    if (useLegacyNavigation) {
-      config = convertToLegacyConfig(config);
-    }
-
     // Run Lighthouse.
     try {
       result = {
-        ...await lighthouseRunner(requestedUrl, config, {isDebug, useLegacyNavigation}),
+        ...await lighthouseRunner(requestedUrl, config, {isDebug}),
         networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
       };
 
@@ -213,7 +185,6 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     report = getAssertionReport(result, expectations, {
       runner: lighthouseRunner.runnerName,
       isDebug,
-      useLegacyNavigation,
     });
 
     runs.push({

package/core/audits/byte-efficiency/render-blocking-resources.js

@@ -299,6 +299,7 @@ class RenderBlockingResources extends Audit {
       numericValue: wastedMs,
       numericUnit: 'millisecond',
       details,
+      metricSavings: {FCP: wastedMs, LCP: wastedMs},
     };
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "10.4.0-dev.20230710",
+  "version": "10.4.0-dev.20230711",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/types/internal/smokehouse.d.ts

@@ -53,13 +53,11 @@ declare global {
       {expectations: Smokehouse.ExpectedRunnerResult | Array<Smokehouse.ExpectedRunnerResult>}
 
     export type LighthouseRunner =
-      {runnerName?: string} & ((url: string, config?: Config, runnerOptions?: {isDebug?: boolean; useLegacyNavigation?: boolean}) => Promise<{lhr: LHResult, artifacts: Artifacts, log: string}>);
+      {runnerName?: string} & ((url: string, config?: Config, runnerOptions?: {isDebug?: boolean}) => Promise<{lhr: LHResult, artifacts: Artifacts, log: string}>);
 
     export interface SmokehouseOptions {
       /** If true, performs extra logging from the test runs. */
       isDebug?: boolean;
-      /** If true, use the legacy navigation runner. */
-      useLegacyNavigation?: boolean;
       /** Manually set the number of jobs to run at once. `1` runs all tests serially. */
       jobs?: number;
       /** The number of times to retry failing tests before accepting. Defaults to 0. */

package/core/audits/metrics/first-contentful-paint-3g.d.ts

@@ -1,15 +0,0 @@
-export default FirstContentfulPaint3G;
-declare class FirstContentfulPaint3G extends Audit {
-    /**
-     * @return {LH.Audit.ScoreOptions}
-     */
-    static get defaultOptions(): import("../../../types/audit.js").default.ScoreOptions;
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
-}
-import { Audit } from '../audit.js';
-//# sourceMappingURL=first-contentful-paint-3g.d.ts.map

package/core/audits/metrics/first-contentful-paint-3g.js

@@ -1,69 +0,0 @@
-/**
- * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-import {Audit} from '../audit.js';
-import {FirstContentfulPaint as ComputedFcp} from '../../computed/metrics/first-contentful-paint.js';
-import * as constants from '../../config/constants.js';
-
-const regular3G = constants.throttling.mobileRegular3G;
-
-class FirstContentfulPaint3G extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'first-contentful-paint-3g',
-      title: 'First Contentful Paint (3G)',
-      description: 'First Contentful Paint 3G marks the time at which the first text or image is ' +
-        'painted while on a 3G network. ' +
-        '[Learn more about the First Contentful Paint (3G) metric](https://developers.google.com/web/tools/lighthouse/audits/first-contentful-paint).',
-      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
-    };
-  }
-
-  /**
-   * @return {LH.Audit.ScoreOptions}
-   */
-  static get defaultOptions() {
-    return {
-      // 25th and 8th percentiles HTTPArchive on Slow 4G -> multiply by 1.5 for RTT differential -> median and p10.
-      // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2021_05_01_mobile
-      // https://www.desmos.com/calculator/xi5oympawp
-      p10: 2700,
-      median: 4500,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const gatherContext = artifacts.GatherContext;
-    const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    /** @type {LH.Audit.Context['settings']} */
-    const settings = {...context.settings, throttlingMethod: 'simulate', throttling: regular3G};
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
-    const metricResult = await ComputedFcp.request(metricComputationData, context);
-
-    return {
-      score: Audit.computeLogNormalScore(
-        {p10: context.options.p10, median: context.options.median},
-        metricResult.timing
-      ),
-      numericValue: metricResult.timing,
-      numericUnit: 'millisecond',
-      displayValue: `${metricResult.timing}\xa0ms`,
-    };
-  }
-}
-
-export default FirstContentfulPaint3G;