browsertime 27.5.0 → 28.0.0

package/lib/chrome/trace/timer-costs.js

@@ -0,0 +1,183 @@
+/**
+ * Timer pressure per script — how much setTimeout/setInterval churn
+ * a page runs, from trace events already collected with
+ * --chrome.timeline.
+ *
+ * Two sides are joined per URL:
+ *  - TimerInstall events (instant): who schedules timers, how many,
+ *    how many with timeout 0 (the "yield" pattern that turns into
+ *    main-thread machine-gunning) and how many recurring
+ *    (setInterval / singleShot: false). Attribution from the
+ *    innermost stack frame with a URL.
+ *  - TimerFire tasks from the main-thread task tree: what running
+ *    those timers actually cost. main-thread-tasks.js already chains
+ *    TimerFire back to the installing script's URLs, so the cost
+ *    lands on the script that scheduled the timer even when the
+ *    callback is anonymous.
+ *
+ * Polling loops show up as a high install/fire count with recurring
+ * installs on one URL; oversliced work shows up as hundreds of
+ * timeout-0 installs. Fire time is inclusive task duration — what
+ * the main thread was occupied with when the timer ran.
+ *
+ * Returns undefined when the trace has no timer events. Otherwise:
+ *   { installs, fires, fireTime, timeoutZeroInstalls,
+ *     recurringInstalls,
+ *     byUrl: [{ url, installs, fires, fireTime,
+ *               timeoutZeroInstalls, recurringInstalls }, …],
+ *     sites: [{ url, line?, column?, functionName?, timeout,
+ *               recurring, installs, fires, fireTime }, …] }
+ * fireTime in ms with one decimal; byUrl sorted by fireTime desc,
+ * capped at 10 entries with sub-0.1 ms/zero-install rows dropped.
+ * `sites` lists the individual timers grouped by install site
+ * (installer source position + timeout + kind) — the closest thing
+ * to a timer's identity the trace offers — top 10 by fire time.
+ * Positions are 1-based (trace stack-frame convention).
+ */
+
+import { compute } from './main-thread-tasks.js';
+
+const MAX_URLS = 10;
+const MAX_SITES = 10;
+const UNKNOWN = 'unknown';
+
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function installFrame(data) {
+  for (const frame of data.stackTrace || []) {
+    if (frame.url) return frame;
+  }
+}
+
+export function computeTimerCosts(trace) {
+  const byUrl = new Map();
+  // Individual timers grouped by install site (installer source
+  // position + timeout + kind): a polling loop reinstalling from the
+  // same line collapses into one row with its install/fire counts.
+  const bySite = new Map();
+  const siteForTimerId = new Map();
+  let installs = 0;
+  let fires = 0;
+  let fireTimeMs = 0;
+  let timeoutZeroInstalls = 0;
+  let recurringInstalls = 0;
+
+  function entryFor(url) {
+    let entry = byUrl.get(url);
+    if (!entry) {
+      entry = {
+        url,
+        installs: 0,
+        fires: 0,
+        fireTimeMs: 0,
+        timeoutZeroInstalls: 0,
+        recurringInstalls: 0
+      };
+      byUrl.set(url, entry);
+    }
+    return entry;
+  }
+
+  for (const event of trace.traceEvents) {
+    if (event.name !== 'TimerInstall') continue;
+    const data = (event.args && event.args.data) || {};
+    const frame = installFrame(data);
+    const entry = entryFor(frame ? frame.url : UNKNOWN);
+    installs++;
+    entry.installs++;
+    const timeout = data.timeout || 0;
+    if (timeout === 0) {
+      timeoutZeroInstalls++;
+      entry.timeoutZeroInstalls++;
+    }
+    const recurring = data.singleShot === false;
+    if (recurring) {
+      recurringInstalls++;
+      entry.recurringInstalls++;
+    }
+
+    const siteKey = frame
+      ? `${frame.url}|${frame.lineNumber}|${frame.columnNumber}|${timeout}|${recurring}`
+      : `${UNKNOWN}|${timeout}|${recurring}`;
+    let site = bySite.get(siteKey);
+    if (!site) {
+      site = {
+        url: frame ? frame.url : UNKNOWN,
+        timeout,
+        recurring,
+        installs: 0,
+        fires: 0,
+        fireTimeMs: 0
+      };
+      if (frame) {
+        site.line = frame.lineNumber;
+        site.column = frame.columnNumber;
+        if (frame.functionName) site.functionName = frame.functionName;
+      }
+      bySite.set(siteKey, site);
+    }
+    site.installs++;
+    if (data.timerId !== undefined) siteForTimerId.set(data.timerId, site);
+  }
+
+  const tasks = compute(trace);
+  for (const task of tasks) {
+    if (task.event.name !== 'TimerFire') continue;
+    const entry = entryFor(task.attributableURLs.at(-1) || UNKNOWN);
+    fires++;
+    fireTimeMs += task.duration;
+    entry.fires++;
+    entry.fireTimeMs += task.duration;
+    const fireData = (task.event.args && task.event.args.data) || {};
+    const site = siteForTimerId.get(fireData.timerId);
+    if (site) {
+      site.fires++;
+      site.fireTimeMs += task.duration;
+    }
+  }
+
+  if (installs === 0 && fires === 0) return;
+
+  const urls = [...byUrl.values()]
+    .filter(entry => entry.fireTimeMs >= 0.1 || entry.installs > 0)
+    .toSorted((a, b) => b.fireTimeMs - a.fireTimeMs || b.installs - a.installs)
+    .slice(0, MAX_URLS)
+    .map(entry => ({
+      url: entry.url,
+      installs: entry.installs,
+      fires: entry.fires,
+      fireTime: round(entry.fireTimeMs),
+      timeoutZeroInstalls: entry.timeoutZeroInstalls,
+      recurringInstalls: entry.recurringInstalls
+    }));
+
+  const sites = [...bySite.values()]
+    .toSorted((a, b) => b.fireTimeMs - a.fireTimeMs || b.installs - a.installs)
+    .slice(0, MAX_SITES)
+    .map(site => {
+      const published = {
+        url: site.url,
+        timeout: site.timeout,
+        recurring: site.recurring,
+        installs: site.installs,
+        fires: site.fires,
+        fireTime: round(site.fireTimeMs)
+      };
+      if (site.line !== undefined) published.line = site.line;
+      if (site.column !== undefined) published.column = site.column;
+      if (site.functionName) published.functionName = site.functionName;
+      return published;
+    });
+
+  return {
+    installs,
+    fires,
+    fireTime: round(fireTimeMs),
+    timeoutZeroInstalls,
+    recurringInstalls,
+    byUrl: urls,
+    sites
+  };
+}

