browsertime 27.5.0 → 28.0.0

package/lib/chrome/trace/blocking-time.js

@@ -0,0 +1,189 @@
+/**
+ * Blocking-time attribution per URL and per kind of work.
+ *
+ * A top-level main-thread task longer than 50 ms blocks input for
+ * (duration - 50) ms — the same definition Lighthouse's Total
+ * Blocking Time uses. Knowing the page's TBT is one thing; knowing
+ * WHICH script produced it is what tells you what to fix first, so
+ * each blocking task is attributed to a URL:
+ *
+ * Top-level tasks are often anonymous wrappers (RunTask et al.) whose
+ * own attributableURLs is empty while the real work sits in child
+ * tasks. So instead of only looking at the top-level task's own URL
+ * chain, the whole subtree is walked and the task is attributed to
+ * the URL that contributed the most self-time (each node credited to
+ * its most-specific URL, attributableURLs.at(-1), the same choice
+ * script-costs.js makes). ParseHTML nodes carry no attributable URL
+ * (main-thread-tasks.js only reads URLs from script events and stack
+ * frames, and stays byte-equivalent for cpu.urls consumers), so here
+ * they fall back to the document URL in args.beginData.url — a page
+ * blocked by parsing its own big HTML gets attributed to that
+ * document instead of disappearing. Tasks where no node carries any
+ * URL go to the 'unknown' bucket — browser-internal work (GC, style,
+ * layout without a JS trigger) no script owns.
+ *
+ * Blocking time is also split by KIND of work: each blocking task's
+ * subtree self-time per task group (parseHTML, styleLayout,
+ * scriptEvaluation, …) is scaled to the task's blocking share and
+ * summed per window into `kinds`. The per-URL list says who to blame;
+ * the kinds split says what kind of fix applies — script blocking
+ * needs code changes, parse/style blocking needs a smaller document
+ * or cheaper CSS.
+ *
+ * Two windows are reported: the whole trace, and navigationStart →
+ * the last largestContentfulPaint::Candidate event (blocking time in
+ * that window is what delayed LCP). Task times from
+ * main-thread-tasks.js are ms rebased to the first task, while the
+ * navigationStart / LCP timestamps are raw trace µs — the window
+ * check therefore uses the task's raw event.ts instead of converting
+ * back and forth. When the trace has no LCP candidate the LCP window
+ * is omitted rather than guessed.
+ *
+ * Returns:
+ *   { totalBlockingTime, tasks, urls: [{ url, value, tasks }, …],
+ *     kinds: { styleLayout: ms, … },
+ *     beforeLargestContentfulPaint?: { totalBlockingTime, tasks,
+ *                                      urls: [...], kinds: {...} } }
+ * Times in ms rounded to one decimal; url lists sorted by value desc
+ * and noise-filtered to entries above 10 ms, matching cpu.urls.
+ * Kinds that round to 0 ms are omitted.
+ */
+
+import { getMainThreadTasks } from './main-thread-tasks.js';
+import { computeTraceOfTab } from './trace-of-tab.js';
+
+const BLOCKING_THRESHOLD_MS = 50;
+const REPORT_LIMIT_MS = 10;
+const UNKNOWN = 'unknown';
+
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function nodeUrl(node) {
+  const url = node.attributableURLs.at(-1);
+  if (url) return url;
+  if (node.event.name === 'ParseHTML') {
+    const beginData = node.event.args && node.event.args.beginData;
+    return beginData && beginData.url;
+  }
+}
+
+// One subtree walk computing both attributions for a blocking task:
+// the dominant URL (most self-time) and the self-time per task kind.
+function analyzeTask(task) {
+  const selfTimeByUrl = new Map();
+  const selfTimeByKind = new Map();
+  const stack = [task];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const url = nodeUrl(node);
+    if (url) {
+      selfTimeByUrl.set(url, (selfTimeByUrl.get(url) || 0) + node.selfTime);
+    }
+    const kind = node.group.id;
+    selfTimeByKind.set(kind, (selfTimeByKind.get(kind) || 0) + node.selfTime);
+    stack.push(...node.children);
+  }
+  let bestUrl;
+  let bestTime = 0;
+  for (const [url, time] of selfTimeByUrl) {
+    if (time > bestTime) {
+      bestUrl = url;
+      bestTime = time;
+    }
+  }
+  return { url: bestUrl || UNKNOWN, selfTimeByKind };
+}
+
+function newWindow() {
+  return {
+    totalBlockingTime: 0,
+    tasks: 0,
+    byUrl: new Map(),
+    byKind: new Map()
+  };
+}
+
+function addToWindow(window, task, blocking, analysis) {
+  window.totalBlockingTime += blocking;
+  window.tasks += 1;
+  let entry = window.byUrl.get(analysis.url);
+  if (!entry) {
+    entry = { url: analysis.url, value: 0, tasks: 0 };
+    window.byUrl.set(analysis.url, entry);
+  }
+  entry.value += blocking;
+  entry.tasks += 1;
+  // Scale each kind's subtree self-time to the task's blocking share,
+  // so the kinds sum to totalBlockingTime instead of raw durations.
+  for (const [kind, selfTime] of analysis.selfTimeByKind) {
+    const share = (selfTime / task.duration) * blocking;
+    window.byKind.set(kind, (window.byKind.get(kind) || 0) + share);
+  }
+}
+
+function finishWindow(window) {
+  const urls = [];
+  for (const entry of window.byUrl.values()) {
+    if (entry.value > REPORT_LIMIT_MS) {
+      entry.value = round(entry.value);
+      urls.push(entry);
+    }
+  }
+  urls.sort((a, b) => b.value - a.value);
+  const kinds = {};
+  for (const [kind, value] of [...window.byKind.entries()].toSorted(
+    (a, b) => b[1] - a[1]
+  )) {
+    const rounded = round(value);
+    if (rounded > 0) kinds[kind] = rounded;
+  }
+  return {
+    totalBlockingTime: round(window.totalBlockingTime),
+    tasks: window.tasks,
+    urls,
+    kinds
+  };
+}
+
+export function computeBlockingTime(trace) {
+  const { mainThreadEvents, timestamps } = computeTraceOfTab(trace);
+  const tasks = getMainThreadTasks(mainThreadEvents, timestamps.traceEnd);
+
+  let lcpEvent;
+  for (const event of trace.traceEvents) {
+    if (
+      event.name === 'largestContentfulPaint::Candidate' &&
+      (!lcpEvent || event.ts > lcpEvent.ts)
+    ) {
+      lcpEvent = event;
+    }
+  }
+
+  const total = newWindow();
+  const beforeLcp = newWindow();
+
+  for (const task of tasks) {
+    if (task.parent) continue;
+    if (task.duration <= BLOCKING_THRESHOLD_MS) continue;
+
+    const blocking = task.duration - BLOCKING_THRESHOLD_MS;
+    const analysis = analyzeTask(task);
+    addToWindow(total, task, blocking, analysis);
+
+    if (
+      lcpEvent &&
+      task.event.ts >= timestamps.navigationStart &&
+      task.event.ts < lcpEvent.ts
+    ) {
+      addToWindow(beforeLcp, task, blocking, analysis);
+    }
+  }
+
+  const result = finishWindow(total);
+  if (lcpEvent) {
+    result.beforeLargestContentfulPaint = finishWindow(beforeLcp);
+  }
+  return result;
+}

