browsertime 27.0.4 → 27.2.0

package/lib/chrome/trace/task-groups.js

@@ -0,0 +1,196 @@
+/**
+ * Trace-event → group classifier.
+ *
+ * The original list (from @sitespeed.io/tracium 0.3.3, extracted from
+ * Lighthouse circa 2017) is too narrow for modern Chrome traces — it
+ * only knew about ~30 event names, so half the trace fell through to
+ * "other" on a busy 2026-era page. This expanded list adds the
+ * events we actually see today, drawing from:
+ *
+ *   - Modern Lighthouse `core/lib/tracehouse/task-groups.js`
+ *   - WebPageTest's `MAIN_THREAD_CATEGORY_MAP` in waterfall-tools
+ *     (`src/core/mainthread-categories.js`, mirroring the reference
+ *     PHP implementation at Sample/Implementations/webpagetest/
+ *     www/waterfall.inc#L437-L491)
+ *   - Direct sampling of trace.json from real cnet / theverge runs
+ *
+ * The seven-bucket structure is unchanged so the existing UI
+ * categories keep working. Append-only when adding events for
+ * future Chrome versions — don't move events between groups
+ * without checking how it affects the rollups in
+ * `parseCpuTrace.js`.
+ */
+
+export const taskGroups = {
+  parseHTML: {
+    id: 'parseHTML',
+    label: 'Parse HTML & CSS',
+    traceEventNames: [
+      'ParseHTML',
+      'ParseAuthorStyleSheet',
+      // Document parsing / navigation pipeline — these fire during
+      // the initial HTML/CSS parse phase, even though they're not
+      // strictly "parse" events. Counting them as parse-time gives
+      // a more honest "time spent loading the document" signal.
+      'CommitLoad',
+      'DocumentLoader::CommitNavigation',
+      'DecodedDataDocumentParser::AppendBytes',
+      // Resource lifecycle events emitted on the main thread for
+      // the document and its sub-resources. waterfall-tools groups
+      // them with parsing for the same reason — they're part of the
+      // page-load critical path, not arbitrary "other" work.
+      'ResourceSendRequest',
+      'ResourceReceiveResponse',
+      'ResourceReceivedData',
+      'ResourceReceivedResponse',
+      'ResourceFinish'
+    ]
+  },
+  styleLayout: {
+    id: 'styleLayout',
+    label: 'Style & Layout',
+    traceEventNames: [
+      'ScheduleStyleRecalculation',
+      'UpdateLayoutTree', // previously RecalculateStyles
+      'RecalculateStyles', // older Chrome name
+      'InvalidateLayout',
+      'Layout',
+      // IntersectionObserver callbacks query layout to compute
+      // which observed elements have crossed their thresholds; on
+      // ad-heavy pages this can be hundreds of ms.
+      'IntersectionObserverController::computeIntersections'
+    ]
+  },
+  paintCompositeRender: {
+    id: 'paintCompositeRender',
+    label: 'Rendering',
+    traceEventNames: [
+      'Animation',
+      'HitTest',
+      'PaintSetup',
+      'Paint',
+      'PaintImage',
+      'RasterTask', // Previously Rasterize
+      'Rasterize',
+      'ScrollLayer',
+      'UpdateLayer',
+      'UpdateLayerTree',
+      'CompositeLayers',
+      // Modern compositor pipeline phases (Chrome ~M100+) that
+      // didn't exist when the original list was written.
+      'PrePaint',
+      'Commit',
+      'Layerize',
+      'BeginFrame',
+      'BeginMainThreadFrame',
+      'DrawFrame',
+      // Image decode work happens on the main thread when the
+      // off-thread decoder can't keep up.
+      'DecodeImage',
+      'Decode Image',
+      'ImageDecodeTask',
+      'GPUTask',
+      'SetLayerTreeId'
+    ]
+  },
+  scriptParseCompile: {
+    id: 'scriptParseCompile',
+    label: 'Script Parsing & Compilation',
+    traceEventNames: [
+      'v8.compile',
+      'v8.compileModule',
+      'v8.parseOnBackground',
+      'v8.parseFunction',
+      // Context creation + V8 snapshot deserialization — these are
+      // the V8 startup costs that fire before any user JS runs.
+      'V8.DeserializeContext',
+      'LocalWindowProxy::CreateContext'
+    ]
+  },
+  scriptEvaluation: {
+    id: 'scriptEvaluation',
+    label: 'Script Evaluation',
+    traceEventNames: [
+      'EventDispatch',
+      'EvaluateScript',
+      'v8.evaluateModule',
+      'FunctionCall',
+      'TimerFire',
+      'TimerInstall',
+      'TimerRemove',
+      'FireIdleCallback',
+      'FireAnimationFrame',
+      'RunMicrotasks',
+      'V8.Execute',
+      // Modern V8 entry points (Chrome ~M115+) — `v8.run` and
+      // `v8.callFunction` are the wrappers Chrome added when V8
+      // reorganized its tracing categories.
+      'v8.run',
+      'v8.callFunction',
+      'v8.callModuleMethod',
+      'XHRLoad',
+      'XHRReadyStateChange'
+    ]
+  },
+  garbageCollection: {
+    id: 'garbageCollection',
+    label: 'Garbage Collection',
+    traceEventNames: [
+      'MinorGC', // Previously GCEvent
+      'MajorGC',
+      'BlinkGC.AtomicPhase',
+      'BlinkGCMarking',
+      'ThreadState::performIdleLazySweep',
+      'ThreadState::completeSweep',
+      'Heap::collectGarbage',
+      // V8 GC events — there are many specific phase names but they
+      // all share the `V8.GC` prefix (V8.GCScavenger, V8.GCFinalizeMC,
+      // V8.GC_SCAVENGER_SCAVENGE_PARALLEL_PHASE, etc.). Specific
+      // names are listed for fast exact-match; the prefix fallback
+      // in groupForEvent() catches the rest.
+      'V8.GCScavenger',
+      'V8.GCFinalizeMC',
+      'V8.GCMarkCompact',
+      'V8.GCIncrementalMarking',
+      'V8.GCCompactor',
+      'V8.GC_SCAVENGER_SCAVENGE_PARALLEL_PHASE'
+    ]
+  },
+  other: {
+    id: 'other',
+    label: 'Other',
+    traceEventNames: [
+      'MessageLoop::RunTask',
+      'TaskQueueManager::ProcessTaskFromWorkQueue',
+      'ThreadControllerImpl::DoWork',
+      // The top-level scheduler wrapper. Its self-time is the
+      // residual after children run — the "Chrome scheduling
+      // overhead" portion. Was missing from the old list and
+      // dominated the "other" bucket on busy pages.
+      'RunTask',
+      'ThreadControllerImpl::RunTask'
+    ]
+  }
+};
+
+export const taskNameToGroup = {};
+for (const group of Object.values(taskGroups)) {
+  for (const traceEventName of group.traceEventNames) {
+    taskNameToGroup[traceEventName] = group;
+  }
+}
+
+/**
+ * Look up the group for a trace event by name. Falls through to
+ * prefix matching for event-name families that share a structural
+ * pattern (`V8.GC*` for any V8 GC phase) so we don't have to
+ * enumerate every phase name Chrome ships. Returns undefined when
+ * no group matches; callers should fall back to `taskGroups.other`.
+ */
+export function groupForEvent(name) {
+  const exact = taskNameToGroup[name];
+  if (exact) return exact;
+  if (typeof name === 'string' && name.startsWith('V8.GC')) {
+    return taskGroups.garbageCollection;
+  }
+}