package/lib/chrome/webdriver/chromium.js

@@ -7,6 +7,10 @@ const log = getLogger('browsertime.chrome');
 const { Type } = logging;
 import { longTaskMetrics } from '../longTaskMetrics.js';
 import { parseCPUTrace } from '../parseCpuTrace.js';
+import { computeModuleCosts } from '../trace/module-costs.js';
+import { computeFunctionCosts } from '../trace/function-costs.js';
+import { computeStyleInvalidations } from '../trace/style-invalidations.js';
+import { labelForUrl } from '../mediawikiResourceLoader.js';
 import { getHar } from '../har.js';
 import { getEmptyHAR, mergeHars } from '../../support/har/index.js';
 import { toArray } from '../../support/util.js';
@@ -335,6 +339,12 @@ export class Chromium {
       const coverage = await this.coverage.collect();
       this.coverage = undefined;
       if (coverage) {
+        // Bundle location resolvers are plumbing for the CPU trace
+        // parser (per-module CPU attribution), not part of the
+        // coverage result contract — lift them off before the
+        // coverage object is serialized.
+        this.resourceLoaderBundles = coverage.resourceLoaderBundles;
+        delete coverage.resourceLoaderBundles;
         result.coverage = coverage;
       }
     }
@@ -416,6 +426,110 @@ export class Chromium {
       result.extraJson[name] = trace;
 
       const cpu = await parseCPUTrace(trace, result.url);
+
+      // Per-module CPU inside concatenated bundles (MediaWiki
+      // ResourceLoader). The only analysis that needs both the trace
+      // and the bundle boundaries from the coverage path, so it runs
+      // here where the two meet — only when coverage found bundles on
+      // the page, otherwise zero cost and no output key.
+      if (this.resourceLoaderBundles && this.resourceLoaderBundles.size > 0) {
+        try {
+          const moduleCosts = computeModuleCosts(
+            trace,
+            this.resourceLoaderBundles
+          );
+          if (moduleCosts.length > 0) {
+            for (const bundle of moduleCosts) {
+              const label = labelForUrl(bundle.url);
+              if (label) {
+                bundle.label = label;
+              }
+            }
+            cpu.moduleCosts = moduleCosts;
+          }
+        } catch (error) {
+          log.debug('computeModuleCosts failed: %s', error.message);
+        }
+      }
+      // Per-function self/total time from the V8 sampling profiler —
+      // only produces output on runs with the cpu_profiler trace
+      // category (--enableProfileRun). Reuses the bundle resolvers so
+      // functions inside concatenated bundles get a module name.
+      try {
+        const functionCosts = computeFunctionCosts(
+          trace,
+          this.resourceLoaderBundles
+        );
+        if (functionCosts.length > 0) {
+          for (const functionCost of functionCosts) {
+            const label = labelForUrl(functionCost.url);
+            if (label) {
+              functionCost.label = label;
+            }
+            for (const callee of functionCost.callees || []) {
+              const calleeLabel = labelForUrl(callee.url);
+              if (calleeLabel) {
+                callee.label = calleeLabel;
+              }
+            }
+          }
+          cpu.functionCosts = functionCosts;
+        }
+      } catch (error) {
+        log.debug('computeFunctionCosts failed: %s', error.message);
+      }
+      // Invalidation sources resolve to modules the same way —
+      // thousands of invalidations from one giant load.php URL say
+      // nothing, the per-module split says whose code churns the
+      // DOM. Recomputing with the bundles replaces the unresolved
+      // sources parseCpuTrace produced.
+      if (
+        cpu.styleInvalidations &&
+        this.resourceLoaderBundles &&
+        this.resourceLoaderBundles.size > 0
+      ) {
+        try {
+          const enriched = computeStyleInvalidations(
+            trace,
+            this.resourceLoaderBundles
+          );
+          if (enriched) {
+            for (const source of enriched.sources) {
+              const label = labelForUrl(source.url);
+              if (label) {
+                source.label = label;
+              }
+            }
+            cpu.styleInvalidations = enriched;
+          }
+        } catch (error) {
+          log.debug(
+            'computeStyleInvalidations with bundles failed: %s',
+            error.message
+          );
+        }
+      }
+      // Timer install sites inside concatenated bundles resolve to
+      // the owning module — "load.php[scripts]:418" says nothing,
+      // the module name says whose timer it is. Trace stack-frame
+      // positions are 1-based, matching the resolvers.
+      if (
+        cpu.timers &&
+        cpu.timers.sites &&
+        this.resourceLoaderBundles &&
+        this.resourceLoaderBundles.size > 0
+      ) {
+        for (const site of cpu.timers.sites) {
+          if (site.line === undefined) continue;
+          const resolver = this.resourceLoaderBundles.get(site.url);
+          if (!resolver) continue;
+          const module_ = resolver.resolve(site.line, site.column);
+          if (module_) {
+            site.module = module_.name;
+          }
+        }
+      }
+      this.resourceLoaderBundles = undefined;
       result.cpu = cpu;
 
       // Collect render blocking info

package/lib/chrome/webdriver/traceUtilities.js

@@ -52,12 +52,22 @@ function getRecalculateStyleElementsAndTimeBefore(traceEvents, timestamp) {
   );
   let elements = 0;
   let duration = 0;
+  let maxElements = 0;
+  let maxDuration = 0;
   for (let a of updateLayoutTree) {
     elements += a.args.elementCount;
     duration += a.dur;
+    maxElements = Math.max(maxElements, a.args.elementCount);
+    maxDuration = Math.max(maxDuration, a.dur);
   }
 
-  return { elements, durationInMillis: duration / 1000 };
+  return {
+    count: updateLayoutTree.length,
+    elements,
+    durationInMillis: duration / 1000,
+    maxElements,
+    maxDurationInMillis: maxDuration / 1000
+  };
 }
 
 export async function getRenderBlocking(trace) {

package/lib/core/engine/collector.js

@@ -136,6 +136,18 @@ export class Collector {
     }
   }
 
