browsertime 27.5.0 → 28.1.0

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

@@ -0,0 +1,281 @@
+/**
+ * Per-function JS cost from the V8 sampling profiler
+ * (disabled-by-default-v8.cpu_profiler, enabled on --enableProfileRun).
+ * The task-based analyses (scriptCosts, moduleCosts) attribute
+ * main-thread time to a URL or module; the sampled stacks answer the
+ * next question — which function inside that script the time was
+ * spent in.
+ *
+ * The category emits one Profile event per profiled V8 thread and a
+ * stream of ProfileChunk events carrying incremental call-tree nodes,
+ * sampled node ids and µs deltas between samples. Only the profile
+ * started on the inspected tab's main thread is read: the Profile
+ * event is emitted on the profiled thread, while its chunks arrive on
+ * V8's sampling thread and are tied back via the shared profile id +
+ * pid.
+ *
+ * Each sample's delta is credited as self time to the sampled frame
+ * and as total time to every distinct frame on the sampled stack
+ * (recursion counted once) — the definitions DevTools' bottom-up view
+ * uses. Frames aggregate per function identity (name + script +
+ * source position), so a function called from many sites is one row.
+ *
+ * V8 meta frames ((root), (program), (idle), (garbage collector))
+ * carry codeType 'other' and are skipped — idle is not cost and GC is
+ * already in cpu.categories. Engine frames without a script URL
+ * (e.g. querySelectorAll) are kept: the cost is real, it just has no
+ * source position.
+ *
+ * When the optional `bundles` map (url → location resolver, built by
+ * the coverage path) knows a frame's URL, the frame's position is
+ * resolved to the owning module inside the concatenated bundle and
+ * reported as `module`. V8 call-frame positions are 0-based while the
+ * resolvers — and the reported line/column — are 1-based (the trace
+ * event / DevTools convention). Frame URLs longer than 1024 chars are
+ * truncated by V8; they are recovered via unique prefix match against
+ * the bundle map so the reported url matches cpu.urls / moduleCosts.
+ *
+ * Returns [{ functionName, url?, line?, column?, module?, selfTime,
+ * totalTime, callees? }, …] in ms rounded to one decimal, sorted by
+ * selfTime desc, noise-filtered to self time ≥ 1 ms and capped at 50
+ * rows. `callees` (top 5 ≥ 1 ms, [{ functionName, url?, module?,
+ * value }]) breaks a function's non-self time down by what it called,
+ * so orchestrators (loaders, dispatchers) whose total dwarfs their
+ * self time show what they actually ran. Empty array when the trace
+ * carries no profiler data (the category is only enabled on profile
+ * runs).
+ */
+
+import { findMainFrameIds } from './tracing-processor.js';
+
+const REPORT_LIMIT_US = 1000;
+const MAX_FUNCTIONS = 50;
+const CALLEE_LIMIT_US = 1000;
+const MAX_CALLEES = 5;
+// V8 truncates callFrame.url in the trace (observed at 1024 chars),
+// so long bundle URLs (MediaWiki load.php easily exceeds it) won't
+// exact-match the coverage-path bundle map or the rest of the result.
+const V8_URL_TRUNCATION_LIMIT = 1024;
+
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function functionKey(callFrame) {
+  return `${callFrame.functionName}|${callFrame.scriptId}|${callFrame.lineNumber}|${callFrame.columnNumber}`;
+}
+
+function isMetaFrame(callFrame) {
+  return callFrame.codeType === 'other';
+}
+
+// Recover the full bundle URL + resolver for a (possibly truncated)
+// frame URL. Exact match first; for truncation-length URLs fall back
+// to a unique prefix match, skipping when ambiguous.
+function findBundle(bundles, url) {
+  if (!bundles || !url) return;
+  const exact = bundles.get(url);
+  if (exact) return { url, resolver: exact };
+  if (url.length < V8_URL_TRUNCATION_LIMIT) return;
+  let match;
+  for (const [bundleUrl, resolver] of bundles) {
+    if (bundleUrl.startsWith(url)) {
+      if (match) return;
+      match = { url: bundleUrl, resolver };
+    }
+  }
+  return match;
+}
+
+export function computeFunctionCosts(trace, bundles) {
+  const events = trace.traceEvents;
+  const { pid, tid } = findMainFrameIds(events);
+
+  const profileIds = new Set();
+  for (const event of events) {
+    if (event.name === 'Profile' && event.pid === pid && event.tid === tid) {
+      profileIds.add(event.id);
+    }
+  }
+  if (profileIds.size === 0) return [];
+
+  const nodes = new Map();
+  const samples = [];
+  const timeDeltas = [];
+  for (const event of events) {
+    if (
+      event.name !== 'ProfileChunk' ||
+      event.pid !== pid ||
+      !profileIds.has(event.id)
+    ) {
+      continue;
+    }
+    const data = event.args && event.args.data;
+    if (!data) continue;
+    const cpuProfile = data.cpuProfile;
+    if (cpuProfile && cpuProfile.nodes) {
+      for (const node of cpuProfile.nodes) nodes.set(node.id, node);
+    }
+    if (cpuProfile && cpuProfile.samples) samples.push(...cpuProfile.samples);
+    if (data.timeDeltas) timeDeltas.push(...data.timeDeltas);
+  }
+  if (samples.length === 0) return [];
+
+  // Lazily-named frames can miss their url; recover it from another
+  // node in the same script.
+  const scriptUrls = new Map();
+  for (const node of nodes.values()) {
+    const callFrame = node.callFrame;
+    if (callFrame.url && callFrame.scriptId) {
+      scriptUrls.set(callFrame.scriptId, callFrame.url);
+    }
+  }
+
+  // Distinct function keys on each node's stack, for total time.
+  const stackKeys = new Map();
+  function keysForNode(nodeId) {
+    const cached = stackKeys.get(nodeId);
+    if (cached) return cached;
+    const node = nodes.get(nodeId);
+    if (!node) return new Set();
+    const keys = new Set(node.parent ? keysForNode(node.parent) : undefined);
+    if (!isMetaFrame(node.callFrame)) keys.add(functionKey(node.callFrame));
+    stackKeys.set(nodeId, keys);
+    return keys;
+  }
+
+  const functions = new Map();
+  const nodesByKey = new Map();
+  const childNodes = new Map();
+  for (const node of nodes.values()) {
+    if (node.parent !== undefined) {
+      let siblings = childNodes.get(node.parent);
+      if (!siblings) {
+        siblings = [];
+        childNodes.set(node.parent, siblings);
+      }
+      siblings.push(node);
+    }
+    const callFrame = node.callFrame;
+    if (isMetaFrame(callFrame)) continue;
+    const key = functionKey(callFrame);
+    if (!functions.has(key)) {
+      functions.set(key, { callFrame, selfUs: 0, totalUs: 0 });
+    }
+    let keyNodes = nodesByKey.get(key);
+    if (!keyNodes) {
+      keyNodes = [];
+      nodesByKey.set(key, keyNodes);
+    }
+    keyNodes.push(node);
+  }
+
+  // Per-node inclusive time (its subtree's samples) — the cost of the
+  // call-tree edge from its parent, which is what the callee
+  // breakdown aggregates.
+  const nodeTotals = new Map();
+  for (const [index, nodeId] of samples.entries()) {
+    const delta = timeDeltas[index];
+    // The first delta rebases against the profile start and can be
+    // negative or missing; skip rather than credit negative time.
+    if (!delta || delta <= 0) continue;
+    const node = nodes.get(nodeId);
+    if (!node) continue;
+    if (!isMetaFrame(node.callFrame)) {
+      functions.get(functionKey(node.callFrame)).selfUs += delta;
+    }
+    for (const key of keysForNode(nodeId)) {
+      functions.get(key).totalUs += delta;
+    }
+    for (
+      let ancestor = node;
+      ancestor;
+      ancestor =
+        ancestor.parent === undefined ? undefined : nodes.get(ancestor.parent)
+    ) {
+      nodeTotals.set(ancestor.id, (nodeTotals.get(ancestor.id) || 0) + delta);
+    }
+  }
+
+  // Where a function's non-self time went: for every call-tree node of
+  // the function, each child's inclusive time is credited to the
+  // child's function identity. Answers "what did this orchestrator
+  // run" for loader/dispatcher rows whose total dwarfs their self
+  // time. Direct recursion shows the inner occurrence as a callee of
+  // itself, same as DevTools' top-down tree.
+  function calleesFor(key) {
+    const byCallee = new Map();
+    for (const node of nodesByKey.get(key) || []) {
+      for (const child of childNodes.get(node.id) || []) {
+        if (isMetaFrame(child.callFrame)) continue;
+        const childUs = nodeTotals.get(child.id);
+        if (!childUs) continue;
+        const childKey = functionKey(child.callFrame);
+        let entry = byCallee.get(childKey);
+        if (!entry) {
+          entry = { callFrame: child.callFrame, us: 0 };
+          byCallee.set(childKey, entry);
+        }
+        entry.us += childUs;
+      }
+    }
+    const callees = [];
+    for (const { callFrame, us } of [...byCallee.values()].toSorted(
+      (a, b) => b.us - a.us
+    )) {
+      if (us < CALLEE_LIMIT_US || callees.length >= MAX_CALLEES) break;
+      const callee = {
+        functionName: callFrame.functionName || '(anonymous)',
+        value: round(us / 1000)
+      };
+      const url = callFrame.url || scriptUrls.get(callFrame.scriptId) || '';
+      const bundle = findBundle(bundles, url);
+      if (bundle) {
+        callee.url = bundle.url;
+      } else if (url) {
+        callee.url = url;
+      }
+      if (bundle && callFrame.lineNumber !== undefined) {
+        const module_ = bundle.resolver.resolve(
+          callFrame.lineNumber + 1,
+          callFrame.columnNumber === undefined ? 1 : callFrame.columnNumber + 1
+        );
+        if (module_) callee.module = module_.name;
+      }
+      callees.push(callee);
+    }
+    return callees;
+  }
+
+  const costs = [];
+  for (const [key, { callFrame, selfUs, totalUs }] of functions.entries()) {
+    if (selfUs < REPORT_LIMIT_US) continue;
+    const url = callFrame.url || scriptUrls.get(callFrame.scriptId) || '';
+    const cost = {
+      functionName: callFrame.functionName || '(anonymous)',
+      selfTime: round(selfUs / 1000),
+      totalTime: round(totalUs / 1000)
+    };
+    const bundle = findBundle(bundles, url);
+    if (bundle) {
+      cost.url = bundle.url;
+    } else if (url) {
+      cost.url = url;
+    }
+    if (callFrame.lineNumber !== undefined) {
+      cost.line = callFrame.lineNumber + 1;
+      cost.column =
+        callFrame.columnNumber === undefined ? 1 : callFrame.columnNumber + 1;
+      if (bundle) {
+        const module_ = bundle.resolver.resolve(cost.line, cost.column);
+        if (module_) cost.module = module_.name;
+      }
+    }
+    const callees = calleesFor(key);
+    if (callees.length > 0) cost.callees = callees;
+    costs.push(cost);
+  }
+
+  costs.sort((a, b) => b.selfTime - a.selfTime);
+  return costs.slice(0, MAX_FUNCTIONS);
+}

