lighthouse 13.0.3 → 13.1.0

package/CONTRIBUTING.md

@@ -8,7 +8,7 @@ We tag issues that are good candidates for those new to the code with [`good fir
 
 ## Follow the coding style
 
-The `.eslintrc.cjs` file defines all. We use [JSDoc](http://usejsdoc.org/) with [TypeScript `checkJs`](https://www.typescriptlang.org/docs/handbook/type-checking-javascript-files.html#supported-jsdoc). Annotations are encouraged for all contributions.
+The `.eslintrc.cjs` file defines all. We use [JSDoc](https://jsdoc.app/) with [TypeScript `checkJs`](https://www.typescriptlang.org/docs/handbook/type-checking-javascript-files.html#supported-jsdoc). Annotations are encouraged for all contributions.
 
 ## Learn about the architecture
 

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

@@ -3,7 +3,7 @@
 exports[`getAssertionReport works (multiple failing) 1`] = `
 "X difference at cumulative-layout-shift audit.details.items.length
               expected: []
-                 found: [{\\"cumulativeLayoutShiftMainFrame\\":0.09957584751767748,\\"newEngineResult\\":{\\"cumulativeLayoutShift\\":0.09957584751767748,\\"cumulativeLayoutShiftMainFrame\\":0.09957584751767748},\\"newEngineResultDiffered\\":false}]
+                 found: [{\\"cumulativeLayoutShiftMainFrame\\":0.099576,\\"newEngineResult\\":{\\"cumulativeLayoutShift\\":0.099576,\\"cumulativeLayoutShiftMainFrame\\":0.099576},\\"newEngineResultDiffered\\":false}]
 
 
   X difference at cumulative-layout-shift audit.details.blah
@@ -17,7 +17,7 @@ exports[`getAssertionReport works (multiple failing) 1`] = `
         \\"description\\": \\"Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/articles/cls).\\",
         \\"score\\": 0.9,
         \\"scoreDisplayMode\\": \\"numeric\\",
-        \\"numericValue\\": 0.09957584751767748,
+        \\"numericValue\\": 0.099576,
         \\"numericUnit\\": \\"unitless\\",
         \\"displayValue\\": \\"0.1\\",
         \\"scoringOptions\\": {
@@ -28,10 +28,10 @@ exports[`getAssertionReport works (multiple failing) 1`] = `
           \\"type\\": \\"debugdata\\",
           \\"items\\": [
             {
-              \\"cumulativeLayoutShiftMainFrame\\": 0.09957584751767748,
+              \\"cumulativeLayoutShiftMainFrame\\": 0.099576,
               \\"newEngineResult\\": {
-                \\"cumulativeLayoutShift\\": 0.09957584751767748,
-                \\"cumulativeLayoutShiftMainFrame\\": 0.09957584751767748
+                \\"cumulativeLayoutShift\\": 0.099576,
+                \\"cumulativeLayoutShiftMainFrame\\": 0.099576
               },
               \\"newEngineResultDiffered\\": false
             }
@@ -43,7 +43,7 @@ exports[`getAssertionReport works (multiple failing) 1`] = `
 exports[`getAssertionReport works (trivial failing) 1`] = `
 "X difference at cumulative-layout-shift audit.details.items.length
               expected: []
-                 found: [{\\"cumulativeLayoutShiftMainFrame\\":0.09957584751767748,\\"newEngineResult\\":{\\"cumulativeLayoutShift\\":0.09957584751767748,\\"cumulativeLayoutShiftMainFrame\\":0.09957584751767748},\\"newEngineResultDiffered\\":false}]
+                 found: [{\\"cumulativeLayoutShiftMainFrame\\":0.099576,\\"newEngineResult\\":{\\"cumulativeLayoutShift\\":0.099576,\\"cumulativeLayoutShiftMainFrame\\":0.099576},\\"newEngineResultDiffered\\":false}]
 
           found result:
       {
@@ -52,7 +52,7 @@ exports[`getAssertionReport works (trivial failing) 1`] = `
         \\"description\\": \\"Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/articles/cls).\\",
         \\"score\\": 0.9,
         \\"scoreDisplayMode\\": \\"numeric\\",
-        \\"numericValue\\": 0.09957584751767748,
+        \\"numericValue\\": 0.099576,
         \\"numericUnit\\": \\"unitless\\",
         \\"displayValue\\": \\"0.1\\",
         \\"scoringOptions\\": {
@@ -63,10 +63,10 @@ exports[`getAssertionReport works (trivial failing) 1`] = `
           \\"type\\": \\"debugdata\\",
           \\"items\\": [
             {
-              \\"cumulativeLayoutShiftMainFrame\\": 0.09957584751767748,
+              \\"cumulativeLayoutShiftMainFrame\\": 0.099576,
               \\"newEngineResult\\": {
-                \\"cumulativeLayoutShift\\": 0.09957584751767748,
-                \\"cumulativeLayoutShiftMainFrame\\": 0.09957584751767748
+                \\"cumulativeLayoutShift\\": 0.099576,
+                \\"cumulativeLayoutShiftMainFrame\\": 0.099576
               },
               \\"newEngineResultDiffered\\": false
             }

package/cli/test/smokehouse/config/exclusions.js

@@ -31,6 +31,50 @@ const exclusions = {
     // Disabled because is timing out.
     'oopif-scripts',
   ],
+  'devtools-mcp': [
+    // Disabled because performance tracing related audits are not supported.
+    'byte-efficiency',
+    'byte-gzip',
+    'dbw',
+    'errors-expired-ssl',
+    'errors-iframe-expired-ssl',
+    'errors-infinite-loop',
+    'forms-autocomplete',
+    'fps-max-passive',
+    'fps-max',
+    'fps-overflow-x',
+    'lantern-fetch',
+    'lantern-idle-callback-long',
+    'lantern-idle-callback-short',
+    'lantern-online',
+    'lantern-set-timeout',
+    'lantern-xhr',
+    'legacy-javascript',
+    'metrics-debugger',
+    'metrics-delayed-fcp',
+    'metrics-delayed-lcp',
+    'metrics-tricky-tti-late-fcp',
+    'metrics-tricky-tti',
+    'oopif-requests',
+    'oopif-scripts',
+    'perf-debug',
+    'perf-diagnostics-animations',
+    'perf-diagnostics-unsized-images',
+    'perf-fonts',
+    'perf-frame-metrics',
+    'perf-preload',
+    'perf-trace-elements',
+    'redirects-client-paint-server',
+    'redirects-history-push-state',
+    'redirects-multiple-server',
+    'redirects-scripts',
+    'redirects-single-client',
+    'redirects-single-server',
+    'screenshot',
+    'shift-attribution',
+    'source-maps',
+    'timing',
+  ],
 };
 
 for (const array of Object.values(exclusions)) {

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

@@ -33,9 +33,10 @@ const coreTestDefnsPath =
  * contingent on having built all the bundles.
  */
 const runnerPaths = {
-  cli: '../lighthouse-runners/cli.js',
-  bundle: '../lighthouse-runners/bundle.js',
-  devtools: '../lighthouse-runners/devtools.js',
+  'cli': '../lighthouse-runners/cli.js',
+  'bundle': '../lighthouse-runners/bundle.js',
+  'devtools': '../lighthouse-runners/devtools.js',
+  'devtools-mcp': '../lighthouse-runners/devtools-mcp.js',
 };
 
 /**
@@ -146,7 +147,7 @@ async function begin() {
       },
       'runner': {
         default: 'cli',
-        choices: ['cli', 'bundle', 'devtools'],
+        choices: ['cli', 'bundle', 'devtools', 'devtools-mcp'],
         describe: 'The method of running Lighthouse',
       },
       'tests-path': {

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

@@ -0,0 +1,14 @@
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools MCP bundle.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {LocalConsole=} logger
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
+ */
+export function runLighthouse(url: string, config?: LH.Config | undefined, logger?: LocalConsole | undefined, testRunnerOptions?: Smokehouse.SmokehouseOptions["testRunnerOptions"] | undefined): Promise<{
+    lhr: LH.Result;
+    artifacts: LH.Artifacts;
+}>;
+import { LocalConsole } from '../lib/local-console.js';
+//# sourceMappingURL=devtools-mcp.d.ts.map

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

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview A runner that launches Chrome and executes Lighthouse via the
+ * DevTools MCP bundle.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import {Worker, isMainThread, parentPort, workerData} from 'worker_threads';
+import {once} from 'events';
+
+import puppeteer from 'puppeteer-core';
+import * as ChromeLauncher from 'chrome-launcher';
+
+import {LH_ROOT} from '../../../../shared/root.js';
+import {loadArtifacts, saveArtifacts} from '../../../../core/lib/asset-saver.js';
+import {LocalConsole} from '../lib/local-console.js';
+
+// This runs only in the worker. The rest runs on the main thread.
+if (!isMainThread && parentPort) {
+  (async () => {
+    const {url, config, testRunnerOptions} = workerData;
+    try {
+      const result = await runBundledLighthouse(url, config, testRunnerOptions);
+      // Save to assets directory because LighthouseError won't survive postMessage.
+      const assetsDir = fs.mkdtempSync(os.tmpdir() + '/smoke-mcp-assets-');
+      await saveArtifacts(result.artifacts, assetsDir);
+      const value = {
+        lhr: result.lhr,
+        assetsDir,
+      };
+      parentPort?.postMessage({type: 'result', value});
+    } catch (err) {
+      console.error(err);
+      parentPort?.postMessage({type: 'error', value: err.toString()});
+    }
+  })();
+}
+
+/**
+ * @param {string} url
+ * @param {LH.Config|undefined} config
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
+ */
+async function runBundledLighthouse(url, config, testRunnerOptions) {
+  if (isMainThread || !parentPort) {
+    throw new Error('must be called in worker');
+  }
+
+  // Load bundle.
+  const {navigation} = await import(LH_ROOT + '/dist/lighthouse-devtools-mcp-bundle.js');
+
+  // Launch and connect to Chrome.
+  const launchedChrome = await ChromeLauncher.launch({
+    chromeFlags: [
+      testRunnerOptions?.headless ? '--headless=new' : '',
+    ],
+  });
+  const port = launchedChrome.port;
+
+  // Run Lighthouse.
+  try {
+    const logLevel = testRunnerOptions?.isDebug ? 'verbose' : 'info';
+
+    // Puppeteer is not included in the bundle, we must create the page here.
+    const browser = await puppeteer.connect({browserURL: `http://127.0.0.1:${port}`});
+    const page = await browser.newPage();
+
+    // navigation(page, requestor, options)
+    const runnerResult = await navigation(page, url, {config, flags: {port, logLevel}});
+
+    if (!runnerResult) throw new Error('No runnerResult');
+
+    return {
+      lhr: runnerResult.lhr,
+      artifacts: runnerResult.artifacts,
+    };
+  } finally {
+    // Clean up and return results.
+    launchedChrome.kill();
+  }
+}
+
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools MCP bundle.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {LocalConsole=} logger
+ * @param {Smokehouse.SmokehouseOptions['testRunnerOptions']=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
+ */
+async function runLighthouse(url, config, logger, testRunnerOptions = {}) {
+  logger = logger || new LocalConsole();
+
+  const worker = new Worker(new URL(import.meta.url), {
+    stdout: true,
+    stderr: true,
+    workerData: {url, config, testRunnerOptions},
+  });
+  worker.stdout.setEncoding('utf8');
+  worker.stderr.setEncoding('utf8');
+  worker.stdout.addListener('data', (data) => {
+    logger.log(`[STDOUT] ${data}`);
+  });
+  worker.stderr.addListener('data', (data) => {
+    logger.log(`[STDERR] ${data}`);
+  });
+  const [workerResponse] = await once(worker, 'message');
+
+  if (workerResponse.type === 'error') {
+    const log = logger.getLog();
+    throw new Error(`Worker returned an error: ${workerResponse.value}
+Log:
+${log}
+`);
+  }
+
+  const result = workerResponse.value;
+  if (!result.lhr || !result.assetsDir) {
+    throw new Error(`invalid response from worker:
+${JSON.stringify(result, null, 2)}`);
+  }
+
+  const artifacts = loadArtifacts(result.assetsDir);
+  fs.rmSync(result.assetsDir, {recursive: true});
+
+  return {
+    lhr: result.lhr,
+    artifacts,
+  };
+}
+
+export {
+  runLighthouse,
+};

package/core/audits/baseline.d.ts

@@ -0,0 +1,25 @@
+export default Baseline;
+export type DXFeatureEvent = LH.TraceEvent & {
+    args: {
+        feature: string;
+        url?: string;
+        lineNumber?: number;
+        columnNumber?: number;
+    };
+};
+/** @typedef {LH.TraceEvent & {args: {feature: string, url?: string, lineNumber?: number, columnNumber?: number}}} DXFeatureEvent */
+declare class Baseline extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    let title: string;
+    let description: string;
+    let columnFeature: string;
+    let columnStatus: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=baseline.d.ts.map

package/core/audits/baseline.js

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import data from 'web-features/data.json' with {type: 'json'};
+
+import {Audit} from './audit.js';
+import metadata from '../lib/baseline/web-features-metadata.json' with {type: 'json'};
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of the Baseline audit. Shown when the page is compatible with the target baseline. */
+  title: 'Baseline Features',
+  /**
+   * @description Description of the Baseline audit.
+   * @example {2026-03-18} date
+   */
+  description:
+    'Lists web features used on the page and their Baseline status as of {date}. ' +
+    '[Learn more about Baseline](https://webstatus.dev/).',
+  /** Label for the column displaying the feature ID. */
+  columnFeature: 'Web-features',
+  /** Label for the column displaying the feature\'s baseline status. */
+  columnStatus: 'Baseline Status',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+const {features} = /** @type {any} */ (data);
+
+
+/** @typedef {LH.TraceEvent & {args: {feature: string, url?: string, lineNumber?: number, columnNumber?: number}}} DXFeatureEvent */
+
+class Baseline extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'baseline',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description, {date: metadata.date}),
+      requiredArtifacts: ['Trace'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts) {
+    const trace = artifacts.Trace;
+
+    /** @type {Map<string, {featureId: string, source: LH.Audit.Details.SourceLocationValue | undefined}>} */
+    const featuresMap = new Map();
+
+    const dxEvents = /** @type {DXFeatureEvent[]} */ (
+      (trace.traceEvents || []).filter(e => e.cat === 'blink.webdx_feature_usage' &&
+        e.args?.feature)
+    );
+
+    for (const event of dxEvents) {
+      const key = `${event.args.feature}`;
+
+      if (featuresMap.has(key)) continue;
+
+      /** @type {LH.Audit.Details.SourceLocationValue | undefined} */
+      let source;
+
+      if (event.args.url) {
+        const line = event.args.lineNumber ? event.args.lineNumber - 1 : 0;
+        const column = event.args.columnNumber ? event.args.columnNumber - 1 : 0;
+
+        source = Audit.makeSourceLocation(event.args.url, line, column);
+      }
+
+      featuresMap.set(key, {
+        featureId: event.args.feature,
+        source,
+      });
+    }
+
+    const baselineFeatures = Array.from(featuresMap.values());
+    const baselineStatus = [];
+
+    for (const feature of baselineFeatures) {
+      if (!feature.featureId) {
+        continue;
+      }
+
+      const featureData = features[feature.featureId];
+
+      if (!featureData || !('status' in featureData)) {
+        continue;
+      }
+
+      let displayStatus = 'Limited Availability';
+      let baselineTier = 'limited';
+
+      if (featureData.status.baseline === 'high') {
+        displayStatus = `Widely Available (${featureData.status.baseline_low_date})`;
+        baselineTier = 'high';
+      } else if (featureData.status.baseline === 'low') {
+        displayStatus = `Newly Available (${featureData.status.baseline_low_date})`;
+        baselineTier = 'low';
+      }
+
+      baselineStatus.push({
+        featureId: {
+          type: /** @type {const} */ ('link'),
+          text: feature.featureId,
+          url: `https://webstatus.dev/features/${feature.featureId}`,
+        },
+        displayStatus: {
+          type: /** @type {const} */ ('baseline-status'),
+          status: baselineTier,
+          displayString: displayStatus,
+        },
+        source: feature.source,
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {
+        key: 'featureId',
+        valueType: 'link',
+        label: str_(UIStrings.columnFeature),
+      },
+      {
+        key: 'displayStatus',
+        valueType: 'baseline-status',
+        label: str_(UIStrings.columnStatus),
+      },
+      {
+        key: 'source',
+        valueType: 'source-location',
+        label: str_(i18n.UIStrings.columnSource),
+      },
+    ];
+
+    /**
+     * Determines the sorting rank of a baseline status.
+     * @param {string} status The display status string.
+     * @return {number} The numerical rank (1 is the highest priority).
+     */
+    const getStatusRank = (status) => {
+      if (status.startsWith('Limited')) {
+        return 1;
+      }
+      if (status.startsWith('Newly')) {
+        return 2;
+      }
+      if (status.startsWith('Widely')) {
+        return 3;
+      }
+      return 4;
+    };
+
+    const sortedStatuses = baselineStatus.sort((featureA, featureB) => {
+      const rankA = getStatusRank(featureA.displayStatus.displayString);
+      const rankB = getStatusRank(featureB.displayStatus.displayString);
+
+      if (rankA !== rankB) {
+        return rankA - rankB;
+      }
+
+      const hasSourceA = !!featureA.source;
+      const hasSourceB = !!featureB.source;
+
+      if (hasSourceA !== hasSourceB) {
+        return hasSourceA ? -1 : 1;
+      }
+
+      return 0;
+    });
+
+    const details = Audit.makeTableDetails(headings, sortedStatuses);
+
+    return {
+      score: 1,
+      details,
+    };
+  }
+}
+
+export default Baseline;
+export {UIStrings};

package/core/computed/document-urls.js

@@ -41,8 +41,11 @@ class DocumentUrls {
     }
     if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
 
-    const initialRequest =
-      Lantern.Core.NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+    const initialRequest = Lantern.Core.NetworkAnalyzer.findResourceForUrl(
+      // @ts-expect-error - trace engine types for InitiatorType are outdated
+      networkRecords,
+      requestedUrl
+    );
     if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
 
     return {requestedUrl, mainDocumentUrl};

package/core/computed/main-resource.js

@@ -23,17 +23,21 @@ class MainResource {
     if (!mainDocumentUrl) throw new Error('mainDocumentUrl must exist to get the main resource');
     const records = await NetworkRecords.request(data.devtoolsLog, context);
 
-    // We could have more than one record matching the main doucment url,
+    // We could have more than one record matching the main document url,
     // if the page did `location.reload()`. Since `mainDocumentUrl` refers to the _last_
     // document request, we should return the last candidate here. Besides, the browser
     // would have evicted the first request by the time `MainDocumentRequest` (a consumer
     // of this computed artifact) attempts to fetch the contents, resulting in a protocol error.
-    const mainResource =
-      Lantern.Core.NetworkAnalyzer.findLastDocumentForUrl(records, mainDocumentUrl);
+    const mainResource = Lantern.Core.NetworkAnalyzer.findLastDocumentForUrl(
+      // @ts-expect-error - trace engine types for InitiatorType are outdated
+      records,
+      mainDocumentUrl
+    );
     if (!mainResource) {
       throw new Error('Unable to identify the main resource');
     }
 
+    // @ts-expect-error - Return type is typed as Lantern request by trace engine, but it is a raw record at runtime since we passed raw records.
     return mainResource;
   }
 }

package/core/computed/network-analysis.js

@@ -18,7 +18,10 @@ class NetworkAnalysis {
    */
   static async compute_(devtoolsLog, context) {
     const records = await NetworkRecords.request(devtoolsLog, context);
-    const analysis = Lantern.Core.NetworkAnalyzer.analyze(records);
+    const analysis = Lantern.Core.NetworkAnalyzer.analyze(
+      // @ts-expect-error - trace engine types for InitiatorType are outdated
+      records
+    );
     if (!analysis) {
       log.error('NetworkAnalysis', 'Network analysis failed due to lack of transfer data');
       return {

package/core/config/default-config.js

@@ -266,6 +266,7 @@ const defaultConfig = {
     'dobetterweb/js-libraries',
     'dobetterweb/notification-on-start',
     'dobetterweb/paste-preventing-inputs',
+    'baseline',
     'seo/meta-description',
     'seo/http-status-code',
     'seo/link-text',
@@ -559,6 +560,7 @@ const defaultConfig = {
         // Browser Compatibility
         {id: 'doctype', weight: 1, group: 'best-practices-browser-compat'},
         {id: 'charset', weight: 1, group: 'best-practices-browser-compat'},
+        {id: 'baseline', weight: 0, group: 'best-practices-browser-compat'},
         // General Group
         {id: 'js-libraries', weight: 0, group: 'best-practices-general'},
         {id: 'deprecations', weight: 5, group: 'best-practices-general'},

package/core/gather/driver/wait-for-condition.js

@@ -387,11 +387,21 @@ async function isPageHung(session) {
     await session.sendCommand('Runtime.evaluate', {
       expression: '"ping"',
       returnByValue: true,
-      timeout: 1000,
     });
 
     return false;
   } catch (err) {
+    // If the session has crashed, we want to rethrow that error instead of assuming it's a hang.
+    // session.sendCommand normally handles this, but if PROTOCOL_TIMEOUT wins the race,
+    // we might have missed the TARGET_CRASHED error.
+    try {
+      // Check if it's already crashed.
+      await Promise.race([session.onCrashPromise(), Promise.resolve()]);
+    } catch (crashErr) {
+      if (crashErr.code === 'TARGET_CRASHED') throw crashErr;
+    }
+
+    if (err.code === 'TARGET_CRASHED') throw err;
     return true;
   }
 }

package/core/gather/gatherers/trace.js

@@ -61,6 +61,9 @@ class Trace extends BaseGatherer {
       'disabled-by-default-devtools.v8-source-rundown-sources',
       'disabled-by-default-devtools.v8-source-rundown',
 
+      // Required for Baseline Audit to detect feature usage.
+      'blink.webdx_feature_usage',
+
       // Not used by Lighthouse (yet) but included for users that want JS samples when looking at
       // a trace collected by Lighthouse (e.g. "View Trace" workflow in DevTools)
       // TODO: Re-enable after investigating b/325659693

package/core/lib/baseline/web-features-metadata.json

@@ -0,0 +1,3 @@
+{
+  "date": "2026-03-18"
+}