lighthouse 13.5.0-dev.20261002 → 13.5.0-dev.20261006

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

@@ -78,6 +78,8 @@ const exclusions = {
 };
 
 for (const array of Object.values(exclusions)) {
+  // https://github.com/GoogleChrome/lighthouse/issues/17277
+  array.push('webmcp');
   // https://github.com/GoogleChrome/lighthouse/issues/14271
   array.push('lantern-idle-callback-short');
   // glitch is gone.

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

@@ -216,7 +216,9 @@ async function begin() {
     if (testDefnPath === coreTestDefnsPath) {
       const {createServers} = await import('../../fixtures/static-server.js');
       servers = await createServers();
-      takeNetworkRequestUrls = servers[0].takeRequestUrls.bind(servers[0]);
+      if (servers.length) {
+        takeNetworkRequestUrls = servers[0].takeRequestUrls.bind(servers[0]);
+      }
     }
 
     const prunedTestDefns = pruneExpectedNetworkRequests(testDefns, takeNetworkRequestUrls);
@@ -234,7 +236,7 @@ async function begin() {
 
     smokehouseResult = (await runSmokehouse(prunedTestDefns, options));
   } finally {
-    servers?.forEach(s => s.close());
+    if (servers) await Promise.all(servers.map(s => s.close()));
   }
 
   let smokehouseOutputDir;
@@ -244,7 +246,7 @@ async function begin() {
     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.
+    // Otherwise, write all results to disk when running locally.
     smokehouseOutputDir = `${LH_ROOT}/.tmp/smokehouse-output`;
     testResultsToOutput = smokehouseResult.testResults;
   }

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

@@ -73,6 +73,31 @@ describe('findDiffersences', () => {
       expected: {duration: '<100'},
       diffs: [{path: '.duration', actual: 100, expected: '<100'}],
     },
+    'range (negative 1)': {
+      actual: {duration: -3},
+      expected: {duration: '>-5'},
+      diffs: null,
+    },
+    'range (negative 2)': {
+      actual: {duration: -9},
+      expected: {duration: '-10 +/- 2'},
+      diffs: null,
+    },
+    'range (invalid numerical expectation without prefix)': {
+      actual: {duration: 3},
+      expected: {duration: '+/- 5'},
+      diffs: [{path: '.duration', actual: 3, expected: '+/- 5'}],
+    },
+    'range (invalid numerical expectation with prefix)': {
+      actual: {duration: 15},
+      expected: {duration: '10 < 20'},
+      diffs: [{path: '.duration', actual: 15, expected: '10 < 20'}],
+    },
+    'range (numeric actual vs array expected)': {
+      actual: {duration: 10},
+      expected: {duration: ['>0']},
+      diffs: [{path: '.duration', actual: 10, expected: ['>0']}],
+    },
 
     'array (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
@@ -112,6 +137,11 @@ describe('findDiffersences', () => {
       expected: {prices: {'3': {nested: '>3'}}},
       diffs: [{path: '.prices[3].nested', actual: 3, expected: '>3'}],
     },
+    'array (8)': {
+      actual: {prices: {0: 1, length: 1}},
+      expected: {prices: [1]},
+      diffs: [{path: '.prices.length', actual: {0: 1, length: 1}, expected: [1]}],
+    },
 
     '_includes (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
@@ -295,4 +325,39 @@ describe('getAssertionReport', () => {
     expect(report).toMatchObject({passed: 3, failed: 1});
     expect(clean(report.log)).toMatchSnapshot();
   });
+
+  it('asserts expected.lhr.userAgent', () => {
+    const passingReport = getAssertionReport({lhr, artifacts}, {
+      lhr: {
+        audits: {},
+        requestedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        finalDisplayedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        userAgent: /Chrome\//,
+      },
+    });
+    expect(passingReport).toMatchObject({passed: 4, failed: 0, log: ''});
+
+    const failingReport = getAssertionReport({lhr, artifacts}, {
+      lhr: {
+        audits: {},
+        requestedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        finalDisplayedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        userAgent: 'NotTheUserAgent',
+      },
+    });
+    expect(failingReport).toMatchObject({passed: 3, failed: 1});
+  });
+
+  it('lazily evaluates hostUserAgent only when chromium version check is used', () => {
+    const customLhr = structuredClone(lhr);
+    customLhr.environment.hostUserAgent = 'InvalidUserAgentWithoutChromeVersion';
+    const report = getAssertionReport({lhr: customLhr, artifacts}, {
+      lhr: {
+        audits: {},
+        requestedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        finalDisplayedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+      },
+    });
+    expect(report).toMatchObject({passed: 3, failed: 0, log: ''});
+  });
 });

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

@@ -30,7 +30,7 @@ import {chromiumVersionCheck} from './version-check.js';
  * @property {Difference[]|null} diffs
  */
 
-const NUMBER_REGEXP = /(?:\d|\.)+/.source;
+const NUMBER_REGEXP = /-?(?:\d|\.)+/.source;
 const OPS_REGEXP = /<=?|>=?|\+\/-|±/.source;
 // An optional number, optional whitespace, an operator, optional whitespace, a number.
 const NUMERICAL_EXPECTATION_REGEXP =
@@ -48,21 +48,27 @@ const NUMERICAL_EXPECTATION_REGEXP =
  * @return {boolean}
  */
 function matchesExpectation(actual, expected) {
-  if (typeof actual === 'number' && NUMERICAL_EXPECTATION_REGEXP.test(expected)) {
+  if (
+    typeof actual === 'number' &&
+    typeof expected === 'string' &&
+    NUMERICAL_EXPECTATION_REGEXP.test(expected)
+  ) {
     const parts = expected.match(NUMERICAL_EXPECTATION_REGEXP);
+    if (!parts) return false;
     const [, prefixNumber, operator, postfixNumber] = parts;
     switch (operator) {
       case '>':
-        return actual > postfixNumber;
+        return prefixNumber === undefined && actual > Number(postfixNumber);
       case '>=':
-        return actual >= postfixNumber;
+        return prefixNumber === undefined && actual >= Number(postfixNumber);
       case '<':
-        return actual < postfixNumber;
+        return prefixNumber === undefined && actual < Number(postfixNumber);
       case '<=':
-        return actual <= postfixNumber;
+        return prefixNumber === undefined && actual <= Number(postfixNumber);
       case '+/-':
       case '±':
-        return Math.abs(actual - prefixNumber) <= postfixNumber;
+        return prefixNumber !== undefined &&
+          Math.abs(actual - Number(prefixNumber)) <= Number(postfixNumber);
       default:
         throw new Error(`unexpected operator ${operator}`);
     }
@@ -117,21 +123,8 @@ function findDifferences(path, actual, expected) {
     const expectedValue = expected[key];
 
     if (key === '_includes') {
-      if (Array.isArray(actual)) {
-        inclExclCopy = [...actual];
-      } else if (typeof actual === 'object') {
-        inclExclCopy = Object.entries(actual);
-      }
-
       if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
-      if (!inclExclCopy) {
-        diffs.push({
-          path,
-          actual: 'Actual value is not an array or object',
-          expected,
-        });
-        continue;
-      }
+      inclExclCopy = Array.isArray(actual) ? [...actual] : Object.entries(actual);
 
       for (const expectedEntry of expectedValue) {
         const matchingIndex =
@@ -153,24 +146,11 @@ function findDifferences(path, actual, expected) {
     }
 
     if (key === '_excludes') {
-      // Re-use state from `_includes` check, if there was one.
-      if (!inclExclCopy) {
-        if (Array.isArray(actual)) {
-          // We won't be removing items, so we can just copy the reference.
-          inclExclCopy = actual;
-        } else if (typeof actual === 'object') {
-          inclExclCopy = Object.entries(actual);
-        }
-      }
-
       if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
+      // Re-use state from `_includes` check, if there was one.
       if (!inclExclCopy) {
-        diffs.push({
-          path,
-          actual: 'Actual value is not an array or object',
-          expected,
-        });
-        continue;
+        // We won't be removing items, so we can just copy the reference.
+        inclExclCopy = Array.isArray(actual) ? actual : Object.entries(actual);
       }
 
       const expectedExclusions = expectedValue;
@@ -201,7 +181,7 @@ function findDifferences(path, actual, expected) {
   // This still allows for asserting that the first n elements of an array are specified elements,
   // but requires using an object literal (ex: {0: x, 1: y, 2: z} matches [x, y, z, q, w, e] and
   // {0: x, 1: y, 2: z, length: 5} does not match [x, y, z].
-  if (Array.isArray(expected) && actual.length !== expected.length) {
+  if (Array.isArray(expected) && (!Array.isArray(actual) || actual.length !== expected.length)) {
     diffs.push({
       path: `${path}.length`,
       actual,
@@ -256,6 +236,7 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
    * @param {*} obj
    */
   function failsChromeVersionCheck(obj) {
+    if (!obj._minChromiumVersion && !obj._maxChromiumVersion) return false;
     return !chromiumVersionCheck({
       version: getChromeVersionString(),
       min: obj._minChromiumVersion,
@@ -376,6 +357,10 @@ function collateResults(localConsole, actual, expected) {
   /** @type {Comparison[]} */
   const extraAssertions = [];
 
+  if (expected.lhr.userAgent) {
+    extraAssertions.push(makeComparison('userAgent', actual.lhr.userAgent, expected.lhr.userAgent));
+  }
+
   if (expected.lhr.timing) {
     const comparison = makeComparison('timing', actual.lhr.timing, expected.lhr.timing);
     extraAssertions.push(comparison);
@@ -425,7 +410,7 @@ function reportAssertion(localConsole, assertion) {
   RegExp.prototype.toJSON = RegExp.prototype.toString;
 
   if (assertion.equal) {
-    if (isPlainObject(assertion.actual)) {
+    if (isPlainObject(assertion.actual) || Array.isArray(assertion.actual)) {
       localConsole.log(`  ${log.greenify(log.tick)} ${assertion.name}`);
     } else {
       localConsole.log(`  ${log.greenify(log.tick)} ${assertion.name}: ` +

package/cli/test/smokehouse/smokehouse.js

@@ -160,6 +160,8 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
   const bufferedConsole = new LocalConsole();
   bufferedConsole.log(`\n${purpleify(id)}: testing '${requestedUrl}'…`);
   for (let i = 0; i <= retries; i++) {
+    result = undefined;
+    report = undefined;
     if (i !== 0) {
       bufferedConsole.log(`  Retrying run (${i} out of ${retries} retries)…`);
     }
@@ -167,42 +169,54 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     const logger = new LocalConsole();
 
     // Run Lighthouse.
+    let isTimeout = false;
     try {
       // Each individual runner has internal timeouts, but we've had bugs where
       // that didn't cover some edge case. So to be safe give a (long) timeout here.
+      let timeoutId;
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() =>
-          reject(new Error('Timed out waiting for provided lighthouseRunner')), 1000 * 120);
+        timeoutId = setTimeout(() => {
+          isTimeout = true;
+          reject(new Error('Timed out waiting for provided lighthouseRunner'));
+        }, 1000 * 120);
       });
-      const timedResult = await Promise.race([
-        lighthouseRunner(requestedUrl, config, logger, mergedTestRunnerOptions),
-        timeoutPromise,
-      ]);
+      let timedResult;
+      try {
+        timedResult = await Promise.race([
+          lighthouseRunner(requestedUrl, config, logger, mergedTestRunnerOptions),
+          timeoutPromise,
+        ]);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+
+      if (!timedResult.lhr?.audits || !timedResult.artifacts) {
+        // Something went really wrong and the runner didn't catch it.
+        throw new Error('lighthouse runner returned a bad result. got lhr:\n' +
+          JSON.stringify(timedResult.lhr, null, 2));
+      }
+
       result = {
         ...timedResult,
         networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
         log: logger.getLog(),
       };
-
-      if (!result.lhr?.audits || !result.artifacts) {
-        // Something went really wrong and the runner didn't catch it.
-        throw new Error('lighthouse runner returned a bad result. got lhr:\n' +
-          JSON.stringify(result.lhr, null, 2));
-      }
     } catch (e) {
       // Clear the network requests so that when we retry, we don't see duplicates.
       if (takeNetworkRequestUrls) takeNetworkRequestUrls();
 
       logChildProcessError(bufferedConsole, e);
-      bufferedConsole.log('Timed out. log from lighthouseRunner:');
-      bufferedConsole.log(logger.getLog());
+      if (isTimeout) {
+        bufferedConsole.log('Timed out. log from lighthouseRunner:');
+        bufferedConsole.log(logger.getLog());
+      }
       continue; // Retry, if possible.
     }
 
     // Assert result.
     report = getAssertionReport(result, expectations, {
       runner: lighthouseRunner.runnerName,
-      ...testRunnerOptions,
+      ...mergedTestRunnerOptions,
     });
 
     runs.push({

package/cli/test/smokehouse/version-check-test.js

@@ -19,6 +19,10 @@ describe('version check', () => {
     expect(compareVersions([100, 0, 0, 0], [100])).toBe(0);
     expect(compareVersions([100, 0, 0, 1], [100])).toBe(1);
     expect(compareVersions([99, 0, 0, 0], [100])).toBe(-1);
+
+    expect(compareVersions([100], [100, 0, 0, 0])).toBe(0);
+    expect(compareVersions([100], [100, 0, 0, 1])).toBe(-1);
+    expect(compareVersions([101], [100, 0, 0, 1])).toBe(1);
   });
 
   it('chromiumVersionCheck', async () => {
@@ -27,6 +31,7 @@ describe('version check', () => {
     expect(chromiumVersionCheck({version: '100', max: '100'})).toBe(true);
     expect(chromiumVersionCheck({version: '100', min: '101'})).toBe(false);
     expect(chromiumVersionCheck({version: '100', max: '99'})).toBe(false);
+    expect(chromiumVersionCheck({version: '100', min: '100.0.1.0'})).toBe(false);
 
     expect(chromiumVersionCheck({version: '100.0.2331.3'})).toBe(true);
     expect(chromiumVersionCheck({version: '100.0.2331.3', min: '100.0.2331.3'})).toBe(true);

package/cli/test/smokehouse/version-check.js

@@ -22,7 +22,7 @@ function parseVersion(versionString) {
  * @param {number[]} versionB
  */
 function compareVersions(versionA, versionB) {
-  for (let i = 0; i < versionA.length; i++) {
+  for (let i = 0; i < Math.max(versionA.length, versionB.length); i++) {
     if ((versionA[i] ?? 0) > (versionB[i] ?? 0)) return 1;
     if ((versionA[i] ?? 0) < (versionB[i] ?? 0)) return -1;
   }

package/core/audits/baseline.d.ts

@@ -789,6 +789,16 @@ declare class Baseline extends Audit {
     };
     /**
      * Determines the baseline status and display string for a given feature ID.
+     *
+     * Baseline tiers & dates (built by `build/build-baseline-data.js`):
+     * - `limited`: `baseline === false` (Limited Availability — not yet in all core browsers, no date).
+     * - `low`: `baseline === 'low'` (Newly Available — in all core browsers; value is `baseline_low_date`).
+     * - `high`: `baseline === 'high'` (Widely Available — 30 months past `baseline_low_date`; note that
+     *   `featureData.high[id]` still stores the feature's `baseline_low_date`).
+     *
+     * If a feature in `featureData.low` has reached `baseline_low_date + 30 months <= currentDate` at runtime,
+     * we dynamically promote it from `low` (Newly Available) to `high` (Widely Available).
+     *
      * @param {string} featureId
      * @param {{high: Record<string, string>, low: Record<string, string>, limited: string[]}} featureData
      * @param {Date} currentDate
@@ -803,6 +813,10 @@ declare class Baseline extends Audit {
         baselineTier: "high" | "low" | "limited";
     } | null;
     /**
+     * Returns the `baseline_low_date` (YYYY-MM-DD, when the feature became Newly Available)
+     * for both `low` and `high` features, since `build/build-baseline-data.js` stores
+     * `baseline_low_date` in both `featureData.low` and `featureData.high`.
+     *
      * @param {string} featureId
      * @param {{high: Record<string, string>, low: Record<string, string>, limited: string[]}} featureData
      * @return {string|null}

package/core/audits/baseline.js

@@ -48,6 +48,16 @@ class Baseline extends Audit {
 
   /**
    * Determines the baseline status and display string for a given feature ID.
+   *
+   * Baseline tiers & dates (built by `build/build-baseline-data.js`):
+   * - `limited`: `baseline === false` (Limited Availability — not yet in all core browsers, no date).
+   * - `low`: `baseline === 'low'` (Newly Available — in all core browsers; value is `baseline_low_date`).
+   * - `high`: `baseline === 'high'` (Widely Available — 30 months past `baseline_low_date`; note that
+   *   `featureData.high[id]` still stores the feature's `baseline_low_date`).
+   *
+   * If a feature in `featureData.low` has reached `baseline_low_date + 30 months <= currentDate` at runtime,
+   * we dynamically promote it from `low` (Newly Available) to `high` (Widely Available).
+   *
    * @param {string} featureId
    * @param {{high: Record<string, string>, low: Record<string, string>, limited: string[]}} featureData
    * @param {Date} currentDate
@@ -92,6 +102,10 @@ class Baseline extends Audit {
   }
 
   /**
+   * Returns the `baseline_low_date` (YYYY-MM-DD, when the feature became Newly Available)
+   * for both `low` and `high` features, since `build/build-baseline-data.js` stores
+   * `baseline_low_date` in both `featureData.low` and `featureData.high`.
+   *
    * @param {string} featureId
    * @param {{high: Record<string, string>, low: Record<string, string>, limited: string[]}} featureData
    * @return {string|null}
@@ -103,9 +117,7 @@ class Baseline extends Audit {
     }
     if (featureId in featureData.high) {
       const highData = /** @type {Record<string, string>} */ (featureData.high);
-      const date = new Date(highData[featureId]);
-      date.setUTCMonth(date.getUTCMonth() - 30);
-      return date.toISOString().slice(0, 10);
+      return highData[featureId];
     }
     return null;
   }

package/core/audits/predictive-perf.js

@@ -76,8 +76,8 @@ class PredictivePerf extends Audit {
       pessimisticLCP: lcp.pessimisticEstimate.timeInMs,
 
       roughEstimateOfTTFB: timingSummary.metrics.timeToFirstByte,
-      roughEstimateOfLCPLoadStart: timingSummary.metrics.lcpLoadDelay,
-      roughEstimateOfLCPLoadEnd: timingSummary.metrics.lcpLoadDuration,
+      roughEstimateOfLCPLoadDelay: timingSummary.metrics.lcpLoadDelay,
+      roughEstimateOfLCPLoadDuration: timingSummary.metrics.lcpLoadDuration,
     };
 
     const score = Audit.computeLogNormalScore(

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

@@ -42,15 +42,15 @@ class LCPBreakdown {
       const throttleRatio = metricLcp / observedLcp;
 
       const unclampedLoadStart = (lcpRecord.networkRequestTime - timeOrigin) * throttleRatio;
-      const loadDelay = Math.max(ttfb, Math.min(unclampedLoadStart, metricLcp));
+      const loadStart = Math.max(ttfb, Math.min(unclampedLoadStart, metricLcp));
 
       const unclampedLoadEnd = (lcpRecord.networkEndTime - timeOrigin) * throttleRatio;
-      const loadDuration = Math.max(loadDelay, Math.min(unclampedLoadEnd, metricLcp));
+      const loadEnd = Math.max(loadStart, Math.min(unclampedLoadEnd, metricLcp));
 
       return {
         ttfb,
-        loadDelay,
-        loadDuration,
+        loadDelay: loadStart - ttfb,
+        loadDuration: loadEnd - loadStart,
       };
     }
 

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

@@ -401,12 +401,12 @@
     "oklab": "2023-05-09",
     "online": "2015-07-29",
     "opacity": "2015-07-29",
-    "opacity-svg": "≤2020-03-24",
+    "opacity-svg": "2020-03-24",
     "optional-catch-binding": "2020-01-15",
     "origin-private-file-system": "2023-03-27",
     "outline": "2023-03-27",
     "outlines": "2017-04-05",
-    "output": "≤2018-10-02",
+    "output": "2018-10-02",
     "overflow": "2023-09-18",
     "overflow-clip": "2022-09-12",
     "overflow-shorthand": "2020-03-24",

package/core/lib/page-functions.js

@@ -97,13 +97,10 @@ function getOuterHTMLSnippet(element, ignoreAttrs = [], snippetCharacterLimit =
   }
 
   try {
-    /** @type {Element} */
-    // @ts-expect-error - clone will be same type as element - see https://github.com/microsoft/TypeScript/issues/283
-    const clone = element.cloneNode();
-
-    // Prevent any potential side-effects by appending to a template element.
+    // Prevent any potential side-effects by cloning into a template element.
     // See https://github.com/GoogleChrome/lighthouse/issues/11465
     const template = element.ownerDocument.createElement('template');
+    const clone = template.content.ownerDocument.importNode(element);
     template.content.append(clone);
     ignoreAttrs.concat(autoFillIgnoreAttrs).forEach(attribute =>{
       clone.removeAttribute(attribute);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "13.5.0-dev.20261002",
+  "version": "13.5.0-dev.20261006",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -179,6 +179,7 @@
     "typed-query-selector": "^2.12.0",
     "typescript": "6.0.3",
     "wait-for-expect": "^3.0.2",
+    "web-features": "^3.40.0",
     "webtreemap-cdt": "^3.2.1"
   },
   "dependencies": {
@@ -186,7 +187,7 @@
     "@sentry/node": "^10.0.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
-    "axe-core": "^4.13.0",
+    "axe-core": "4.13.0",
     "chrome-launcher": "^1.2.2",
     "configstore": "^7.0.0",
     "csp_evaluator": "1.1.8",
@@ -206,7 +207,6 @@
     "speedline-core": "^1.4.3",
     "third-party-web": "^0.30.0",
     "tldts-icann": "^7.4.16",
-    "web-features": "^3.40.0",
     "ws": "^7.0.0",
     "yargs": "^17.3.1",
     "yargs-parser": "^21.0.0"