package/lib/chrome/trace/trace-of-tab.js

@@ -0,0 +1,168 @@
+/**
+ * Trace → tab-of-interest extractor. Ported from @sitespeed.io/tracium
+ * 0.3.3. Picks the renderer pid/tid/frameId, locates navigation/paint
+ * landmark events, and returns the chronologically-stable subset of
+ * events that belong to the inspected tab plus its main-thread
+ * subset that the task-builder consumes.
+ */
+
+import { getLogger } from '@sitespeed.io/log';
+import { findMainFrameIds } from './tracing-processor.js';
+
+const log = getLogger('browsertime.chrome.trace');
+
+const ACCEPTABLE_NAVIGATION_URL_REGEX = /^(chrome|https?|file):/;
+
+function getTimestamp(event) {
+  return event && event.ts;
+}
+
+function isNavigationStartOfInterest(event) {
+  return (
+    event.name === 'navigationStart' &&
+    (!event.args.data ||
+      !event.args.data.documentLoaderURL ||
+      ACCEPTABLE_NAVIGATION_URL_REGEX.test(event.args.data.documentLoaderURL))
+  );
+}
+
+/**
+ * Stable sort by `ts`. JavaScript's Array.prototype.sort isn't
+ * guaranteed stable across engines historically, and trace event
+ * order matters when ts collides (B/E pairing breaks otherwise).
+ * The implementation sorts an indices array first, breaking ties by
+ * source index, so equal-ts events keep their original ordering.
+ */
+function filteredStableSort(traceEvents, filter) {
+  const indices = [];
+  for (const [srcIndex, traceEvent] of traceEvents.entries()) {
+    if (filter(traceEvent)) {
+      indices.push(srcIndex);
+    }
+  }
+  indices.sort((indexA, indexB) => {
+    const result = traceEvents[indexA].ts - traceEvents[indexB].ts;
+    return result || indexA - indexB;
+  });
+  const sorted = [];
+  for (const index of indices) {
+    sorted.push(traceEvents[index]);
+  }
+  return sorted;
+}
+
+export function computeTraceOfTab(trace) {
+  // Parse the trace for our key events and sort them by timestamp.
+  // The sort *must* be stable to keep events correctly nested.
+  const keyEvents = filteredStableSort(trace.traceEvents, e => {
+    return (
+      e.cat.includes('blink.user_timing') ||
+      e.cat.includes('loading') ||
+      e.cat.includes('devtools.timeline') ||
+      e.cat === '__metadata'
+    );
+  });
+
+  const mainFrameIds = findMainFrameIds(keyEvents);
+
+  // Filter to just events matching the frame ID for sanity.
+  const frameEvents = keyEvents.filter(
+    e => e.args.frame === mainFrameIds.frameId
+  );
+
+  // Our navStart will be the last frame navigation in the trace.
+  const navigationStart = frameEvents.findLast(e =>
+    isNavigationStartOfInterest(e)
+  );
+  if (!navigationStart) throw new Error('NO_NAVSTART');
+
+  // Find our first paint of this frame.
+  const firstPaint = frameEvents.find(
+    e => e.name === 'firstPaint' && e.ts > navigationStart.ts
+  );
+
+  // fMP follows at/after the FP.
+  let firstMeaningfulPaint = frameEvents.find(
+    e => e.name === 'firstMeaningfulPaint' && e.ts > navigationStart.ts
+  );
+  let fmpFellBack = false;
+
+  // If there was no firstMeaningfulPaint event found in the trace,
+  // network-idle detection may have not been triggered before the
+  // capture finished. Use the last firstMeaningfulPaintCandidate.
+  if (!firstMeaningfulPaint) {
+    const fmpCand = 'firstMeaningfulPaintCandidate';
+    fmpFellBack = true;
+    log.debug(
+      'trace-of-tab',
+      `No firstMeaningfulPaint found, falling back to last ${fmpCand}`
+    );
+    const lastCandidate = frameEvents.findLast(e => e.name === fmpCand);
+    if (!lastCandidate) {
+      log.debug(
+        'trace-of-tab',
+        'No `firstMeaningfulPaintCandidate` events found in trace'
+      );
+    }
+    firstMeaningfulPaint = lastCandidate;
+  }
+
+  const load = frameEvents.find(
+    e => e.name === 'loadEventEnd' && e.ts > navigationStart.ts
+  );
+  const domContentLoaded = frameEvents.find(
+    e => e.name === 'domContentLoadedEventEnd' && e.ts > navigationStart.ts
+  );
+
+  // Subset all trace events to just our tab's process (incl threads
+  // other than main). Stable-sort to keep events correctly nested.
+  const processEvents = filteredStableSort(
+    trace.traceEvents,
+    e => e.pid === mainFrameIds.pid
+  );
+
+  const mainThreadEvents = processEvents.filter(
+    e => e.tid === mainFrameIds.tid
+  );
+
+  // traceEnd must exist since at least navigationStart was verified.
+  let traceEnd = trace.traceEvents[0];
+  for (const evt of trace.traceEvents) {
+    if (evt.ts > traceEnd.ts) traceEnd = evt;
+  }
+  const fakeEndOfTraceEvt = { ts: traceEnd.ts + (traceEnd.dur || 0) };
+
+  const timestamps = {
+    navigationStart: navigationStart.ts,
+    firstPaint: getTimestamp(firstPaint),
+    firstMeaningfulPaint: getTimestamp(firstMeaningfulPaint),
+    traceEnd: fakeEndOfTraceEvt.ts,
+    load: getTimestamp(load),
+    domContentLoaded: getTimestamp(domContentLoaded)
+  };
+
+  const getTiming = ts => (ts - navigationStart.ts) / 1000;
+  const maybeGetTiming = ts => (ts === undefined ? undefined : getTiming(ts));
+  const timings = {
+    navigationStart: 0,
+    firstPaint: maybeGetTiming(timestamps.firstPaint),
+    firstMeaningfulPaint: maybeGetTiming(timestamps.firstMeaningfulPaint),
+    traceEnd: getTiming(timestamps.traceEnd),
+    load: maybeGetTiming(timestamps.load),
+    domContentLoaded: maybeGetTiming(timestamps.domContentLoaded)
+  };
+
+  return {
+    timings,
+    timestamps,
+    processEvents,
+    mainThreadEvents,
+    mainFrameIds,
+    navigationStartEvt: navigationStart,
+    firstPaintEvt: firstPaint,
+    firstMeaningfulPaintEvt: firstMeaningfulPaint,
+    loadEvt: load,
+    domContentLoadedEvt: domContentLoaded,
+    fmpFellBack
+  };
+}