+  // Header values are strings so they are kept out of the statistics.
+  addMainDocument(url, mainDocument) {
+    const results =
+      this.allResults[url] || this.allResults[this.urlAndActualUrl[url]];
+    if (results) {
+      if (!results.mainDocument) {
+        results.mainDocument = [];
+      }
+      results.mainDocument.push(mainDocument);
+    }
+  }
+
   /**
    * Collect all individual runs, add it to the statistics, and store
    * data that needs to be on disk (trace logs, sceenshots etc).

package/lib/core/engine/index.js

@@ -18,6 +18,7 @@ import {
 import {
   getFullyLoaded,
   getMainDocumentTimings,
+  getMainDocuments,
   addExtraFieldsToHar
 } from '../../support/har/index.js';
 import { XVFB } from '../../support/xvfb.js';
@@ -374,6 +375,11 @@ export class Engine {
       for (let timing of timings) {
         collector.addMainDocumentTimings(timing.url, timing.timings);
       }
+
+      const mainDocuments = getMainDocuments(extras.har);
+      for (let document of mainDocuments) {
+        collector.addMainDocument(document.url, document.mainDocument);
+      }
     }
   }
 

package/lib/support/cli.js

@@ -51,7 +51,7 @@ function hasbin(bin) {
 function validateInput(argv) {
   // Check NodeJS major version
   const fullVersion = process.versions.node;
-  const minVersion = 20;
+  const minVersion = 22;
   const majorVersion = fullVersion.split('.')[0];
   if (majorVersion < minVersion) {
     return (

package/lib/support/har/index.js

@@ -269,6 +269,45 @@ export function getMainDocumentTimings(har) {
     return [];
   }
 }
+export function getMainDocuments(har) {
+  // Sometimes the HAR is dirty
+  try {
+    const mainDocuments = [];
+    for (let page of har.log.pages) {
+      const url = page._url;
+      if (url === undefined) continue;
+
+      const requests = getDocumentRequests(har.log.entries, page.id);
+      const finalEntry = requests.at(-1);
+      if (!finalEntry) continue;
+
+      const headers = {};
+      for (let header of finalEntry.response.headers || []) {
+        const name = header.name.toLowerCase();
+        // Always drop sensitive headers (the same list as
+        // --cleanSensitiveHeaders uses) since browsertime.json often ends
+        // up in dashboards even when the HAR stays local.
+        if (isSensitiveHeader(name)) continue;
+        headers[name] =
+          name in headers ? headers[name] + ', ' + header.value : header.value;
+      }
+
+      mainDocuments.push({
+        url,
+        mainDocument: {
+          url: finalEntry.request.url,
+          status: finalEntry.response.status,
+          redirects: requests.length - 1,
+          headers
+        }
+      });
+    }
+    return mainDocuments;
+  } catch (error) {
+    log.error('Could not get main document headers ' + error);
+    return [];
+  }
+}
 export function getFullyLoaded(har) {
   const fullyLoaded = [];
   const entries = [...har.log.entries];
@@ -464,8 +503,12 @@ export function addExtraFieldsToHar(totalResults, har, options) {
   }
 }
 
+export function isSensitiveHeader(name) {
+  return sensitiveHeaders.has(name.toLowerCase());
+}
+
 export function cleanSensitiveHeaders(name, value) {
-  if (sensitiveHeaders.has(name.toLowerCase())) {
+  if (isSensitiveHeader(name)) {
     return '[REMOVED]';
   }
   return value;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "browsertime",
   "description": "Get performance metrics from your web page using Browsertime.",
-  "version": "27.5.0",
+  "version": "28.0.0",
   "bin": "./bin/browsertime.js",
   "type": "module",
   "types": "./scripting.d.ts",
@@ -11,7 +11,7 @@
     "@sitespeed.io/edgedriver": "149.0.4022",
     "@sitespeed.io/geckodriver": "0.36.2",
     "@sitespeed.io/log": "2.0.0",
-    "@sitespeed.io/throttle": "6.0.0",
+    "@sitespeed.io/throttle": "6.0.1",
     "chrome-har": "1.3.1",
     "chrome-remote-interface": "0.34.0",
     "execa": "9.6.1",
@@ -40,7 +40,7 @@
     "typescript": "5.9.3"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "files": [
     "CHANGELOG.md",
@@ -92,7 +92,7 @@
     "url": "https://github.com/sitespeedio/browsertime.git"
   },
   "homepage": "https://www.sitespeed.io/documentation/browsertime/",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "ava": {
     "files": [
       "test/**/*",