package/lib/chrome/trace/domain-breakdown.js

@@ -0,0 +1,86 @@
+/**
+ * First-party vs third-party main-thread rollup.
+ *
+ * cpu.urls answers "which URL costs the most main-thread time";
+ * this answers the level above it — how much of the main thread the
+ * site's own code uses versus embedded third parties, and which
+ * domains those third parties are. Each task's self-time is credited
+ * to its most-specific attributable URL (attributableURLs.at(-1),
+ * same choice as script-costs.js) so a task counts once — cpu.urls
+ * deliberately credits the full URL chain, which would double-count
+ * across domains here. Tasks with no attributable URL are
+ * browser-internal work no domain owns and are skipped.
+ *
+ * First-party is decided by registrable domain: the last two labels
+ * of the hostname, so every subdomain of the tested page's domain is
+ * first-party (en.wikipedia.org and upload.wikimedia.org roll up to
+ * wikipedia.org / wikimedia.org). Deliberately NOT a full public
+ * suffix list — two-level public suffixes (co.uk, com.au, …) group
+ * one label too high, which is acceptable for a rollup and avoids
+ * carrying an eTLD+1 dependency.
+ *
+ * Returns:
+ *   { firstPartyDomain, firstParty, thirdParty,
+ *     domains: [{ domain, value, firstParty }, …] }
+ * Times in ms rounded to one decimal; domains sorted by value desc
+ * and noise-filtered to entries above 10 ms, matching cpu.urls. The
+ * firstParty / thirdParty totals include the filtered-out remainder.
+ */
+
+import { compute } from './main-thread-tasks.js';
+
+const REPORT_LIMIT_MS = 10;
+
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+
+function registrableDomain(hostname) {
+  const labels = hostname.split('.');
+  return labels.length <= 2 ? hostname : labels.slice(-2).join('.');
+}
+
+function domainOf(url) {
+  try {
+    const { hostname } = new URL(url);
+    return hostname ? registrableDomain(hostname) : undefined;
+  } catch {
+    return;
+  }
+}
+
+export function computeDomainBreakdown(trace, pageUrl) {
+  const firstPartyDomain = registrableDomain(new URL(pageUrl).hostname);
+  const byDomain = new Map();
+
+  for (const task of compute(trace)) {
+    const url = task.attributableURLs.at(-1);
+    if (!url) continue;
+    const domain = domainOf(url);
+    if (!domain) continue;
+    byDomain.set(domain, (byDomain.get(domain) || 0) + task.selfTime);
+  }
+
+  let firstParty = 0;
+  let thirdParty = 0;
+  const domains = [];
+  for (const [domain, value] of byDomain) {
+    const isFirstParty = domain === firstPartyDomain;
+    if (isFirstParty) {
+      firstParty += value;
+    } else {
+      thirdParty += value;
+    }
+    if (value > REPORT_LIMIT_MS) {
+      domains.push({ domain, value: round(value), firstParty: isFirstParty });
+    }
+  }
+  domains.sort((a, b) => b.value - a.value);
+
+  return {
+    firstPartyDomain,
+    firstParty: round(firstParty),
+    thirdParty: round(thirdParty),
+    domains
+  };
+}