package/lib/chrome/trace/index.js

@@ -15,6 +15,13 @@ import { compute } from './main-thread-tasks.js';
 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';
 
 /**
  * Compute the hierarchical main-thread task tree for a trace.

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

@@ -0,0 +1,137 @@
+/**
+ * Per-module CPU attribution for script bundles that concatenate many
+ * logical modules into a single URL (e.g. MediaWiki ResourceLoader
+ * load.php responses). cpu.urls can only say "load.php used 267 ms of
+ * main thread"; this analysis splits that time across the modules
+ * inside each bundle so the owner of a slow module can be identified.
+ *
+ * This file is bundle-format agnostic. It walks the main-thread task
+ * tree and, for every task whose most-specific code location falls
+ * inside a known bundle URL, asks that bundle's resolver which module
+ * owns the source position. All knowledge about the bundle format
+ * (module delimiters, line/column → byte-offset math) lives in the
+ * resolver — see lib/chrome/mediawikiResourceLoader.js.
+ *
+ * Attribution rules per task (selfTime is exclusive of children, so
+ * nothing is counted twice):
+ *  - EvaluateScript / v8.compile / v8.compileModule on a bundle URL:
+ *    the event spans the whole script, not one module (module bodies
+ *    are only registered at evaluate time and executed later), so the
+ *    time goes to the bundle's `otherTime` bucket.
+ *  - FunctionCall: args.data carries the definition site of the
+ *    invoked function — resolve it to a module.
+ *  - Any other event with a stack trace: the innermost frame with a
+ *    URL decides — resolve when it is a bundle, skip the task when it
+ *    points at code outside any bundle.
+ *  - Tasks with no location of their own (layout, GC, microtasks
+ *    triggered by module code) fall back to the inherited
+ *    most-specific attributable URL; when that is a bundle the time
+ *    is in-bundle but not attributable to one module → `otherTime`.
+ *
+ * Because only a task's own most-specific location (or the inherited
+ * chain when it has none) is credited, the per-bundle sum of module
+ * selfTime + otherTime is always ≤ that URL's total in cpu.urls,
+ * which counts a task for every URL anywhere in its chain.
+ *
+ * Times are in ms rounded to one decimal, matching the sibling
+ * analyses. Modules that round to 0 are dropped; bundles are sorted
+ * by total time desc and modules by selfTime desc.
+ */
+
+import { compute } from './main-thread-tasks.js';
+
+const WHOLE_SCRIPT_EVENTS = new Set([
+  'EvaluateScript',
+  'v8.compile',
+  'v8.compileModule'
+]);
+
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function attributeTask(task, bundles) {
+  const event = task.event;
+  const argsData = (event.args && event.args.data) || {};
+
+  if (WHOLE_SCRIPT_EVENTS.has(event.name)) {
+    const url =
+      event.name === 'v8.compileModule' ? event.args.fileName : argsData.url;
+    return url && bundles.has(url) ? { url } : undefined;
+  }
+
+  if (event.name === 'FunctionCall' && argsData.url) {
+    const bundle = bundles.get(argsData.url);
+    if (!bundle) return;
+    return {
+      url: argsData.url,
+      module: bundle.resolve(argsData.lineNumber, argsData.columnNumber)
+    };
+  }
+
+  for (const frame of argsData.stackTrace || []) {
+    if (!frame.url) continue;
+    const bundle = bundles.get(frame.url);
+    if (!bundle) return;
+    return {
+      url: frame.url,
+      module: bundle.resolve(frame.lineNumber, frame.columnNumber)
+    };
+  }
+
+  const inherited = task.attributableURLs.at(-1);
+  return inherited && bundles.has(inherited) ? { url: inherited } : undefined;
+}
+
+/**
+ * @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, bundles) {
+  if (!bundles || bundles.size === 0) return [];
+
+  const byBundle = new Map();
+  for (const task of compute(trace)) {
+    if (!(task.selfTime > 0)) continue;
+    const attribution = attributeTask(task, bundles);
+    if (!attribution) continue;
+
+    let entry = byBundle.get(attribution.url);
+    if (!entry) {
+      entry = { byModule: new Map(), otherTime: 0 };
+      byBundle.set(attribution.url, entry);
+    }
+    const module = attribution.module;
+    if (module) {
+      const key = `${module.name}@${module.version}`;
+      const moduleEntry = entry.byModule.get(key);
+      if (moduleEntry) {
+        moduleEntry.selfTime += task.selfTime;
+      } else {
+        entry.byModule.set(key, { ...module, selfTime: task.selfTime });
+      }
+    } else {
+      entry.otherTime += task.selfTime;
+    }
+  }
+
+  const result = [];
+  for (const [url, entry] of byBundle) {
+    const modules = [];
+    let total = entry.otherTime;
+    for (const moduleEntry of entry.byModule.values()) {
+      total += moduleEntry.selfTime;
+      moduleEntry.selfTime = round(moduleEntry.selfTime);
+      if (moduleEntry.selfTime > 0) modules.push(moduleEntry);
+    }
+    modules.sort((a, b) => b.selfTime - a.selfTime);
+    result.push({ url, modules, otherTime: round(entry.otherTime), total });
+  }
+  result.sort((a, b) => b.total - a.total);
+  for (const entry of result) delete entry.total;
+  return result;
+}

package/lib/chrome/trace/non-composited-animations.js

@@ -10,20 +10,64 @@
  *
  * 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).
+ * `unsupportedProperties` strings. Chrome often omits the property
+ * list (the bitmask is the only signal), so the bitmask is decoded
+ * into `failureReasons` strings here — otherwise consumers show "an
+ * animation failed" with no way to say why.
  *
- * Returns: [{ name, id, compositeFailed, unsupportedProperties,
- *             startTime }, …]
+ * The bit meanings come from Blink's CompositorAnimations
+ * FailureReason enum (compositor_animations.h, kFailureReasonCount
+ * = 21 as of Chrome ~M140): bit values are stable and never reused,
+ * so decoding old traces is safe. Bits 8/11/14 are retired in
+ * current Blink but kept here for traces from older Chrome versions.
+ * Unknown future bits decode to 'unknown reason (bit N)' instead of
+ * being dropped.
+ *
+ * Returns: [{ name, id, compositeFailed, failureReasons,
+ *             unsupportedProperties, startTime }, …]
  *   name            — args.data.nodeName when present (rare)
  *   id              — args.data.id (compositor-internal)
  *   compositeFailed — bitmask of failure reasons
+ *   failureReasons  — the bitmask decoded to human-readable strings
  *   unsupportedProperties — array of property names that blocked
  *                           composite (e.g. ['top','box-shadow'])
  *   startTime       — event ts in microseconds (raw trace timestamp)
  */
 