package/types/chrome/mediawikiResourceLoader.d.ts

@@ -0,0 +1,11 @@
+export function isResourceLoaderBundle(url: any, source: any): any;
+export function labelForUrl(url: any): string;
+export function labelForStyleAttributes(attributes: any): any;
+export function resourceLoaderLocationResolver(source: any): {
+    resolve(lineNumber: any, columnNumber: any): {
+        name: any;
+        version: any;
+    };
+};
+export function resourceLoaderModuleCoverage(source: any, painted: any): any;
+//# sourceMappingURL=mediawikiResourceLoader.d.ts.map

package/types/chrome/mediawikiResourceLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediawikiResourceLoader.d.ts","sourceRoot":"","sources":["../../lib/chrome/mediawikiResourceLoader.js"],"names":[],"mappings":"AAmBA,mEAEC;AA6DD,8CAuBC;AAcD,8DAUC;AAwBD;;;;;EAkCC;AAOD,6EA4BC"}

package/types/chrome/parseCpuTrace.d.ts

@@ -1,27 +1,2 @@
-export function parseCPUTrace(tracelog: any, url: any): Promise<{
-    categories: {
-        parseHTML: number;
-        styleLayout: number;
-        paintCompositeRender: number;
-        scriptParseCompile: number;
-        scriptEvaluation: number;
-        garbageCollection: number;
-        other: number;
-    };
-    events: {};
-    urls: {
-        url: string;
-        value: number;
-    }[];
-    scriptCosts: any[];
-    forcedReflows: any[];
-    nonCompositedAnimations: any[];
-} | {
-    categories?: undefined;
-    events?: undefined;
-    urls?: undefined;
-    scriptCosts?: undefined;
-    forcedReflows?: undefined;
-    nonCompositedAnimations?: undefined;
-}>;
+export function parseCPUTrace(tracelog: any, url: any): Promise<{}>;
 //# sourceMappingURL=parseCpuTrace.d.ts.map

