@paulirish/trace_engine 0.0.4 → 0.0.6

package/trace.mjs

@@ -17,6 +17,7 @@ var handlers_exports = {};
 __export(handlers_exports, {
   Migration: () => Migration_exports,
   ModelHandlers: () => ModelHandlers_exports,
+  Threads: () => Threads_exports,
   Types: () => types_exports2
 });
 
@@ -385,7 +386,8 @@ __export(types_exports, {
 // front_end/models/trace/types/Configuration.ts
 var Configuration_exports = {};
 __export(Configuration_exports, {
-  DEFAULT: () => DEFAULT
+  DEFAULT: () => DEFAULT,
+  configToCacheKey: () => configToCacheKey
 });
 var DEFAULT = {
   settings: {},
@@ -398,6 +400,12 @@ var DEFAULT = {
     pauseDuration: 1
   }
 };
+function configToCacheKey(config2) {
+  return [
+    `experiments.timelineShowAllEvents:${config2.experiments.timelineShowAllEvents}`,
+    `experiments.timelineV8RuntimeCallStats:${config2.experiments.timelineV8RuntimeCallStats}`
+  ].join("-");
+}
 
 // front_end/models/trace/types/File.ts
 var File_exports = {};
@@ -459,6 +467,7 @@ __export(TraceEvents_exports, {
   isSyntheticInteractionEvent: () => isSyntheticInteractionEvent,
   isSyntheticLayoutShift: () => isSyntheticLayoutShift,
   isSyntheticNetworkRequestDetailsEvent: () => isSyntheticNetworkRequestDetailsEvent,
+  isSyntheticTraceEventCpuProfile: () => isSyntheticTraceEventCpuProfile,
   isSyntheticUserTimingTraceEvent: () => isSyntheticUserTimingTraceEvent,
   isThreadName: () => isThreadName,
   isTraceEventAnimation: () => isTraceEventAnimation,
@@ -712,6 +721,9 @@ function isTraceEventGPUTask(traceEventData) {
 function isTraceEventProfile(traceEventData) {
   return traceEventData.name === "Profile";
 }
+function isSyntheticTraceEventCpuProfile(traceEventData) {
+  return traceEventData.name === "CpuProfile";
+}
 function isTraceEventProfileChunk(traceEventData) {
   return traceEventData.name === "ProfileChunk";
 }
@@ -1051,25 +1063,138 @@ function data() {
   };
 }
 
+// front_end/models/trace/handlers/AuctionWorkletsHandler.ts
+var AuctionWorkletsHandler_exports = {};
+__export(AuctionWorkletsHandler_exports, {
+  data: () => data2,
+  finalize: () => finalize2,
+  handleEvent: () => handleEvent2,
+  reset: () => reset2
+});
+var runningInProcessEvents = /* @__PURE__ */ new Map();
+var doneWithProcessEvents = /* @__PURE__ */ new Map();
+var createdSyntheticEvents = /* @__PURE__ */ new Map();
+var utilityThreads = /* @__PURE__ */ new Map();
+var v8HelperThreads = /* @__PURE__ */ new Map();
+function reset2() {
+  runningInProcessEvents.clear();
+  doneWithProcessEvents.clear();
+  createdSyntheticEvents.clear();
+  utilityThreads.clear();
+  v8HelperThreads.clear();
+}
+function handleEvent2(event) {
+  if (TraceEvents_exports.isTraceEventAuctionWorkletRunningInProcess(event)) {
+    runningInProcessEvents.set(event.args.data.pid, event);
+    return;
+  }
+  if (TraceEvents_exports.isTraceEventAuctionWorkletDoneWithProcess(event)) {
+    doneWithProcessEvents.set(event.args.data.pid, event);
+    return;
+  }
+  if (TraceEvents_exports.isThreadName(event)) {
+    if (event.args.name === "auction_worklet.CrUtilityMain") {
+      utilityThreads.set(event.pid, event);
+      return;
+    }
+    if (event.args.name === "AuctionV8HelperThread") {
+      v8HelperThreads.set(event.pid, event);
+    }
+  }
+}
+function workletType(input) {
+  switch (input) {
+    case "seller":
+      return TraceEvents_exports.AuctionWorkletType.SELLER;
+    case "bidder":
+      return TraceEvents_exports.AuctionWorkletType.BIDDER;
+    default:
+      return TraceEvents_exports.AuctionWorkletType.UNKNOWN;
+  }
+}
+function makeSyntheticEventBase(event) {
+  return {
+    name: "SyntheticAuctionWorkletEvent",
+    s: TraceEvents_exports.TraceEventScope.THREAD,
+    cat: event.cat,
+    tid: event.tid,
+    ts: event.ts,
+    ph: TraceEvents_exports.Phase.INSTANT,
+    pid: event.args.data.pid,
+    host: event.args.data.host,
+    target: event.args.data.target,
+    type: workletType(event.args.data.type)
+  };
+}
+async function finalize2() {
+  for (const [pid, utilityThreadNameEvent] of utilityThreads) {
+    const v8HelperEvent = v8HelperThreads.get(pid);
+    if (!v8HelperEvent) {
+      continue;
+    }
+    const runningEvent = runningInProcessEvents.get(pid);
+    const doneWithEvent = doneWithProcessEvents.get(pid);
+    let syntheticEvent = null;
+    if (runningEvent) {
+      syntheticEvent = {
+        ...makeSyntheticEventBase(runningEvent),
+        args: {
+          data: {
+            runningInProcessEvent: runningEvent,
+            utilityThread: utilityThreadNameEvent,
+            v8HelperThread: v8HelperEvent
+          }
+        }
+      };
+      if (doneWithEvent) {
+        syntheticEvent.args.data.doneWithProcessEvent = doneWithEvent;
+      }
+    } else if (doneWithEvent) {
+      syntheticEvent = {
+        ...makeSyntheticEventBase(doneWithEvent),
+        args: {
+          data: {
+            doneWithProcessEvent: doneWithEvent,
+            utilityThread: utilityThreadNameEvent,
+            v8HelperThread: v8HelperEvent
+          }
+        }
+      };
+      if (runningEvent) {
+        syntheticEvent.args.data.runningInProcessEvent = runningEvent;
+      }
+    }
+    if (syntheticEvent === null) {
+      continue;
+    }
+    createdSyntheticEvents.set(pid, syntheticEvent);
+  }
+}
+function data2() {
+  return {
+    worklets: new Map(createdSyntheticEvents)
+  };
+}
+
 // front_end/models/trace/handlers/GPUHandler.ts
 var GPUHandler_exports = {};
 __export(GPUHandler_exports, {
-  data: () => data3,
+  data: () => data4,
   deps: () => deps,
-  finalize: () => finalize3,
-  handleEvent: () => handleEvent3,
+  finalize: () => finalize4,
+  handleEvent: () => handleEvent4,
   initialize: () => initialize2,
-  reset: () => reset3
+  reset: () => reset4
 });
 
 // front_end/models/trace/handlers/MetaHandler.ts
 var MetaHandler_exports = {};
 __export(MetaHandler_exports, {
-  data: () => data2,
-  finalize: () => finalize2,
-  handleEvent: () => handleEvent2,
+  data: () => data3,
+  finalize: () => finalize3,
+  handleEvent: () => handleEvent3,
   initialize: () => initialize,
-  reset: () => reset2
+  reset: () => reset3
 });
 var rendererProcessesByFrameId = /* @__PURE__ */ new Map();
 var mainFrameId = "";
@@ -1098,7 +1223,7 @@ var eventPhasesOfInterestForTraceBounds = /* @__PURE__ */ new Set([
   TraceEvents_exports.Phase.INSTANT
 ]);
 var handlerState2 = 1 /* UNINITIALIZED */;
-function reset2() {
+function reset3() {
   navigationsByFrameId.clear();
   navigationsByNavigationId.clear();
   mainFrameNavigations.length = 0;
@@ -1143,7 +1268,7 @@ function updateRendererProcessByFrame(event, frame) {
     }
   });
 }
-function handleEvent2(event) {
+function handleEvent3(event) {
   if (handlerState2 !== 2 /* INITIALIZED */) {
     throw new Error("Meta Handler is not initialized");
   }
@@ -1233,7 +1358,7 @@ function handleEvent2(event) {
     return;
   }
 }
-async function finalize2() {
+async function finalize3() {
   if (handlerState2 !== 2 /* INITIALIZED */) {
     throw new Error("Handler is not initialized");
   }
@@ -1269,7 +1394,7 @@ async function finalize2() {
   }
   handlerState2 = 3 /* FINALIZED */;
 }
-function data2() {
+function data3() {
   if (handlerState2 !== 3 /* FINALIZED */) {
     throw new Error("Meta Handler is not finalized");
   }
@@ -1297,7 +1422,8 @@ var helpers_exports = {};
 __export(helpers_exports, {
   SamplesIntegrator: () => SamplesIntegrator_exports,
   Timing: () => Timing_exports3,
-  Trace: () => Trace_exports
+  Trace: () => Trace_exports,
+  TreeHelpers: () => TreeHelpers_exports
 });
 
 // front_end/models/trace/helpers/SamplesIntegrator.ts
@@ -1320,7 +1446,9 @@ __export(Timing_exports3, {
   secondsToMicroseconds: () => secondsToMicroseconds,
   secondsToMilliseconds: () => secondsToMilliseconds,
   timeStampForEventAdjustedByClosestNavigation: () => timeStampForEventAdjustedByClosestNavigation,
-  traceBoundsMilliseconds: () => traceBoundsMilliseconds
+  traceWindowFromMilliSeconds: () => traceWindowFromMilliSeconds,
+  traceWindowMilliSeconds: () => traceWindowMilliSeconds,
+  traceWindowMillisecondsToMicroSeconds: () => traceWindowMillisecondsToMicroSeconds
 });
 
 // front_end/models/trace/helpers/Trace.ts
@@ -1331,6 +1459,7 @@ __export(Trace_exports, {
   extractId: () => extractId,
   extractOriginFromTrace: () => extractOriginFromTrace,
   getNavigationForTraceEvent: () => getNavigationForTraceEvent,
+  makeProfileCall: () => makeProfileCall,
   mergeEventsInOrder: () => mergeEventsInOrder,
   sortTraceEventsInPlace: () => sortTraceEventsInPlace
 });
@@ -1436,6 +1565,21 @@ function activeURLForFrameAtTime(frameId, time, rendererProcessesByFrame) {
   }
   return null;
 }
+function makeProfileCall(node, ts, pid, tid) {
+  return {
+    cat: "",
+    name: "ProfileCall",
+    nodeId: node.id,
+    args: {},
+    ph: TraceEvents_exports.Phase.COMPLETE,
+    pid,
+    tid,
+    ts,
+    dur: Timing_exports2.MicroSeconds(0),
+    selfTime: Timing_exports2.MicroSeconds(0),
+    callFrame: node.callFrame
+  };
+}
 
 // front_end/models/trace/helpers/Timing.ts
 var millisecondsToMicroseconds = (value) => Timing_exports2.MicroSeconds(value * 1e3);
@@ -1545,13 +1689,28 @@ function eventTimingsSeconds(event) {
     selfTime: microSecondsToSeconds(microTimes.selfTime)
   };
 }
-function traceBoundsMilliseconds(bounds) {
+function traceWindowMilliSeconds(bounds) {
   return {
     min: microSecondsToMilliseconds(bounds.min),
     max: microSecondsToMilliseconds(bounds.max),
     range: microSecondsToMilliseconds(bounds.range)
   };
 }
+function traceWindowMillisecondsToMicroSeconds(bounds) {
+  return {
+    min: millisecondsToMicroseconds(bounds.min),
+    max: millisecondsToMicroseconds(bounds.max),
+    range: millisecondsToMicroseconds(bounds.range)
+  };
+}
+function traceWindowFromMilliSeconds(min, max) {
+  const traceWindow = {
+    min: millisecondsToMicroseconds(min),
+    max: millisecondsToMicroseconds(max),
+    range: millisecondsToMicroseconds(Timing_exports2.MilliSeconds(max - min))
+  };
+  return traceWindow;
+}
 
 // front_end/models/trace/helpers/SamplesIntegrator.ts
 var SamplesIntegrator = class {
@@ -1562,6 +1721,7 @@ var SamplesIntegrator = class {
   #lockedJsStackDepth = [];
   #fakeJSInvocation = false;
   #profileModel;
+  #nodeForGC = /* @__PURE__ */ new Map();
   #engineConfig;
   constructor(profileModel, pid, tid, configuration) {
     this.#profileModel = profileModel;
@@ -1650,26 +1810,39 @@ var SamplesIntegrator = class {
       return [];
     }
     const calls = [];
+    let prevNode;
     for (let i = 0; i < samples.length; i++) {
       const node = this.#profileModel.nodeByIndex(i);
       const timestamp = millisecondsToMicroseconds(Timing_exports2.MilliSeconds(timestamps[i]));
       if (!node) {
         continue;
       }
-      const call = SamplesIntegrator.makeProfileCall(node, timestamp, this.#processId, this.#threadId);
+      const call = makeProfileCall(node, timestamp, this.#processId, this.#threadId);
       calls.push(call);
+      if (node.id === this.#profileModel.gcNode?.id && prevNode) {
+        this.#nodeForGC.set(call, prevNode);
+        continue;
+      }
+      prevNode = node;
     }
     return calls;
   }
   #getStackTraceFromProfileCall(profileCall) {
     let node = this.#profileModel.nodeById(profileCall.nodeId);
+    const isGarbageCollection = Boolean(node?.id === this.#profileModel.gcNode?.id);
+    if (isGarbageCollection) {
+      node = this.#nodeForGC.get(profileCall) || null;
+    }
     if (!node) {
       return [];
     }
-    const callFrames = new Array(node.depth + 1);
+    const callFrames = new Array(node.depth + 1 + Number(isGarbageCollection));
     let i = callFrames.length - 1;
+    if (isGarbageCollection) {
+      callFrames[i--] = profileCall;
+    }
     while (node) {
-      callFrames[i--] = SamplesIntegrator.makeProfileCall(node, profileCall.ts, this.#processId, this.#threadId);
+      callFrames[i--] = makeProfileCall(node, profileCall.ts, this.#processId, this.#threadId);
       node = node.parent;
     }
     return callFrames;
@@ -1691,10 +1864,10 @@ var SamplesIntegrator = class {
     this.#truncateJSStack(i, event.ts);
     for (; i < stackTrace.length; ++i) {
       const call = stackTrace[i];
-      this.#currentJSStack.push(call);
       if (call.nodeId === this.#profileModel.programNode?.id || call.nodeId === this.#profileModel.root?.id || call.nodeId === this.#profileModel.idleNode?.id || call.nodeId === this.#profileModel.gcNode?.id) {
         continue;
       }
+      this.#currentJSStack.push(call);
       this.#constructedProfileCalls.push(call);
     }
   }
@@ -1770,28 +1943,137 @@ var SamplesIntegrator = class {
     }
     stack.length = j;
   }
-  static makeProfileCall(node, ts, pid, tid) {
-    return {
-      cat: "",
-      name: "ProfileCall",
-      nodeId: node.id,
-      args: {},
-      ph: TraceEvents_exports.Phase.COMPLETE,
-      pid,
-      tid,
-      ts,
-      dur: Timing_exports2.MicroSeconds(0),
-      selfTime: Timing_exports2.MicroSeconds(0),
-      callFrame: node.callFrame
-    };
-  }
 };
 
+// front_end/models/trace/helpers/TreeHelpers.ts
+var TreeHelpers_exports = {};
+__export(TreeHelpers_exports, {
+  makeEmptyTraceEntryNode: () => makeEmptyTraceEntryNode,
+  makeEmptyTraceEntryTree: () => makeEmptyTraceEntryTree,
+  makeTraceEntryNodeId: () => makeTraceEntryNodeId,
+  treify: () => treify,
+  walkEntireTree: () => walkEntireTree,
+  walkTreeFromEntry: () => walkTreeFromEntry
+});
+var nodeIdCount = 0;
+var makeTraceEntryNodeId = () => ++nodeIdCount;
+var makeEmptyTraceEntryTree = () => ({
+  nodes: /* @__PURE__ */ new Map(),
+  roots: /* @__PURE__ */ new Set(),
+  maxDepth: 0
+});
+var makeEmptyTraceEntryNode = (entry, id) => ({
+  entry,
+  id,
+  parentId: null,
+  children: /* @__PURE__ */ new Set(),
+  depth: 0
+});
+var TraceEntryNodeIdTag = class {
+  #tag;
+};
+function treify(entries, options) {
+  const entryToNode3 = /* @__PURE__ */ new Map();
+  const stack = [];
+  nodeIdCount = -1;
+  const tree = makeEmptyTraceEntryTree();
+  for (let i = 0; i < entries.length; i++) {
+    const event = entries[i];
+    if (options && !options.filter.has(event.name)) {
+      continue;
+    }
+    const duration = event.dur || 0;
+    const nodeId = makeTraceEntryNodeId();
+    const node = makeEmptyTraceEntryNode(event, nodeId);
+    if (stack.length === 0) {
+      tree.nodes.set(nodeId, node);
+      tree.roots.add(node);
+      event.selfTime = Timing_exports2.MicroSeconds(duration);
+      stack.push(node);
+      tree.maxDepth = Math.max(tree.maxDepth, stack.length);
+      entryToNode3.set(event, node);
+      continue;
+    }
+    const parentNode = stack.at(-1);
+    if (parentNode === void 0) {
+      throw new Error("Impossible: no parent node found in the stack");
+    }
+    const parentEvent = parentNode.entry;
+    const begin = event.ts;
+    const parentBegin = parentEvent.ts;
+    const parentDuration = parentEvent.dur || 0;
+    const end = begin + duration;
+    const parentEnd = parentBegin + parentDuration;
+    const startsBeforeParent = begin < parentBegin;
+    if (startsBeforeParent) {
+      throw new Error("Impossible: current event starts before the parent event");
+    }
+    const startsAfterParent = begin >= parentEnd;
+    if (startsAfterParent) {
+      stack.pop();
+      i--;
+      nodeIdCount--;
+      continue;
+    }
+    const endsAfterParent = end > parentEnd;
+    if (endsAfterParent) {
+      continue;
+    }
+    tree.nodes.set(nodeId, node);
+    node.depth = stack.length;
+    node.parentId = parentNode.id;
+    parentNode.children.add(node);
+    event.selfTime = Timing_exports2.MicroSeconds(duration);
+    if (parentEvent.selfTime !== void 0) {
+      parentEvent.selfTime = Timing_exports2.MicroSeconds(parentEvent.selfTime - (event.dur || 0));
+    }
+    stack.push(node);
+    tree.maxDepth = Math.max(tree.maxDepth, stack.length);
+    entryToNode3.set(event, node);
+  }
+  return { tree, entryToNode: entryToNode3 };
+}
+function walkTreeFromEntry(entryToNode3, rootEntry, onEntryStart, onEntryEnd) {
+  const startNode = entryToNode3.get(rootEntry);
+  if (!startNode) {
+    return;
+  }
+  walkTreeByNode(entryToNode3, startNode, onEntryStart, onEntryEnd);
+}
+function walkEntireTree(entryToNode3, tree, onEntryStart, onEntryEnd, traceWindowToInclude) {
+  for (const rootNode of tree.roots) {
+    walkTreeByNode(entryToNode3, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude);
+  }
+}
+function walkTreeByNode(entryToNode3, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude) {
+  if (traceWindowToInclude && !treeNodeIsInWindow(rootNode, traceWindowToInclude)) {
+    return;
+  }
+  onEntryStart(rootNode.entry);
+  for (const child of rootNode.children) {
+    walkTreeByNode(entryToNode3, child, onEntryStart, onEntryEnd, traceWindowToInclude);
+  }
+  onEntryEnd(rootNode.entry);
+}
+function treeNodeIsInWindow(node, traceWindow) {
+  const { startTime, endTime } = eventTimingsMicroSeconds(node.entry);
+  if (startTime >= traceWindow.min && startTime < traceWindow.max) {
+    return true;
+  }
+  if (endTime > traceWindow.min && endTime <= traceWindow.max) {
+    return true;
+  }
+  if (startTime <= traceWindow.min && endTime >= traceWindow.max) {
+    return true;
+  }
+  return false;
+}
+
 // front_end/models/trace/handlers/GPUHandler.ts
 var handlerState3 = 1 /* UNINITIALIZED */;
 var eventsInProcessThread = /* @__PURE__ */ new Map();
 var mainGPUThreadTasks = [];
-function reset3() {
+function reset4() {
   eventsInProcessThread.clear();
   mainGPUThreadTasks = [];
   handlerState3 = 1 /* UNINITIALIZED */;
@@ -1802,7 +2084,7 @@ function initialize2() {
   }
   handlerState3 = 2 /* INITIALIZED */;
 }
-function handleEvent3(event) {
+function handleEvent4(event) {
   if (handlerState3 !== 2 /* INITIALIZED */) {
     throw new Error("GPU Handler is not initialized");
   }
@@ -1811,18 +2093,18 @@ function handleEvent3(event) {
   }
   Trace_exports.addEventToProcessThread(event, eventsInProcessThread);
 }
-async function finalize3() {
+async function finalize4() {
   if (handlerState3 !== 2 /* INITIALIZED */) {
     throw new Error("GPU Handler is not initialized");
   }
-  const { gpuProcessId: gpuProcessId2, gpuThreadId: gpuThreadId2 } = data2();
+  const { gpuProcessId: gpuProcessId2, gpuThreadId: gpuThreadId2 } = data3();
   const gpuThreadsForProcess = eventsInProcessThread.get(gpuProcessId2);
   if (gpuThreadsForProcess && gpuThreadId2) {
     mainGPUThreadTasks = gpuThreadsForProcess.get(gpuThreadId2) || [];
   }
   handlerState3 = 3 /* FINALIZED */;
 }
-function data3() {
+function data4() {
   if (handlerState3 !== 3 /* FINALIZED */) {
     throw new Error("GPU Handler is not finalized");
   }
@@ -1840,13 +2122,13 @@ __export(LayoutShiftsHandler_exports, {
   LayoutShiftsThreshold: () => LayoutShiftsThreshold,
   MAX_CLUSTER_DURATION: () => MAX_CLUSTER_DURATION,
   MAX_SHIFT_TIME_DELTA: () => MAX_SHIFT_TIME_DELTA,
-  data: () => data6,
+  data: () => data7,
   deps: () => deps4,
-  finalize: () => finalize6,
+  finalize: () => finalize7,
   findNextScreenshotEventIndex: () => findNextScreenshotEventIndex,
-  handleEvent: () => handleEvent6,
+  handleEvent: () => handleEvent7,
   initialize: () => initialize3,
-  reset: () => reset6,
+  reset: () => reset7,
   stateForLayoutShiftScore: () => stateForLayoutShiftScore
 });
 
@@ -1856,14 +2138,14 @@ __export(PageLoadMetricsHandler_exports, {
   MarkerName: () => MarkerName,
   MetricName: () => MetricName,
   ScoreClassification: () => ScoreClassification,
-  data: () => data4,
+  data: () => data5,
   deps: () => deps2,
   eventIsPageLoadEvent: () => eventIsPageLoadEvent,
-  finalize: () => finalize4,
+  finalize: () => finalize5,
   getFrameIdForPageLoadEvent: () => getFrameIdForPageLoadEvent,
-  handleEvent: () => handleEvent4,
+  handleEvent: () => handleEvent5,
   isTraceEventMarkerEvent: () => isTraceEventMarkerEvent,
-  reset: () => reset4,
+  reset: () => reset5,
   scoreClassificationForDOMContentLoaded: () => scoreClassificationForDOMContentLoaded,
   scoreClassificationForFirstContentfulPaint: () => scoreClassificationForFirstContentfulPaint,
   scoreClassificationForLargestContentfulPaint: () => scoreClassificationForLargestContentfulPaint,
@@ -1872,7 +2154,7 @@ __export(PageLoadMetricsHandler_exports, {
 });
 var metricScoresByFrameId = /* @__PURE__ */ new Map();
 var allMarkerEvents = [];
-function reset4() {
+function reset5() {
   metricScoresByFrameId.clear();
   pageLoadEventsArray = [];
   allMarkerEvents = [];
@@ -1899,7 +2181,7 @@ var pageLoadEventTypeGuards = [
 function eventIsPageLoadEvent(event) {
   return pageLoadEventTypeGuards.some((fn) => fn(event));
 }
-function handleEvent4(event) {
+function handleEvent5(event) {
   if (!eventIsPageLoadEvent(event)) {
     return;
   }
@@ -1911,7 +2193,7 @@ function storePageLoadMetricAgainstNavigationId(navigation, event) {
     throw new Error("Navigation event unexpectedly had no navigation ID.");
   }
   const frameId = getFrameIdForPageLoadEvent(event);
-  const { rendererProcessesByFrame } = data2();
+  const { rendererProcessesByFrame } = data3();
   const rendererProcessesInFrame = rendererProcessesByFrame.get(frameId);
   if (!rendererProcessesInFrame) {
     return;
@@ -1923,12 +2205,6 @@ function storePageLoadMetricAgainstNavigationId(navigation, event) {
   if (TraceEvents_exports.isTraceEventNavigationStart(event)) {
     return;
   }
-  const minTime = processData[0].window.min;
-  const maxTime = processData.at(-1)?.window.max || 0;
-  const eventBelongsToProcess = event.ts >= minTime && event.ts <= maxTime;
-  if (!eventBelongsToProcess) {
-    return;
-  }
   if (TraceEvents_exports.isTraceEventFirstContentfulPaint(event)) {
     const fcpTime = Timing_exports2.MicroSeconds(event.ts - navigation.ts);
     const score = Timing_exports3.formatMicrosecondsTime(fcpTime, {
@@ -2082,7 +2358,7 @@ function getNavigationForPageLoadEvent(event) {
     if (!navigationId) {
       throw new Error("Trace event unexpectedly had no navigation ID.");
     }
-    const { navigationsByNavigationId: navigationsByNavigationId2 } = data2();
+    const { navigationsByNavigationId: navigationsByNavigationId2 } = data3();
     const navigation = navigationsByNavigationId2.get(navigationId);
     if (!navigation) {
       return null;
@@ -2091,7 +2367,7 @@ function getNavigationForPageLoadEvent(event) {
   }
   if (TraceEvents_exports.isTraceEventMarkDOMContent(event) || TraceEvents_exports.isTraceEventInteractiveTime(event) || TraceEvents_exports.isTraceEventLayoutShift(event) || TraceEvents_exports.isTraceEventMarkLoad(event)) {
     const frameId = getFrameIdForPageLoadEvent(event);
-    const { navigationsByFrameId: navigationsByFrameId2 } = data2();
+    const { navigationsByFrameId: navigationsByFrameId2 } = data3();
     return Trace_exports.getNavigationForTraceEvent(event, frameId, navigationsByFrameId2);
   }
   if (TraceEvents_exports.isTraceEventNavigationStart(event)) {
@@ -2164,7 +2440,7 @@ function gatherFinalLCPEvents() {
   }
   return allFinalLCPEvents;
 }
-async function finalize4() {
+async function finalize5() {
   pageLoadEventsArray.sort((a, b) => a.ts - b.ts);
   for (const pageLoadEvent of pageLoadEventsArray) {
     const navigation = getNavigationForPageLoadEvent(pageLoadEvent);
@@ -2173,12 +2449,12 @@ async function finalize4() {
     }
   }
   const allFinalLCPEvents = gatherFinalLCPEvents();
-  const mainFrame = data2().mainFrameId;
+  const mainFrame = data3().mainFrameId;
   const allEventsButLCP = pageLoadEventsArray.filter((event) => !TraceEvents_exports.isTraceEventLargestContentfulPaintCandidate(event));
   const markerEvents = [...allFinalLCPEvents, ...allEventsButLCP].filter(isTraceEventMarkerEvent);
   allMarkerEvents = markerEvents.filter((event) => getFrameIdForPageLoadEvent(event) === mainFrame).sort((a, b) => a.ts - b.ts);
 }
-function data4() {
+function data5() {
   return {
     metricScoresByFrameId: new Map(metricScoresByFrameId),
     allMarkerEvents: [...allMarkerEvents]
@@ -2209,32 +2485,32 @@ var MetricName = /* @__PURE__ */ ((MetricName2) => {
 // front_end/models/trace/handlers/ScreenshotsHandler.ts
 var ScreenshotsHandler_exports = {};
 __export(ScreenshotsHandler_exports, {
-  data: () => data5,
+  data: () => data6,
   deps: () => deps3,
-  finalize: () => finalize5,
-  handleEvent: () => handleEvent5,
-  reset: () => reset5
+  finalize: () => finalize6,
+  handleEvent: () => handleEvent6,
+  reset: () => reset6
 });
 var eventsInProcessThread2 = /* @__PURE__ */ new Map();
 var snapshots = [];
-function reset5() {
+function reset6() {
   eventsInProcessThread2.clear();
   snapshots.length = 0;
 }
-function handleEvent5(event) {
-  if (event.ph !== TraceEvents_exports.Phase.OBJECT_SNAPSHOT || event.name !== "Screenshot") {
+function handleEvent6(event) {
+  if (event.name !== "Screenshot") {
     return;
   }
   Trace_exports.addEventToProcessThread(event, eventsInProcessThread2);
 }
-async function finalize5() {
-  const { browserProcessId: browserProcessId2, browserThreadId: browserThreadId2 } = data2();
+async function finalize6() {
+  const { browserProcessId: browserProcessId2, browserThreadId: browserThreadId2 } = data3();
   const browserThreads = eventsInProcessThread2.get(browserProcessId2);
   if (browserThreads) {
     snapshots = browserThreads.get(browserThreadId2) || [];
   }
 }
-function data5() {
+function data6() {
   return [...snapshots];
 }
 function deps3() {
@@ -2259,7 +2535,7 @@ function initialize3() {
   }
   handlerState4 = 2 /* INITIALIZED */;
 }
-function reset6() {
+function reset7() {
   handlerState4 = 1 /* UNINITIALIZED */;
   layoutShiftEvents.length = 0;
   layoutInvalidationEvents.length = 0;
@@ -2269,7 +2545,7 @@ function reset6() {
   scoreRecords.length = 0;
   clsWindowID = -1;
 }
-function handleEvent6(event) {
+function handleEvent7(event) {
   if (handlerState4 !== 2 /* INITIALIZED */) {
     throw new Error("Handler is not initialized");
   }
@@ -2301,7 +2577,7 @@ function updateTraceWindowMax(traceWindow, newMax) {
   traceWindow.range = Timing_exports2.MicroSeconds(traceWindow.max - traceWindow.min);
 }
 function findNextScreenshotSource(timestamp) {
-  const screenshots = data5();
+  const screenshots = data6();
   const screenshotIndex = findNextScreenshotEventIndex(screenshots, timestamp);
   if (!screenshotIndex) {
     return void 0;
@@ -2312,7 +2588,7 @@ function findNextScreenshotEventIndex(screenshots, timestamp) {
   return array_utilities_exports.nearestIndexFromBeginning(screenshots, (frame) => frame.ts > timestamp);
 }
 function buildScoreRecords() {
-  const { traceBounds: traceBounds2 } = data2();
+  const { traceBounds: traceBounds2 } = data3();
   scoreRecords.push({ ts: traceBounds2.min, score: 0 });
   for (const cluster of clusters) {
     let clusterScore = 0;
@@ -2330,7 +2606,7 @@ function buildScoreRecords() {
     scoreRecords.push({ ts: cluster.clusterWindow.max, score: 0 });
   }
 }
-async function finalize6() {
+async function finalize7() {
   layoutShiftEvents.sort((a, b) => a.ts - b.ts);
   prePaintEvents.sort((a, b) => a.ts - b.ts);
   layoutInvalidationEvents.sort((a, b) => a.ts - b.ts);
@@ -2339,7 +2615,7 @@ async function finalize6() {
   handlerState4 = 3 /* FINALIZED */;
 }
 async function buildLayoutShiftsClusters() {
-  const { navigationsByFrameId: navigationsByFrameId2, mainFrameId: mainFrameId2, traceBounds: traceBounds2 } = data2();
+  const { navigationsByFrameId: navigationsByFrameId2, mainFrameId: mainFrameId2, traceBounds: traceBounds2 } = data3();
   const navigations = navigationsByFrameId2.get(mainFrameId2) || [];
   if (layoutShiftEvents.length === 0) {
     return;
@@ -2450,7 +2726,7 @@ async function buildLayoutShiftsClusters() {
     }
   }
 }
-function data6() {
+function data7() {
   if (handlerState4 !== 3 /* FINALIZED */) {
     throw new Error("Layout Shifts Handler is not finalized");
   }
@@ -2487,34 +2763,34 @@ var LayoutShiftsThreshold = /* @__PURE__ */ ((LayoutShiftsThreshold2) => {
 // front_end/models/trace/handlers/MemoryHandler.ts
 var MemoryHandler_exports = {};
 __export(MemoryHandler_exports, {
-  data: () => data7,
-  handleEvent: () => handleEvent7,
-  reset: () => reset7
+  data: () => data8,
+  handleEvent: () => handleEvent8,
+  reset: () => reset8
 });
 var updateCountersByProcess = /* @__PURE__ */ new Map();
-function reset7() {
+function reset8() {
   updateCountersByProcess.clear();
 }
-function handleEvent7(event) {
+function handleEvent8(event) {
   if (TraceEvents_exports.isTraceEventUpdateCounters(event)) {
     const countersForProcess = map_utilities_exports.getWithDefault(updateCountersByProcess, event.pid, () => []);
     countersForProcess.push(event);
     updateCountersByProcess.set(event.pid, countersForProcess);
   }
 }
-function data7() {
+function data8() {
   return { updateCountersByProcess: new Map(updateCountersByProcess) };
 }
 
 // front_end/models/trace/handlers/NetworkRequestsHandler.ts
 var NetworkRequestsHandler_exports = {};
 __export(NetworkRequestsHandler_exports, {
-  data: () => data8,
+  data: () => data9,
   deps: () => deps5,
-  finalize: () => finalize7,
-  handleEvent: () => handleEvent8,
+  finalize: () => finalize8,
+  handleEvent: () => handleEvent9,
   initialize: () => initialize4,
-  reset: () => reset8
+  reset: () => reset9
 });
 var MILLISECONDS_TO_MICROSECONDS = 1e3;
 var SECONDS_TO_MICROSECONDS = 1e6;
@@ -2546,7 +2822,7 @@ function firstPositiveValueInList(entries) {
   return 0;
 }
 var handlerState5 = 1 /* UNINITIALIZED */;
-function reset8() {
+function reset9() {
   requestsByOrigin.clear();
   requestMap.clear();
   requestsByTime.length = 0;
@@ -2555,7 +2831,7 @@ function reset8() {
 function initialize4() {
   handlerState5 = 2 /* INITIALIZED */;
 }
-function handleEvent8(event) {
+function handleEvent9(event) {
   if (handlerState5 !== 2 /* INITIALIZED */) {
     throw new Error("Network Request handler is not initialized");
   }
@@ -2588,11 +2864,11 @@ function handleEvent8(event) {
     return;
   }
 }
-async function finalize7() {
+async function finalize8() {
   if (handlerState5 !== 2 /* INITIALIZED */) {
     throw new Error("Network Request handler is not initialized");
   }
-  const { rendererProcessesByFrame } = data2();
+  const { rendererProcessesByFrame } = data3();
   for (const [requestId, request] of requestMap.entries()) {
     if (!request.sendRequests || !request.receiveResponse) {
       continue;
@@ -2735,7 +3011,7 @@ async function finalize7() {
   }
   handlerState5 = 3 /* FINALIZED */;
 }
-function data8() {
+function data9() {
   if (handlerState5 !== 3 /* FINALIZED */) {
     throw new Error("Network Request handler is not finalized");
   }
@@ -2753,11 +3029,11 @@ var UserInteractionsHandler_exports = {};
 __export(UserInteractionsHandler_exports, {
   LONG_INTERACTION_THRESHOLD: () => LONG_INTERACTION_THRESHOLD,
   categoryOfInteraction: () => categoryOfInteraction,
-  data: () => data9,
-  finalize: () => finalize8,
-  handleEvent: () => handleEvent9,
+  data: () => data10,
+  finalize: () => finalize9,
+  handleEvent: () => handleEvent10,
   removeNestedInteractions: () => removeNestedInteractions,
-  reset: () => reset9
+  reset: () => reset10
 });
 var allEvents = [];
 var LONG_INTERACTION_THRESHOLD = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(200));
@@ -2767,7 +3043,7 @@ var interactionEventsWithNoNesting = [];
 var eventTimingEndEventsById = /* @__PURE__ */ new Map();
 var eventTimingStartEventsForInteractions = [];
 var handlerState6 = 1 /* UNINITIALIZED */;
-function reset9() {
+function reset10() {
   allEvents.length = 0;
   interactionEvents.length = 0;
   eventTimingStartEventsForInteractions.length = 0;
@@ -2776,7 +3052,7 @@ function reset9() {
   longestInteractionEvent = null;
   handlerState6 = 2 /* INITIALIZED */;
 }
-function handleEvent9(event) {
+function handleEvent10(event) {
   if (handlerState6 !== 2 /* INITIALIZED */) {
     throw new Error("Handler is not initialized");
   }
@@ -2847,7 +3123,7 @@ function removeNestedInteractions(interactions) {
   });
   return keptEvents;
 }
-async function finalize8() {
+async function finalize9() {
   for (const interactionStartEvent of eventTimingStartEventsForInteractions) {
     const endEvent = eventTimingEndEventsById.get(interactionStartEvent.id);
     if (!endEvent) {
@@ -2881,7 +3157,7 @@ async function finalize8() {
   handlerState6 = 3 /* FINALIZED */;
   interactionEventsWithNoNesting.push(...removeNestedInteractions(interactionEvents));
 }
-function data9() {
+function data10() {
   return {
     allEvents: [...allEvents],
     interactionEvents: [...interactionEvents],
@@ -2896,10 +3172,10 @@ function data9() {
 // front_end/models/trace/handlers/UserTimingsHandler.ts
 var UserTimingsHandler_exports = {};
 __export(UserTimingsHandler_exports, {
-  data: () => data10,
-  finalize: () => finalize9,
-  handleEvent: () => handleEvent10,
-  reset: () => reset10
+  data: () => data11,
+  finalize: () => finalize10,
+  handleEvent: () => handleEvent11,
+  reset: () => reset11
 });
 var syntheticEvents = [];
 var performanceMeasureEvents = [];
@@ -2907,7 +3183,7 @@ var performanceMarkEvents = [];
 var consoleTimings = [];
 var timestampEvents = [];
 var handlerState7 = 1 /* UNINITIALIZED */;
-function reset10() {
+function reset11() {
   syntheticEvents.length = 0;
   performanceMeasureEvents.length = 0;
   performanceMarkEvents.length = 0;
@@ -2953,7 +3229,7 @@ var navTimingNames = [
   "loadEventStart",
   "loadEventEnd"
 ];
-function handleEvent10(event) {
+function handleEvent11(event) {
   if (handlerState7 !== 2 /* INITIALIZED */) {
     throw new Error("UserTimings handler is not initialized");
   }
@@ -2975,7 +3251,7 @@ function handleEvent10(event) {
     timestampEvents.push(event);
   }
 }
-async function finalize9() {
+async function finalize10() {
   if (handlerState7 !== 2 /* INITIALIZED */) {
     throw new Error("UserTimings handler is not initialized");
   }
@@ -3025,7 +3301,7 @@ async function finalize9() {
   syntheticEvents.sort((a, b) => a.ts - b.ts);
   handlerState7 = 3 /* FINALIZED */;
 }
-function data10() {
+function data11() {
   if (handlerState7 !== 3 /* FINALIZED */) {
     throw new Error("UserTimings handler is not finalized");
   }
@@ -3042,15 +3318,17 @@ var WarningsHandler_exports = {};
 __export(WarningsHandler_exports, {
   FORCED_LAYOUT_AND_STYLES_THRESHOLD: () => FORCED_LAYOUT_AND_STYLES_THRESHOLD,
   LONG_MAIN_THREAD_TASK_THRESHOLD: () => LONG_MAIN_THREAD_TASK_THRESHOLD,
-  data: () => data11,
-  handleEvent: () => handleEvent11,
-  reset: () => reset11
+  data: () => data12,
+  deps: () => deps6,
+  finalize: () => finalize11,
+  handleEvent: () => handleEvent12,
+  reset: () => reset12
 });
 var warningsPerEvent = /* @__PURE__ */ new Map();
 var eventsPerWarning = /* @__PURE__ */ new Map();
 var FORCED_LAYOUT_AND_STYLES_THRESHOLD = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(10));
 var LONG_MAIN_THREAD_TASK_THRESHOLD = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(50));
-function reset11() {
+function reset12() {
   warningsPerEvent.clear();
   eventsPerWarning.clear();
 }
@@ -3062,7 +3340,7 @@ function storeWarning(event, warning) {
   existingEvents.push(event);
   eventsPerWarning.set(warning, existingEvents);
 }
-function handleEvent11(event) {
+function handleEvent12(event) {
   if (event.name === TraceEvents_exports.KnownEventName.RunTask) {
     const { duration } = Timing_exports3.eventTimingsMicroSeconds(event);
     if (duration > LONG_MAIN_THREAD_TASK_THRESHOLD) {
@@ -3090,7 +3368,16 @@ function handleEvent11(event) {
     return;
   }
 }
-function data11() {
+function deps6() {
+  return ["UserInteractions"];
+}
+async function finalize11() {
+  const longInteractions = data10().interactionsOverThreshold;
+  for (const interaction of longInteractions) {
+    storeWarning(interaction, "LONG_INTERACTION");
+  }
+}
+function data12() {
   return {
     perEvent: new Map(warningsPerEvent),
     perWarning: new Map(eventsPerWarning)
@@ -3100,11 +3387,11 @@ function data11() {
 // front_end/models/trace/handlers/WorkersHandler.ts
 var WorkersHandler_exports = {};
 __export(WorkersHandler_exports, {
-  data: () => data12,
-  finalize: () => finalize10,
-  handleEvent: () => handleEvent12,
+  data: () => data13,
+  finalize: () => finalize12,
+  handleEvent: () => handleEvent13,
   initialize: () => initialize5,
-  reset: () => reset12
+  reset: () => reset13
 });
 var handlerState8 = 1 /* UNINITIALIZED */;
 var sessionIdEvents = [];
@@ -3116,12 +3403,12 @@ function initialize5() {
   }
   handlerState8 = 2 /* INITIALIZED */;
 }
-function reset12() {
+function reset13() {
   sessionIdEvents.length = 0;
   workerIdByThread.clear();
   handlerState8 = 1 /* UNINITIALIZED */;
 }
-function handleEvent12(event) {
+function handleEvent13(event) {
   if (handlerState8 !== 2 /* INITIALIZED */) {
     throw new Error("Workers Handler is not initialized");
   }
@@ -3129,7 +3416,7 @@ function handleEvent12(event) {
     sessionIdEvents.push(event);
   }
 }
-async function finalize10() {
+async function finalize12() {
   if (handlerState8 !== 2 /* INITIALIZED */) {
     throw new Error("Handler is not initialized");
   }
@@ -3142,7 +3429,7 @@ async function finalize10() {
   }
   handlerState8 = 3 /* FINALIZED */;
 }
-function data12() {
+function data13() {
   if (handlerState8 !== 3 /* FINALIZED */) {
     throw new Error("Workers Handler is not finalized");
   }
@@ -3156,6 +3443,7 @@ function data12() {
 // front_end/models/trace/handlers/Migration.ts
 var ENABLED_TRACE_HANDLERS = {
   Animations: AnimationHandler_exports,
+  AuctionWorklets: AuctionWorkletsHandler_exports,
   UserTimings: UserTimingsHandler_exports,
   PageLoadMetrics: PageLoadMetricsHandler_exports,
   UserInteractions: UserInteractionsHandler_exports,
@@ -3190,119 +3478,6 @@ __export(ModelHandlers_exports, {
   Workers: () => WorkersHandler_exports
 });
 
-// front_end/models/trace/handlers/AuctionWorkletsHandler.ts
-var AuctionWorkletsHandler_exports = {};
-__export(AuctionWorkletsHandler_exports, {
-  data: () => data13,
-  finalize: () => finalize11,
-  handleEvent: () => handleEvent13,
-  reset: () => reset13
-});
-var runningInProcessEvents = /* @__PURE__ */ new Map();
-var doneWithProcessEvents = /* @__PURE__ */ new Map();
-var createdSyntheticEvents = /* @__PURE__ */ new Map();
-var utilityThreads = /* @__PURE__ */ new Map();
-var v8HelperThreads = /* @__PURE__ */ new Map();
-function reset13() {
-  runningInProcessEvents.clear();
-  doneWithProcessEvents.clear();
-  createdSyntheticEvents.clear();
-  utilityThreads.clear();
-  v8HelperThreads.clear();
-}
-function handleEvent13(event) {
-  if (TraceEvents_exports.isTraceEventAuctionWorkletRunningInProcess(event)) {
-    runningInProcessEvents.set(event.args.data.pid, event);
-    return;
-  }
-  if (TraceEvents_exports.isTraceEventAuctionWorkletDoneWithProcess(event)) {
-    doneWithProcessEvents.set(event.args.data.pid, event);
-    return;
-  }
-  if (TraceEvents_exports.isThreadName(event)) {
-    if (event.args.name === "auction_worklet.CrUtilityMain") {
-      utilityThreads.set(event.pid, event);
-      return;
-    }
-    if (event.args.name === "AuctionV8HelperThread") {
-      v8HelperThreads.set(event.pid, event);
-    }
-  }
-}
-function workletType(input) {
-  switch (input) {
-    case "seller":
-      return TraceEvents_exports.AuctionWorkletType.SELLER;
-    case "bidder":
-      return TraceEvents_exports.AuctionWorkletType.BIDDER;
-    default:
-      return TraceEvents_exports.AuctionWorkletType.UNKNOWN;
-  }
-}
-function makeSyntheticEventBase(event) {
-  return {
-    name: "SyntheticAuctionWorkletEvent",
-    s: TraceEvents_exports.TraceEventScope.THREAD,
-    cat: event.cat,
-    tid: event.tid,
-    ts: event.ts,
-    ph: TraceEvents_exports.Phase.INSTANT,
-    pid: event.args.data.pid,
-    host: event.args.data.host,
-    target: event.args.data.target,
-    type: workletType(event.args.data.type)
-  };
-}
-async function finalize11() {
-  for (const [pid, utilityThreadNameEvent] of utilityThreads) {
-    const v8HelperEvent = v8HelperThreads.get(pid);
-    if (!v8HelperEvent) {
-      continue;
-    }
-    const runningEvent = runningInProcessEvents.get(pid);
-    const doneWithEvent = doneWithProcessEvents.get(pid);
-    let syntheticEvent = null;
-    if (runningEvent) {
-      syntheticEvent = {
-        ...makeSyntheticEventBase(runningEvent),
-        args: {
-          data: {
-            runningInProcessEvent: runningEvent,
-            utilityThread: utilityThreadNameEvent,
-            v8HelperThread: v8HelperEvent
-          }
-        }
-      };
-      if (doneWithEvent) {
-        syntheticEvent.args.data.doneWithProcessEvent = doneWithEvent;
-      }
-    } else if (doneWithEvent) {
-      syntheticEvent = {
-        ...makeSyntheticEventBase(doneWithEvent),
-        args: {
-          data: {
-            doneWithProcessEvent: doneWithEvent,
-            utilityThread: utilityThreadNameEvent,
-            v8HelperThread: v8HelperEvent
-          }
-        }
-      };
-      if (runningEvent) {
-        syntheticEvent.args.data.runningInProcessEvent = runningEvent;
-      }
-    }
-    if (syntheticEvent === null) {
-      continue;
-    }
-    createdSyntheticEvents.set(pid, syntheticEvent);
-  }
-}
-function data13() {
-  return {
-    worklets: new Map(createdSyntheticEvents)
-  };
-}
-
 // front_end/models/trace/handlers/LargestImagePaintHandler.ts
 var LargestImagePaintHandler_exports = {};
 __export(LargestImagePaintHandler_exports, {
@@ -3360,24 +3535,23 @@ __export(RendererHandler_exports, {
   assignThreadName: () => assignThreadName,
   buildHierarchy: () => buildHierarchy,
   data: () => data17,
-  deps: () => deps6,
-  finalize: () => finalize13,
+  deps: () => deps7,
+  finalize: () => finalize14,
   handleEvent: () => handleEvent17,
   handleUserConfig: () => handleUserConfig,
   initialize: () => initialize7,
   makeCompleteEvent: () => makeCompleteEvent,
   reset: () => reset17,
   sanitizeProcesses: () => sanitizeProcesses,
-  sanitizeThreads: () => sanitizeThreads,
-  treify: () => treify
+  sanitizeThreads: () => sanitizeThreads
 });
 
 // front_end/models/trace/handlers/SamplesHandler.ts
 var SamplesHandler_exports = {};
 __export(SamplesHandler_exports, {
-  buildProfileCalls: () => buildProfileCalls,
   data: () => data16,
-  finalize: () => finalize12,
+  finalize: () => finalize13,
+  getProfileCallFunctionName: () => getProfileCallFunctionName,
   handleEvent: () => handleEvent16,
   initialize: () => initialize6,
   reset: () => reset16
@@ -3535,7 +3709,7 @@ var CPUProfileDataModel = class extends ProfileTreeModel {
     this.profileHead = this.translateProfileTree(profile.nodes);
     this.initialize(this.profileHead);
     this.extractMetaNodes();
-    if (this.samples) {
+    if (this.samples?.length) {
       this.sortSamples();
       this.normalizeTimestamps();
       this.fixMissingSamples();
@@ -3858,61 +4032,63 @@ var CPUProfileDataModel = class extends ProfileTreeModel {
 // front_end/models/trace/handlers/SamplesHandler.ts
 var events = /* @__PURE__ */ new Map();
 var profilesInProcess = /* @__PURE__ */ new Map();
+var entryToNode = /* @__PURE__ */ new Map();
 var preprocessedData = /* @__PURE__ */ new Map();
 var handlerState9 = 1 /* UNINITIALIZED */;
 function buildProfileCalls() {
   for (const [processId, profiles] of preprocessedData) {
     for (const [profileId, preProcessedData] of profiles) {
-      let openFrameCallback = function(_depth, node, timeStampMs) {
+      let openFrameCallback = function(depth, node, timeStampMs) {
+        if (threadId === void 0) {
+          return;
+        }
         const ts = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(timeStampMs));
-        trackingStack.push({ callFrame: node.callFrame, ts, pid: processId, children: [], tid: threadId });
-      }, closeFrameCallback = function(depth, node, _timeStamp, durMs, selfTimeMs) {
-        const partialProfileCall = trackingStack.pop();
-        if (!partialProfileCall) {
+        const nodeId = node.id;
+        const profileCall = Trace_exports.makeProfileCall(node, ts, processId, threadId);
+        finalizedData.profileCalls.push(profileCall);
+        indexStack.push(finalizedData.profileCalls.length - 1);
+        const traceEntryNode = TreeHelpers_exports.makeEmptyTraceEntryNode(profileCall, nodeId);
+        finalizedData.profileTree?.nodes.set(nodeId, traceEntryNode);
+        entryToNode.set(profileCall, traceEntryNode);
+        traceEntryNode.depth = depth;
+        if (indexStack.length === 1) {
+          finalizedData.profileTree?.roots.add(traceEntryNode);
+        }
+      }, closeFrameCallback = function(_depth, node, _timeStamp, durMs, selfTimeMs) {
+        const profileCallIndex = indexStack.pop();
+        const profileCall = profileCallIndex !== void 0 && finalizedData.profileCalls[profileCallIndex];
+        if (!profileCall) {
           return;
         }
-        const { callFrame, ts, pid, children, tid } = partialProfileCall;
-        if (callFrame === void 0 || ts === void 0 || pid === void 0 || profileId === void 0 || children === void 0 || tid === void 0) {
+        const { callFrame, ts, pid, tid } = profileCall;
+        const traceEntryNode = entryToNode.get(profileCall);
+        if (callFrame === void 0 || ts === void 0 || pid === void 0 || profileId === void 0 || tid === void 0 || traceEntryNode === void 0) {
           return;
         }
         const dur = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(durMs));
         const selfTime = Timing_exports3.millisecondsToMicroseconds(Timing_exports2.MilliSeconds(selfTimeMs));
-        const completeProfileCall = {
-          callFrame,
-          ts,
-          pid,
-          dur,
-          selfTime,
-          children,
-          ph: TraceEvents_exports.Phase.COMPLETE,
-          cat: "",
-          args: {},
-          name: "ProfileCall",
-          tid,
-          nodeId: node.id
-        };
-        const parent = trackingStack.at(-1);
-        const calls = finalizedData.profileCalls;
-        calls.push(completeProfileCall);
-        if (!parent) {
+        profileCall.dur = dur;
+        profileCall.selfTime = selfTime;
+        const parentIndex = indexStack.at(-1);
+        const parent = parentIndex !== void 0 && finalizedData.profileCalls.at(parentIndex);
+        const parentNode = parent && entryToNode.get(parent);
+        if (!parentNode) {
           return;
         }
-        parent.children = parent.children || [];
-        parent.children.push(completeProfileCall);
-        if (parent.selfTime) {
-          parent.selfTime = Timing_exports2.MicroSeconds(parent.selfTime - dur);
-        }
+        traceEntryNode.parentId = parentNode.id;
+        parentNode.children.add(traceEntryNode);
       };
       const threadId = preProcessedData.threadId;
-      if (!preProcessedData.rawProfile.nodes.length || !threadId) {
+      if (!preProcessedData.rawProfile.nodes.length || threadId === void 0) {
         continue;
       }
-      const trackingStack = [];
+      const indexStack = [];
       const profileModel = new CPUProfileDataModel_exports.CPUProfileDataModel(preProcessedData.rawProfile);
-      const finalizedData = { rawProfile: preProcessedData.rawProfile, parsedProfile: profileModel, profileCalls: [] };
-      profileModel.forEachFrame(openFrameCallback, closeFrameCallback);
-      Trace_exports.sortTraceEventsInPlace(finalizedData.profileCalls);
+      const profileTree = TreeHelpers_exports.makeEmptyTraceEntryTree();
+      profileTree.maxDepth = profileModel.maxDepth;
+      const finalizedData = { rawProfile: preProcessedData.rawProfile, parsedProfile: profileModel, profileCalls: [], profileTree };
       const dataByThread = map_utilities_exports.getWithDefault(profilesInProcess, processId, () => /* @__PURE__ */ new Map());
+      profileModel.forEachFrame(openFrameCallback, closeFrameCallback);
       dataByThread.set(threadId, finalizedData);
     }
   }
@@ -3921,6 +4097,7 @@ function reset16() {
   events.clear();
   preprocessedData.clear();
   profilesInProcess.clear();
+  entryToNode.clear();
   handlerState9 = 1 /* UNINITIALIZED */;
 }
 function initialize6() {
@@ -3933,6 +4110,15 @@ function handleEvent16(event) {
   if (handlerState9 !== 2 /* INITIALIZED */) {
     throw new Error("Samples Handler is not initialized");
   }
+  if (TraceEvents_exports.isSyntheticTraceEventCpuProfile(event)) {
+    const pid = event.pid;
+    const tid = event.tid;
+    const profileId = "0x1";
+    const profileData = getOrCreatePreProcessedData(pid, profileId);
+    profileData.rawProfile = event.args.data.cpuProfile;
+    profileData.threadId = tid;
+    return;
+  }
   if (TraceEvents_exports.isTraceEventProfile(event)) {
     const profileData = getOrCreatePreProcessedData(event.pid, event.id);
     profileData.rawProfile.startTime = event.ts;
@@ -3979,7 +4165,7 @@ function handleEvent16(event) {
     return;
   }
 }
-async function finalize12() {
+async function finalize13() {
   if (handlerState9 !== 2 /* INITIALIZED */) {
     throw new Error("Samples Handler is not initialized");
   }
@@ -3991,7 +4177,8 @@ function data16() {
     throw new Error("Samples Handler is not finalized");
   }
   return {
-    profilesInProcess: new Map(profilesInProcess)
+    profilesInProcess: new Map(profilesInProcess),
+    entryToNode: new Map(entryToNode)
   };
 }
 function getOrCreatePreProcessedData(processId, profileId) {
@@ -4008,14 +4195,20 @@ function getOrCreatePreProcessedData(processId, profileId) {
     profileId
   }));
 }
+function getProfileCallFunctionName(data18, entry) {
+  const profile = data18.profilesInProcess.get(entry.pid)?.get(entry.tid);
+  const node = profile?.parsedProfile.nodeById(entry.nodeId);
+  if (node?.functionName) {
+    return node.functionName;
+  }
+  return entry.callFrame.functionName;
+}
 
 // front_end/models/trace/handlers/RendererHandler.ts
 var processes = /* @__PURE__ */ new Map();
 var compositorTileWorkers = Array();
-var entryToNode = /* @__PURE__ */ new Map();
+var entryToNode2 = /* @__PURE__ */ new Map();
 var allRendererEvents = [];
-var nodeIdCount = 0;
-var makeRendererEntrytNodeId = () => ++nodeIdCount;
 var completeEventStack = [];
 var handlerState10 = 1 /* UNINITIALIZED */;
 var config = Configuration_exports.DEFAULT;
@@ -4028,18 +4221,6 @@ var makeRendererThread = () => ({
   name: null,
   entries: []
 });
-var makeEmptyRendererTree = () => ({
-  nodes: /* @__PURE__ */ new Map(),
-  roots: /* @__PURE__ */ new Set(),
-  maxDepth: 0
-});
-var makeEmptyRendererEventNode = (entry, id) => ({
-  entry,
-  id,
-  parentId: null,
-  children: /* @__PURE__ */ new Set(),
-  depth: 0
-});
 var getOrCreateRendererProcess = (processes2, pid) => {
   return map_utilities_exports.getWithDefault(processes2, pid, makeRendererProcess);
 };
@@ -4051,11 +4232,10 @@ function handleUserConfig(userConfig) {
 }
 function reset17() {
   processes.clear();
-  entryToNode.clear();
+  entryToNode2.clear();
   allRendererEvents.length = 0;
   completeEventStack.length = 0;
   compositorTileWorkers.length = 0;
-  nodeIdCount = -1;
   handlerState10 = 1 /* UNINITIALIZED */;
 }
 function initialize7() {
@@ -4092,11 +4272,11 @@ function handleEvent17(event) {
     allRendererEvents.push(event);
   }
 }
-async function finalize13() {
+async function finalize14() {
   if (handlerState10 !== 2 /* INITIALIZED */) {
     throw new Error("Renderer Handler is not initialized");
   }
-  const { mainFrameId: mainFrameId2, rendererProcessesByFrame, threadsInProcess: threadsInProcess2 } = data2();
+  const { mainFrameId: mainFrameId2, rendererProcessesByFrame, threadsInProcess: threadsInProcess2 } = data3();
   assignMeta(processes, mainFrameId2, rendererProcessesByFrame, threadsInProcess2);
   sanitizeProcesses(processes);
   buildHierarchy(processes);
@@ -4110,7 +4290,7 @@ function data17() {
   return {
     processes: new Map(processes),
     compositorTileWorkers: new Map(gatherCompositorThreads()),
-    entryToNode: new Map(entryToNode),
+    entryToNode: new Map(entryToNode2),
     allRendererEvents: [...allRendererEvents]
   };
 }
@@ -4167,9 +4347,15 @@ function assignThreadName(processes2, rendererProcessesByFrame, threadsInProcess
   }
 }
 function sanitizeProcesses(processes2) {
+  const auctionWorklets = data2().worklets;
   for (const [pid, process] of processes2) {
     if (process.url === null) {
-      processes2.delete(pid);
+      const maybeWorklet = auctionWorklets.get(pid);
+      if (maybeWorklet) {
+        process.url = maybeWorklet.host;
+      } else {
+        processes2.delete(pid);
+      }
       continue;
     }
     const asUrl = new URL(process.url);
@@ -4191,7 +4377,7 @@ function buildHierarchy(processes2, options) {
   for (const [pid, process] of processes2) {
     for (const [tid, thread] of process.threads) {
       if (!thread.entries.length) {
-        thread.tree = makeEmptyRendererTree();
+        thread.tree = TreeHelpers_exports.makeEmptyTraceEntryTree();
         continue;
       }
       Trace_exports.sortTraceEventsInPlace(thread.entries);
@@ -4201,69 +4387,13 @@ function buildHierarchy(processes2, options) {
       if (profileCalls) {
         thread.entries = Trace_exports.mergeEventsInOrder(thread.entries, profileCalls);
       }
-      thread.tree = treify(thread.entries, options);
-    }
-  }
-}
-function treify(entries, options) {
-  const stack = [];
-  nodeIdCount = -1;
-  const tree = makeEmptyRendererTree();
-  for (let i = 0; i < entries.length; i++) {
-    const event = entries[i];
-    if (options && !options.filter.has(event.name)) {
-      continue;
-    }
-    const duration = event.dur || 0;
-    const nodeId = makeRendererEntrytNodeId();
-    const node = makeEmptyRendererEventNode(event, nodeId);
-    if (stack.length === 0) {
-      tree.nodes.set(nodeId, node);
-      tree.roots.add(node);
-      event.selfTime = Timing_exports2.MicroSeconds(duration);
-      stack.push(node);
-      tree.maxDepth = Math.max(tree.maxDepth, stack.length);
-      entryToNode.set(event, node);
-      continue;
-    }
-    const parentNode = stack.at(-1);
-    if (parentNode === void 0) {
-      throw new Error("Impossible: no parent node found in the stack");
-    }
-    const parentEvent = parentNode.entry;
-    const begin = event.ts;
-    const parentBegin = parentEvent.ts;
-    const parentDuration = parentEvent.dur || 0;
-    const end = begin + duration;
-    const parentEnd = parentBegin + parentDuration;
-    const startsBeforeParent = begin < parentBegin;
-    if (startsBeforeParent) {
-      throw new Error("Impossible: current event starts before the parent event");
-    }
-    const startsAfterParent = begin >= parentEnd;
-    if (startsAfterParent) {
-      stack.pop();
-      i--;
-      nodeIdCount--;
-      continue;
-    }
-    const endsAfterParent = end > parentEnd;
-    if (endsAfterParent) {
-      continue;
-    }
-    tree.nodes.set(nodeId, node);
-    node.depth = stack.length;
-    node.parentId = parentNode.id;
-    parentNode.children.add(node);
-    event.selfTime = Timing_exports2.MicroSeconds(duration);
-    if (parentEvent.selfTime !== void 0) {
-      parentEvent.selfTime = Timing_exports2.MicroSeconds(parentEvent.selfTime - (event.dur || 0));
+      const treeData = TreeHelpers_exports.treify(thread.entries, options);
+      thread.tree = treeData.tree;
+      for (const [entry, node] of treeData.entryToNode) {
+        entryToNode2.set(entry, node);
+      }
     }
-    stack.push(node);
-    tree.maxDepth = Math.max(tree.maxDepth, stack.length);
-    entryToNode.set(event, node);
   }
-  return tree;
 }
 function makeCompleteEvent(event) {
   if (TraceEvents_exports.isTraceEventEnd(event)) {
@@ -4286,12 +4416,78 @@ function makeCompleteEvent(event) {
   completeEventStack.push(syntheticComplete);
   return syntheticComplete;
 }
-function deps6() {
-  return ["Meta", "Samples"];
+function deps7() {
+  return ["Meta", "Samples", "AuctionWorklets"];
+}
+
+// front_end/models/trace/handlers/Threads.ts
+var Threads_exports = {};
+__export(Threads_exports, {
+  ThreadType: () => ThreadType,
+  threadsInTrace: () => threadsInTrace
+});
+var ThreadType = /* @__PURE__ */ ((ThreadType2) => {
+  ThreadType2["MAIN_THREAD"] = "MAIN_THREAD";
+  ThreadType2["WORKER"] = "WORKER";
+  ThreadType2["RASTERIZER"] = "RASTERIZER";
+  ThreadType2["AUCTION_WORKLET"] = "AUCTION_WORKLET";
+  ThreadType2["OTHER"] = "OTHER";
+  ThreadType2["CPU_PROFILE"] = "CPU_PROFILE";
+  return ThreadType2;
+})(ThreadType || {});
+function getThreadTypeForRendererThread(traceParseData, pid, thread) {
+  let threadType = "OTHER" /* OTHER */;
+  if (thread.name === "CrRendererMain") {
+    threadType = "MAIN_THREAD" /* MAIN_THREAD */;
+  } else if (thread.name === "DedicatedWorker thread") {
+    threadType = "WORKER" /* WORKER */;
+  } else if (thread.name?.startsWith("CompositorTileWorker")) {
+    threadType = "RASTERIZER" /* RASTERIZER */;
+  } else if (traceParseData.AuctionWorklets.worklets.has(pid)) {
+    threadType = "AUCTION_WORKLET" /* AUCTION_WORKLET */;
+  }
+  return threadType;
+}
+function threadsInTrace(traceParseData) {
+  const foundThreads = [];
+  if (traceParseData.Renderer && traceParseData.Renderer.processes.size) {
+    for (const [pid, process] of traceParseData.Renderer.processes) {
+      for (const [tid, thread] of process.threads) {
+        const threadType = getThreadTypeForRendererThread(traceParseData, pid, thread);
+        if (!thread.tree) {
+          continue;
+        }
+        foundThreads.push({
+          name: thread.name,
+          pid,
+          tid,
+          entries: thread.entries,
+          tree: thread.tree,
+          type: threadType,
+          entryToNode: traceParseData.Renderer.entryToNode
+        });
+      }
+    }
+  } else if (traceParseData.Samples && traceParseData.Samples.profilesInProcess.size) {
+    for (const [pid, process] of traceParseData.Samples.profilesInProcess) {
+      for (const [tid, thread] of process) {
+        if (!thread.profileTree) {
+          continue;
+        }
+        foundThreads.push({
+          pid,
+          tid,
+          name: null,
+          entries: thread.profileCalls,
+          tree: thread.profileTree,
+          type: "CPU_PROFILE" /* CPU_PROFILE */,
+          entryToNode: traceParseData.Samples.entryToNode
+        });
+      }
+    }
+  }
+  return foundThreads;
 }
-var RendererEventNodeIdTag = class {
-  #tag;
-};
 
 // front_end/models/trace/LegacyTracingModel.ts
 var LegacyTracingModel_exports = {};
@@ -5112,9 +5308,9 @@ function sortHandlers(traceHandlers) {
     if (!handler) {
       return;
     }
-    const deps7 = handler.deps?.();
-    if (deps7) {
-      deps7.forEach(visitHandler);
+    const deps8 = handler.deps?.();
+    if (deps8) {
+      deps8.forEach(visitHandler);
     }
     sortedMap.set(handlerName, handler);
   };
@@ -5155,8 +5351,8 @@ var Model = class extends EventTarget {
   #lastRecordingIndex = 0;
   #processor;
   #config = Configuration_exports.DEFAULT;
-  static createWithAllHandlers() {
-    return new Model(ModelHandlers_exports);
+  static createWithAllHandlers(config2) {
+    return new Model(ModelHandlers_exports, config2);
   }
   static createWithRequiredHandlersForMigration(config2) {
     return new Model(Migration_exports.ENABLED_TRACE_HANDLERS, config2);
@@ -5276,9 +5472,9 @@ var TreeManipulator = class {
   #entryToNode;
   #lastVisibleEntries = null;
   #activeActions = [];
-  constructor(thread, entryToNode2) {
+  constructor(thread, entryToNode3) {
     this.#thread = thread;
-    this.#entryToNode = entryToNode2;
+    this.#entryToNode = entryToNode3;
   }
   applyAction(action) {
     if (this.#actionIsActive(action)) {