+// Blink FailureReason bit → human-readable string, in bit order.
+const FAILURE_REASONS = [
+  'accelerated animations disabled', // 1 << 0
+  'effect suppressed by DevTools', // 1 << 1
+  'invalid animation or effect', // 1 << 2
+  'effect has unsupported timing parameters', // 1 << 3
+  "effect has composite mode other than 'replace'", // 1 << 4
+  'target has invalid compositing state', // 1 << 5
+  'target has another incompatible animation', // 1 << 6
+  'target has CSS offset', // 1 << 7
+  'target has multiple transform properties', // 1 << 8 (retired)
+  'animation affects non-CSS properties', // 1 << 9
+  'transform-related property cannot be accelerated on target', // 1 << 10
+  'transform-related property depends on box size', // 1 << 11 (retired)
+  'filter-related property may move pixels', // 1 << 12
+  'unsupported CSS property', // 1 << 13
+  'multiple transform animations on same target', // 1 << 14 (retired)
+  'mixed keyframe value types', // 1 << 15
+  'scroll timeline source has invalid compositing state', // 1 << 16
+  'animation has no visible change', // 1 << 17
+  'animation affects an !important property', // 1 << 18
+  'SVG target has independent transform property', // 1 << 19
+  "effect has iteration composite mode other than 'replace'" // 1 << 20
+];
+
+function decodeFailureReasons(bitmask) {
+  const reasons = [];
+  for (let bit = 0; bitmask >> bit > 0; bit++) {
+    if (((bitmask >> bit) & 1) === 0) continue;
+    reasons.push(FAILURE_REASONS[bit] || `unknown reason (bit ${bit})`);
+  }
+  return reasons;
+}
+
 export function computeNonCompositedAnimations(trace) {
   const seen = new Set();
   const animations = [];
@@ -46,6 +90,7 @@ export function computeNonCompositedAnimations(trace) {
       name: data.nodeName || '',
       id: data.id || '',
       compositeFailed: failed,
+      failureReasons: decodeFailureReasons(failed),
       unsupportedProperties: unsupported,
       startTime: event.ts
     });