package/types/chrome/parseCpuTrace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseCpuTrace.d.ts","sourceRoot":"","sources":["../../lib/chrome/parseCpuTrace.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GA2GC"}
+{"version":3,"file":"parseCpuTrace.d.ts","sourceRoot":"","sources":["../../lib/chrome/parseCpuTrace.js"],"names":[],"mappings":"AAoCA,oEA8KC"}

package/types/chrome/trace/blocking-time.d.ts

@@ -0,0 +1,7 @@
+export function computeBlockingTime(trace: any): {
+    totalBlockingTime: number;
+    tasks: any;
+    urls: any[];
+    kinds: {};
+};
+//# sourceMappingURL=blocking-time.d.ts.map

package/types/chrome/trace/blocking-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocking-time.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/blocking-time.js"],"names":[],"mappings":"AAqJA;;;;;EAuCC"}

package/types/chrome/trace/domain-breakdown.d.ts

@@ -0,0 +1,11 @@
+export function computeDomainBreakdown(trace: any, pageUrl: any): {
+    firstPartyDomain: any;
+    firstParty: number;
+    thirdParty: number;
+    domains: {
+        domain: any;
+        value: number;
+        firstParty: boolean;
+    }[];
+};
+//# sourceMappingURL=domain-breakdown.d.ts.map

package/types/chrome/trace/domain-breakdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-breakdown.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/domain-breakdown.js"],"names":[],"mappings":"AAmDA;;;;;;;;;EAkCC"}

package/types/chrome/trace/frame-stability.d.ts

@@ -0,0 +1,11 @@
+export function computeFrameStability(trace: any): {
+    presented: number;
+    partial: number;
+    dropped: number;
+    effectiveFps: number;
+    longestGap: {
+        duration: number;
+        startTime: number;
+    };
+};
+//# sourceMappingURL=frame-stability.d.ts.map

package/types/chrome/trace/frame-stability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-stability.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/frame-stability.js"],"names":[],"mappings":"AAwDA;;;;;;;;;EA8EC"}

package/types/chrome/trace/function-costs.d.ts

@@ -0,0 +1,6 @@
+export function computeFunctionCosts(trace: any, bundles: any): {
+    functionName: any;
+    selfTime: number;
+    totalTime: number;
+}[];
+//# sourceMappingURL=function-costs.d.ts.map