package/lib/chrome/trace/frame-stability.js

@@ -0,0 +1,135 @@
+/**
+ * Frame stability — how smoothly the compositor produced frames
+ * during the traced window. Jank (dropped frames, long gaps between
+ * visual updates) is invisible in load metrics; this surfaces it
+ * from the trace browsertime already records.
+ *
+ * Event shapes sampled from Chrome 150.0.7871.115 with the default
+ * browsertime trace categories. The frame pipeline shows up as
+ * `PipelineReporter` async events (cat
+ * `cc,benchmark,disabled-by-default-devtools.timeline.frame`), one
+ * b/e pair per frame attempt, paired via `id2.local` within a
+ * process. The `b` event carries `args.frame_reporter` with the
+ * final outcome: `state` (STATE_PRESENTED_ALL /
+ * STATE_PRESENTED_PARTIAL / STATE_DROPPED / STATE_NO_UPDATE_DESIRED),
+ * `affects_smoothness`, and `frame_sequence`. The `e` timestamp is
+ * when the frame reached the screen (presentation) for presented
+ * frames. The same frame_sequence can have several reporters
+ * (forked / main + impl), so outcomes are merged per sequence. The
+ * legacy instant events (BeginFrame, DrawFrame, DroppedFrame) are
+ * still emitted and were used to cross-check: DroppedFrame instants
+ * match STATE_DROPPED reporters with affects_smoothness=true.
+ *
+ * Only STATE_DROPPED frames flagged `affects_smoothness` are counted
+ * as dropped — Chrome also marks no-damage idle frames STATE_DROPPED
+ * and counting those would alarm on every static page.
+ *
+ * Returns: { presented, partial, dropped, effectiveFps, longestGap }
+ *   presented    — frames that reached the screen after
+ *                  navigationStart
+ *   partial      — subset of presented where the compositor
+ *                  presented without the main-thread update
+ *                  (STATE_PRESENTED_PARTIAL only)
+ *   dropped      — frames Chrome flags as dropped AND affecting
+ *                  smoothness (its own jank signal)
+ *   effectiveFps — presented frames over the first→last
+ *                  presentation span; omitted with <2 presentations
+ *   longestGap   — { duration, startTime } in ms relative to
+ *                  navigationStart, the longest time between two
+ *                  consecutive presented frames. On mostly-static
+ *                  pages this includes idle time (nothing to draw),
+ *                  so read it as "longest time between visual
+ *                  updates", not proof of jank; omitted with <2
+ *                  presentations
+ */
+
+import { computeTraceOfTab } from './trace-of-tab.js';
+
+const PRESENTED_STATES = new Set([
+  'STATE_PRESENTED_ALL',
+  'STATE_PRESENTED_PARTIAL'
+]);
+
+function round1(number_) {
+  return Math.round(number_ * 10) / 10;
+}
+
+export function computeFrameStability(trace) {
+  const { mainFrameIds, timestamps } = computeTraceOfTab(trace);
+  const navStart = timestamps.navigationStart;
+
+  const open = new Map();
+  const bySequence = new Map();
+  for (const event of trace.traceEvents) {
+    if (event.name !== 'PipelineReporter' || event.pid !== mainFrameIds.pid)
+      continue;
+    const id = (event.id2 && event.id2.local) || event.id;
+    if (event.ph === 'b') {
+      open.set(id, event);
+    } else if (event.ph === 'e') {
+      const begin = open.get(id);
+      if (!begin) continue;
+      open.delete(id);
+      if (event.ts < navStart) continue;
+      const reporter = (begin.args && begin.args.frame_reporter) || {};
+      if (reporter.frame_sequence === undefined) continue;
+      let frame = bySequence.get(reporter.frame_sequence);
+      if (!frame) {
+        frame = { presentedAll: false, presentedPartial: false };
+        bySequence.set(reporter.frame_sequence, frame);
+      }
+      if (PRESENTED_STATES.has(reporter.state)) {
+        if (reporter.state === 'STATE_PRESENTED_ALL') frame.presentedAll = true;
+        else frame.presentedPartial = true;
+        frame.presentationTs = Math.min(
+          frame.presentationTs ?? Number.POSITIVE_INFINITY,
+          event.ts
+        );
+      } else if (
+        reporter.state === 'STATE_DROPPED' &&
+        reporter.affects_smoothness === true
+      ) {
+        frame.dropped = true;
+      }
+    }
+  }
+
+  let presented = 0;
+  let partial = 0;
+  let dropped = 0;
+  const presentationTimes = [];
+  for (const frame of bySequence.values()) {
+    if (frame.presentedAll || frame.presentedPartial) {
+      presented++;
+      if (!frame.presentedAll) partial++;
+      presentationTimes.push(frame.presentationTs);
+    } else if (frame.dropped) {
+      dropped++;
+    }
+  }
+  presentationTimes.sort((a, b) => a - b);
+
+  let effectiveFps;
+  let longestGap;
+  if (presentationTimes.length >= 2) {
+    const spanSeconds = (presentationTimes.at(-1) - presentationTimes[0]) / 1e6;
+    if (spanSeconds > 0) {
+      effectiveFps = round1((presentationTimes.length - 1) / spanSeconds);
+    }
+    let worst = 0;
+    let worstStart = presentationTimes[0];
+    for (let index = 1; index < presentationTimes.length; index++) {
+      const gap = presentationTimes[index] - presentationTimes[index - 1];
+      if (gap > worst) {
+        worst = gap;
+        worstStart = presentationTimes[index - 1];
+      }
+    }
+    longestGap = {
+      duration: round1(worst / 1000),
+      startTime: round1((worstStart - navStart) / 1000)
+    };
+  }
+
+  return { presented, partial, dropped, effectiveFps, longestGap };
+}

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);
+}