package/lib/chrome/trace/selector-stats.js

@@ -0,0 +1,110 @@
+/**
+ * CSS selector matching cost, from Chrome's SelectorStats trace
+ * events (the disabled-by-default-blink.debug category, enabled on
+ * --enableProfileRun). For every style recalculation Chrome reports
+ * per-selector elapsed time, match attempts and match count — the
+ * same data DevTools' "CSS selector stats" checkbox shows. Style &
+ * layout often dominates main-thread blocking, and this is the only
+ * signal that says WHICH selectors the recalc time goes to.
+ *
+ * Selectors are aggregated across all recalcs in the trace. Two
+ * rankings matter and both are kept: elapsed time (what costs now)
+ * and match attempts with zero matches (pure waste — selectors
+ * evaluated against the whole document for rules that never apply,
+ * e.g. a lightbox selector on pages where the lightbox never opens).
+ *
+ * `styleSheetId` is Chrome's session-internal stylesheet handle —
+ * kept so consumers that also collect CSS coverage over CDP can join
+ * back to a stylesheet URL, but it is not stable across runs.
+ * 'ua-style-sheet' marks Chrome's own user-agent rules; those are
+ * not the page's to fix and are excluded from the reported lists
+ * (their time still counts in the totals).
+ *
+ * Returns undefined when the trace has no SelectorStats events (the
+ * category is only on for profile runs). Otherwise:
+ *   { totalElapsed, totalMatchAttempts, totalMatchCount,
+ *     selectors:      [{ selector, styleSheetId?, elapsed,
+ *                        matchAttempts, matchCount }, …],
+ *     wastedSelectors: [{ … same shape, matchCount always 0 }, …] }
+ * elapsed in ms with two decimals (individual selectors are sub-ms),
+ * both lists capped at 25 entries; selectors sorted by elapsed desc,
+ * wastedSelectors by matchAttempts desc.
+ */
+
+const MAX_SELECTORS = 25;
+const UA_STYLE_SHEET = 'ua-style-sheet';
+
+function round2(ms) {
+  return Math.round(ms * 100) / 100;
+}
+
+export function computeSelectorStats(trace) {
+  const bySelector = new Map();
+  let sawSelectorStats = false;
+  let totalElapsedUs = 0;
+  let totalMatchAttempts = 0;
+  let totalMatchCount = 0;
+
+  for (const event of trace.traceEvents) {
+    if (event.name !== 'SelectorStats') continue;
+    sawSelectorStats = true;
+    const timings =
+      (event.args &&
+        event.args.selector_stats &&
+        event.args.selector_stats.selector_timings) ||
+      [];
+    for (const timing of timings) {
+      const elapsedUs = timing['elapsed (us)'] || 0;
+      totalElapsedUs += elapsedUs;
+      totalMatchAttempts += timing.match_attempts || 0;
+      totalMatchCount += timing.match_count || 0;
+      if (timing.style_sheet_id === UA_STYLE_SHEET) continue;
+      const key = `${timing.selector}|${timing.style_sheet_id || ''}`;
+      let entry = bySelector.get(key);
+      if (!entry) {
+        entry = {
+          selector: timing.selector,
+          styleSheetId: timing.style_sheet_id,
+          elapsedUs: 0,
+          matchAttempts: 0,
+          matchCount: 0
+        };
+        bySelector.set(key, entry);
+      }
+      entry.elapsedUs += elapsedUs;
+      entry.matchAttempts += timing.match_attempts || 0;
+      entry.matchCount += timing.match_count || 0;
+    }
+  }
+  if (!sawSelectorStats) return;
+
+  function publish(entry) {
+    const result = {
+      selector: entry.selector,
+      elapsed: round2(entry.elapsedUs / 1000),
+      matchAttempts: entry.matchAttempts,
+      matchCount: entry.matchCount
+    };
+    if (entry.styleSheetId) result.styleSheetId = entry.styleSheetId;
+    return result;
+  }
+
+  const all = [...bySelector.values()];
+  const selectors = all
+    .toSorted((a, b) => b.elapsedUs - a.elapsedUs)
+    .slice(0, MAX_SELECTORS)
+    .map(entry => publish(entry));
+  const wastedSelectors = all
+    .filter(entry => entry.matchCount === 0)
+    .toSorted((a, b) => b.matchAttempts - a.matchAttempts)
+    .slice(0, MAX_SELECTORS)
+    .map(entry => publish(entry));
+
+  return {
+    totalElapsed: round2(totalElapsedUs / 1000),
+    totalMatchAttempts,
+    totalMatchCount,
+    selectors,
+    wastedSelectors
+  };
+}