package/types/chrome/trace/function-costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-costs.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/function-costs.js"],"names":[],"mappings":"AAyFA;;;;IA+LC"}

package/types/chrome/trace/index.d.ts

@@ -16,4 +16,11 @@ export function computeMainThreadTasks(trace: any, options?: {
 export { computeScriptCosts } from "./script-costs.js";
 export { computeForcedReflows } from "./forced-reflows.js";
 export { computeNonCompositedAnimations } from "./non-composited-animations.js";
+export { computeFrameStability } from "./frame-stability.js";
+export { computeFunctionCosts } from "./function-costs.js";
+export { computeStyleInvalidations } from "./style-invalidations.js";
+export { computeSelectorStats } from "./selector-stats.js";
+export { computeTimerCosts } from "./timer-costs.js";
+export { computeBlockingTime } from "./blocking-time.js";
+export { computeDomainBreakdown } from "./domain-breakdown.js";
 //# sourceMappingURL=index.d.ts.map

package/types/chrome/trace/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/index.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH,6DAJG;IAA0B,OAAO,GAAzB,OAAO;CAEf,GAAU,KAAK,KAAQ,CAYzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/index.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH,6DAJG;IAA0B,OAAO,GAAzB,OAAO;CAEf,GAAU,KAAK,KAAQ,CAYzB"}

package/types/chrome/trace/module-costs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @param {Object} trace  Parsed Chrome trace.json (with .traceEvents).
+ * @param {Map<string, {resolve: Function}>} bundles  Bundle URL →
+ *   location resolver, built while collecting coverage.
+ * @returns {Array<{url:string,
+ *   modules:Array<{name:string, version:string, selfTime:number}>,
+ *   otherTime:number}>}
+ */
+export function computeModuleCosts(trace: any, bundles: Map<string, {
+    resolve: Function;
+}>): Array<{
+    url: string;
+    modules: Array<{
+        name: string;
+        version: string;
+        selfTime: number;
+    }>;
+    otherTime: number;
+}>;
+//# sourceMappingURL=module-costs.d.ts.map

package/types/chrome/trace/module-costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-costs.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/module-costs.js"],"names":[],"mappings":"AAqFA;;;;;;;GAOG;AACH,wDANW,GAAG,CAAC,MAAM,EAAE;IAAC,OAAO,WAAU;CAAC,CAAC,GAE9B,KAAK,CAAC;IAAC,GAAG,EAAC,MAAM,CAAC;IAC1B,OAAO,EAAC,KAAK,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAC,OAAO,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAA;KAAC,CAAC,CAAC;IAC9D,SAAS,EAAC,MAAM,CAAA;CAAC,CAAC,CA6CtB"}

package/types/chrome/trace/non-composited-animations.d.ts

@@ -1,32 +1,8 @@
-/**
- * Non-composited animations — animations that triggered Layout or
- * Paint instead of running entirely on the compositor thread.
- *
- * Compositor-only animations (transform, opacity) hand off to the
- * GPU and don't block the main thread. Anything that touches
- * `top` / `left` / `width` / `box-shadow` / non-transformable
- * filters / etc. forces a per-frame layout or paint, which means
- * jank on busy main threads.
- *
- * Chrome marks these in the trace via `Animation` events whose
- * `args.data.compositeFailed` bitmask is non-zero, plus a list of
- * `unsupportedProperties` strings. We surface the raw values; the
- * consumer can map the bitmask to human reasons (see Lighthouse's
- * non-composited-animations audit for the canonical mapping).
- *
- * Returns: [{ name, id, compositeFailed, unsupportedProperties,
- *             startTime }, …]
- *   name            — args.data.nodeName when present (rare)
- *   id              — args.data.id (compositor-internal)
- *   compositeFailed — bitmask of failure reasons
- *   unsupportedProperties — array of property names that blocked
- *                           composite (e.g. ['top','box-shadow'])
- *   startTime       — event ts in microseconds (raw trace timestamp)
- */
 export function computeNonCompositedAnimations(trace: any): {
     name: any;
     id: any;
     compositeFailed: any;
+    failureReasons: string[];
     unsupportedProperties: any;
     startTime: any;
 }[];