package/lib/chrome/trace/tracing-processor.js

@@ -0,0 +1,95 @@
+/**
+ * Trace pid/tid/frameId resolver, ported from @sitespeed.io/tracium
+ * 0.3.3 (Lighthouse 2018 lineage). Only `findMainFrameIds` is kept —
+ * the original module also exposed `getRiskToResponsiveness` and
+ * the `_riskPercentiles` math used by Lighthouse's TBT, but those
+ * aren't called from Browsertime's pipeline so they're dropped to
+ * keep the surface tight.
+ */
+
+/**
+ * Locate the main renderer's pid/tid/frameId via three fallbacks, in
+ * order of how recent the trace events are: the modern
+ * TracingStartedInBrowser event (with a frames[] payload), the legacy
+ * TracingStartedInPage event, and finally pairing the first
+ * navigationStart with the first ResourceSendRequest. Throws when
+ * none of the three apply — which means the trace doesn't contain
+ * a renderable tab and the caller (parseCpuTrace) will degrade
+ * gracefully via its outer try/catch.
+ */
+export function findMainFrameIds(events) {
+  // Prefer the newer TracingStartedInBrowser event first, if it exists.
+  const startedInBrowserEvt = events.find(
+    e => e.name === 'TracingStartedInBrowser'
+  );
+  if (
+    startedInBrowserEvt &&
+    startedInBrowserEvt.args.data &&
+    startedInBrowserEvt.args.data.frames
+  ) {
+    const mainFrame = startedInBrowserEvt.args.data.frames.find(
+      frame => !frame.parent
+    );
+    const frameId = mainFrame && mainFrame.frame;
+    const pid = mainFrame && mainFrame.processId;
+
+    const threadNameEvt = events.find(
+      e =>
+        e.pid === pid &&
+        e.ph === 'M' &&
+        e.cat === '__metadata' &&
+        e.name === 'thread_name' &&
+        e.args.name === 'CrRendererMain'
+    );
+    const tid = threadNameEvt && threadNameEvt.tid;
+
+    if (pid && tid && frameId) {
+      return { pid, tid, frameId };
+    }
+  }
+
+  // Support legacy browser versions that do not emit
+  // TracingStartedInBrowser. The first TracingStartedInPage in the
+  // trace is the renderer thread of interest. Beware: the
+  // TracingStartedInPage event can appear slightly after a
+  // navigationStart, so the order of fallbacks matters.
+  const startedInPageEvt = events.find(e => e.name === 'TracingStartedInPage');
+  if (startedInPageEvt && startedInPageEvt.args && startedInPageEvt.args.data) {
+    const frameId = startedInPageEvt.args.data.page;
+    if (frameId) {
+      return { pid: startedInPageEvt.pid, tid: startedInPageEvt.tid, frameId };
+    }
+  }
+
+  // Last resort: pair the first navigationStart that's loading the
+  // main frame with the first ResourceSendRequest from the same
+  // pid/tid. If those agree the renderer is whatever pid/tid they
+  // share.
+  const navStartEvt = events.find(e =>
+    Boolean(
+      e.name === 'navigationStart' &&
+      e.args &&
+      e.args.data &&
+      e.args.data.isLoadingMainFrame &&
+      e.args.data.documentLoaderURL
+    )
+  );
+  const firstResourceSendEvt = events.find(
+    e => e.name === 'ResourceSendRequest'
+  );
+  if (
+    navStartEvt &&
+    navStartEvt.args &&
+    navStartEvt.args.data &&
+    firstResourceSendEvt &&
+    firstResourceSendEvt.pid === navStartEvt.pid &&
+    firstResourceSendEvt.tid === navStartEvt.tid
+  ) {
+    const frameId = navStartEvt.args.frame;
+    if (frameId) {
+      return { pid: navStartEvt.pid, tid: navStartEvt.tid, frameId };
+    }
+  }
+
+  throw new Error('NO_TRACING_STARTED');
+}

package/lib/chrome/webdriver/chromium.js

@@ -415,6 +415,19 @@ export class Chromium {
               render.renderBlockingInfo[harRequest.request.url];
           }
         }
+        // Also stamp the page-level summary (recalculate-style
+        // elements + duration before FCP/LCP) onto the HAR's page
+        // object so HAR-only consumers can pick it up without
+        // needing browsertime.json. The per-request map is already
+        // projected onto each entry above, so we keep this payload
+        // to just the summary fields.
+        const harPage =
+          this.hars[index - 1].log.pages && this.hars[index - 1].log.pages[0];
+        if (harPage && render.renderBlocking.recalculateStyle) {
+          harPage._renderBlocking = {
+            recalculateStyle: render.renderBlocking.recalculateStyle
+          };
+        }
       }
 
       result.renderBlocking.requests = render.renderBlockingInfo;

package/lib/support/har/index.js

@@ -359,6 +359,17 @@ export function getEmptyHAR(url, browser) {
     }
   };
 }
+// Tag the first entry of a page with the document URL it navigated to.
+// Downstream consumers (waterfall-tools) read `entries[0]._documentURL`
+// to flag cross-origin requests in the rendered waterfall — the first
+// entry's own URL would also work for the no-redirect case, but breaks
+// the moment the document follows a redirect chain to a different host.
+function addDocumentURLToFirstEntry(harPage, entries, url) {
+  if (!harPage || !entries || !url) return;
+  const first = entries.find(entry => entry.pageref === harPage.id);
+  if (first) first._documentURL = url;
+}
+
 export function addExtraFieldsToHar(totalResults, har, options) {
   if (har) {
     let harPageNumber = 0;
@@ -384,6 +395,12 @@ export function addExtraFieldsToHar(totalResults, har, options) {
           options
         );
 
+        addDocumentURLToFirstEntry(
+          harPage,
+          har.log.entries,
+          totalResults[pageNumber].info.url
+        );
+
         if (browserScript) {
           addExtrasToHAR(
             harPage,
@@ -417,6 +434,11 @@ export function addExtraFieldsToHar(totalResults, har, options) {
               browserScript,
               options
             );
+            addDocumentURLToFirstEntry(
+              harPage,
+              har.log.entries,
+              totalResults[page].info.url
+            );
           } else {
             log.error(
               'Could not add meta data to the HAR, miss page ' + harIndex

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "browsertime",
   "description": "Get performance metrics from your web page using Browsertime.",
-  "version": "27.0.4",
+  "version": "27.2.0",
   "bin": "./bin/browsertime.js",
   "type": "module",
   "types": "./types/scripting.d.ts",
@@ -11,9 +11,8 @@
     "@sitespeed.io/edgedriver": "143.0.3650",
     "@sitespeed.io/geckodriver": "0.36.0",
     "@sitespeed.io/log": "1.0.0",
-    "@sitespeed.io/throttle": "5.0.1",
-    "@sitespeed.io/tracium": "0.3.3",
-    "chrome-har": "1.2.1",
+    "@sitespeed.io/throttle": "6.0.0",
+    "chrome-har": "1.3.0",
     "chrome-remote-interface": "0.33.3",
     "execa": "9.6.1",
     "fast-stats": "0.0.7",

package/types/chrome/parseCpuTrace.d.ts

@@ -13,9 +13,15 @@ export function parseCPUTrace(tracelog: any, url: any): Promise<{
         url: string;
         value: number;
     }[];
+    scriptCosts: any[];
+    forcedReflows: any[];
+    nonCompositedAnimations: any[];
 } | {
     categories?: undefined;
     events?: undefined;
     urls?: undefined;
+    scriptCosts?: undefined;
+    forcedReflows?: undefined;
+    nonCompositedAnimations?: undefined;
 }>;
 //# 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":"AAaA;;;;;;;;;;;;;;;;;;;GA4EC"}
+{"version":3,"file":"parseCpuTrace.d.ts","sourceRoot":"","sources":["../../lib/chrome/parseCpuTrace.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GA2GC"}

package/types/chrome/trace/forced-reflows.d.ts

@@ -0,0 +1,8 @@
+export function computeForcedReflows(trace: any): {
+    eventName: any;
+    duration: number;
+    startTime: number;
+    triggeredBy: any;
+    triggeredByUrl: any;
+}[];
+//# sourceMappingURL=forced-reflows.d.ts.map

package/types/chrome/trace/forced-reflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forced-reflows.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/forced-reflows.js"],"names":[],"mappings":"AAgDA;;;;;;IA6BC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Compute the hierarchical main-thread task tree for a trace.
+ * Each task has its kind classified into one of:
+ *   parseHTML | styleLayout | paintCompositeRender |
+ *   scriptParseCompile | scriptEvaluation | garbageCollection | other
+ *
+ * @param {Object} trace  Parsed Chrome trace.json (with .traceEvents).
+ * @param {Object} [options]
+ * @param {boolean} [options.flatten=false]  When true, return all
+ *   tasks flat (parents and children); when false, only top-level.
+ * @returns {Array<Object>}
+ */
+export function computeMainThreadTasks(trace: any, options?: {
+    flatten?: boolean;
+}): Array<any>;
+export { computeScriptCosts } from "./script-costs.js";
+export { computeForcedReflows } from "./forced-reflows.js";
+export { computeNonCompositedAnimations } from "./non-composited-animations.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/types/chrome/trace/main-thread-tasks.d.ts

@@ -0,0 +1,31 @@
+export function getMainThreadTasks(traceEvents: any, traceEndTs: any): {
+    event: any;
+    startTime: any;
+    endTime: any;
+    parent: any;
+    children: any[];
+    attributableURLs: any[];
+    group: {
+        id: string;
+        label: string;
+        traceEventNames: string[];
+    };
+    duration: number;
+    selfTime: number;
+}[];
+export function compute(trace: any): {
+    event: any;
+    startTime: any;
+    endTime: any;
+    parent: any;
+    children: any[];
+    attributableURLs: any[];
+    group: {
+        id: string;
+        label: string;
+        traceEventNames: string[];
+    };
+    duration: number;
+    selfTime: number;
+}[];
+//# sourceMappingURL=main-thread-tasks.d.ts.map

package/types/chrome/trace/main-thread-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-thread-tasks.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/main-thread-tasks.js"],"names":[],"mappings":"AAkKA;;;;;;;;;;;;;;IA4BC;AAED;;;;;;;;;;;;;;IAGC"}

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

@@ -0,0 +1,33 @@
+/**
+ * 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;
+    unsupportedProperties: any;
+    startTime: any;
+}[];
+//# sourceMappingURL=non-composited-animations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-composited-animations.d.ts","sourceRoot":"","sources":["../../../lib/chrome/trace/non-composited-animations.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;IA4BC"}