@paulirish/trace_engine 0.0.9 → 0.0.10

package/models/trace/handlers/UserTimingsHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/UserTimingsHandler.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {HandlerState} from './types.js';\n\n/**\n * IMPORTANT!\n * See UserTimings.md in this directory for some handy documentation on\n * UserTimings and the trace events we parse currently.\n **/\nlet syntheticEvents: Types.TraceEvents.SyntheticEventPair<Types.TraceEvents.TraceEventPairableAsync>[] = [];\nconst performanceMeasureEvents: Types.TraceEvents.TraceEventPerformanceMeasure[] = [];\nconst performanceMarkEvents: Types.TraceEvents.TraceEventPerformanceMark[] = [];\n\nconst consoleTimings: (Types.TraceEvents.TraceEventConsoleTimeBegin|Types.TraceEvents.TraceEventConsoleTimeEnd)[] = [];\n\nconst timestampEvents: Types.TraceEvents.TraceEventTimeStamp[] = [];\n\nexport interface UserTimingsData {\n  /**\n   * Events triggered with the performance.measure() API.\n   * https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure\n   */\n  performanceMeasures: readonly Types.TraceEvents.SyntheticUserTimingPair[];\n  /**\n   * Events triggered with the performance.mark() API.\n   * https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark\n   */\n  performanceMarks: readonly Types.TraceEvents.TraceEventPerformanceMark[];\n  /**\n   * Events triggered with the console.time(), console.timeEnd() and\n   * console.timeLog() API.\n   * https://developer.mozilla.org/en-US/docs/Web/API/console/time\n   */\n  consoleTimings: readonly Types.TraceEvents.SyntheticConsoleTimingPair[];\n  /**\n   * Events triggered with the console.timeStamp() API\n   * https://developer.mozilla.org/en-US/docs/Web/API/console/timeStamp\n   */\n  timestampEvents: readonly Types.TraceEvents.TraceEventTimeStamp[];\n}\nlet handlerState = HandlerState.UNINITIALIZED;\n\nexport function reset(): void {\n  syntheticEvents.length = 0;\n  performanceMeasureEvents.length = 0;\n  performanceMarkEvents.length = 0;\n  consoleTimings.length = 0;\n  timestampEvents.length = 0;\n  handlerState = HandlerState.INITIALIZED;\n}\n\nconst resourceTimingNames = [\n  'workerStart',\n  'redirectStart',\n  'redirectEnd',\n  'fetchStart',\n  'domainLookupStart',\n  'domainLookupEnd',\n  'connectStart',\n  'connectEnd',\n  'secureConnectionStart',\n  'requestStart',\n  'responseStart',\n  'responseEnd',\n];\nconst navTimingNames = [\n  'navigationStart',\n  'unloadEventStart',\n  'unloadEventEnd',\n  'redirectStart',\n  'redirectEnd',\n  'fetchStart',\n  'commitNavigationEnd',\n  'domainLookupStart',\n  'domainLookupEnd',\n  'connectStart',\n  'connectEnd',\n  'secureConnectionStart',\n  'requestStart',\n  'responseStart',\n  'responseEnd',\n  'domLoading',\n  'domInteractive',\n  'domContentLoadedEventStart',\n  'domContentLoadedEventEnd',\n  'domComplete',\n  'loadEventStart',\n  'loadEventEnd',\n];\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('UserTimings handler is not initialized');\n  }\n\n  // These are events dispatched under the blink.user_timing category\n  // but that the user didn't add. Filter them out so that they do not\n  // Appear in the timings track (they still appear in the main thread\n  // flame chart).\n  const ignoredNames = [...resourceTimingNames, ...navTimingNames];\n  if (ignoredNames.includes(event.name)) {\n    return;\n  }\n\n  if (Types.TraceEvents.isTraceEventPerformanceMeasure(event)) {\n    performanceMeasureEvents.push(event);\n    return;\n  }\n  if (Types.TraceEvents.isTraceEventPerformanceMark(event)) {\n    performanceMarkEvents.push(event);\n  }\n  if (Types.TraceEvents.isTraceEventConsoleTime(event)) {\n    consoleTimings.push(event);\n  }\n  if (Types.TraceEvents.isTraceEventTimeStamp(event)) {\n    timestampEvents.push(event);\n  }\n}\n\nexport async function finalize(): Promise<void> {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('UserTimings handler is not initialized');\n  }\n\n  const asyncEvents = [...performanceMeasureEvents, ...consoleTimings];\n  syntheticEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(asyncEvents);\n  handlerState = HandlerState.FINALIZED;\n}\n\nexport function data(): UserTimingsData {\n  if (handlerState !== HandlerState.FINALIZED) {\n    throw new Error('UserTimings handler is not finalized');\n  }\n\n  return {\n    performanceMeasures: syntheticEvents.filter(e => e.cat === 'blink.user_timing') as\n        Types.TraceEvents.SyntheticUserTimingPair[],\n    consoleTimings: syntheticEvents.filter(e => e.cat === 'blink.console') as\n        Types.TraceEvents.SyntheticConsoleTimingPair[],\n    performanceMarks: [...performanceMarkEvents],\n    timestampEvents: [...timestampEvents],\n  };\n}\n"],
+  "mappings": "AAIA;AACA;AAEA;AAOA,IAAI,kBAAqG;AACzG,MAAM,2BAA6E;AACnF,MAAM,wBAAuE;AAE7E,MAAM,iBAA8G;AAEpH,MAAM,kBAA2D;AAyBjE,IAAI,eAAe,aAAa;AAEzB,wBAAuB;AAC5B,kBAAgB,SAAS;AACzB,2BAAyB,SAAS;AAClC,wBAAsB,SAAS;AAC/B,iBAAe,SAAS;AACxB,kBAAgB,SAAS;AACzB,iBAAe,aAAa;AAAA;AAG9B,MAAM,sBAAsB;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAEF,MAAM,iBAAiB;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAGK,4BAAqB,OAA+C;AACzE,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAOlB,QAAM,eAAe,CAAC,GAAG,qBAAqB,GAAG;AACjD,MAAI,aAAa,SAAS,MAAM,OAAO;AACrC;AAAA;AAGF,MAAI,MAAM,YAAY,+BAA+B,QAAQ;AAC3D,6BAAyB,KAAK;AAC9B;AAAA;AAEF,MAAI,MAAM,YAAY,4BAA4B,QAAQ;AACxD,0BAAsB,KAAK;AAAA;AAE7B,MAAI,MAAM,YAAY,wBAAwB,QAAQ;AACpD,mBAAe,KAAK;AAAA;AAEtB,MAAI,MAAM,YAAY,sBAAsB,QAAQ;AAClD,oBAAgB,KAAK;AAAA;AAAA;AAIzB,iCAAgD;AAC9C,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAGlB,QAAM,cAAc,CAAC,GAAG,0BAA0B,GAAG;AACrD,oBAAkB,QAAQ,MAAM,mCAAmC;AACnE,iBAAe,aAAa;AAAA;AAGvB,uBAAiC;AACtC,MAAI,iBAAiB,aAAa,WAAW;AAC3C,UAAM,IAAI,MAAM;AAAA;AAGlB,SAAO;AAAA,IACL,qBAAqB,gBAAgB,OAAO,OAAK,EAAE,QAAQ;AAAA,IAE3D,gBAAgB,gBAAgB,OAAO,OAAK,EAAE,QAAQ;AAAA,IAEtD,kBAAkB,CAAC,GAAG;AAAA,IACtB,iBAAiB,CAAC,GAAG;AAAA;AAAA;",
+  "names": []
+}

package/models/trace/handlers/WarningsHandler.js

@@ -0,0 +1,87 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+import { data as userInteractionsHandlerData } from "./UserInteractionsHandler.js";
+const warningsPerEvent = /* @__PURE__ */ new Map();
+const eventsPerWarning = /* @__PURE__ */ new Map();
+const allEventsStack = [];
+const jsInvokeStack = [];
+const taskReflowEvents = [];
+export const FORCED_REFLOW_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(30));
+export const LONG_MAIN_THREAD_TASK_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(50));
+export function reset() {
+  warningsPerEvent.clear();
+  eventsPerWarning.clear();
+  allEventsStack.length = 0;
+  jsInvokeStack.length = 0;
+  taskReflowEvents.length = 0;
+}
+function storeWarning(event, warning) {
+  const existingWarnings = Platform.MapUtilities.getWithDefault(warningsPerEvent, event, () => []);
+  existingWarnings.push(warning);
+  warningsPerEvent.set(event, existingWarnings);
+  const existingEvents = Platform.MapUtilities.getWithDefault(eventsPerWarning, warning, () => []);
+  existingEvents.push(event);
+  eventsPerWarning.set(warning, existingEvents);
+}
+export function handleEvent(event) {
+  processForcedReflowWarning(event);
+  if (event.name === Types.TraceEvents.KnownEventName.RunTask) {
+    const { duration } = Helpers.Timing.eventTimingsMicroSeconds(event);
+    if (duration > LONG_MAIN_THREAD_TASK_THRESHOLD) {
+      storeWarning(event, "LONG_TASK");
+    }
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventFireIdleCallback(event)) {
+    const { duration } = Helpers.Timing.eventTimingsMilliSeconds(event);
+    if (duration > event.args.data.allottedMilliseconds) {
+      storeWarning(event, "IDLE_CALLBACK_OVER_TIME");
+    }
+    return;
+  }
+}
+function processForcedReflowWarning(event) {
+  accomodateEventInStack(event, allEventsStack);
+  accomodateEventInStack(event, jsInvokeStack, Types.TraceEvents.isJSInvocationEvent(event));
+  if (jsInvokeStack.length) {
+    if (event.name === Types.TraceEvents.KnownEventName.Layout || event.name === Types.TraceEvents.KnownEventName.RecalculateStyles || event.name === Types.TraceEvents.KnownEventName.UpdateLayoutTree) {
+      taskReflowEvents.push(event);
+      return;
+    }
+  }
+  if (allEventsStack.length === 1) {
+    const totalTime = taskReflowEvents.reduce((time, event2) => time + (event2.dur || 0), 0);
+    if (totalTime >= FORCED_REFLOW_THRESHOLD) {
+      taskReflowEvents.forEach((reflowEvent) => storeWarning(reflowEvent, "FORCED_REFLOW"));
+    }
+    taskReflowEvents.length = 0;
+  }
+}
+function accomodateEventInStack(event, stack, pushEventToStack = true) {
+  let nextItem = stack.at(-1);
+  while (nextItem && event.ts > nextItem.ts + (nextItem.dur || 0)) {
+    stack.pop();
+    nextItem = stack.at(-1);
+  }
+  if (!pushEventToStack) {
+    return;
+  }
+  stack.push(event);
+}
+export function deps() {
+  return ["UserInteractions"];
+}
+export async function finalize() {
+  const longInteractions = userInteractionsHandlerData().interactionsOverThreshold;
+  for (const interaction of longInteractions) {
+    storeWarning(interaction, "LONG_INTERACTION");
+  }
+}
+export function data() {
+  return {
+    perEvent: new Map(warningsPerEvent),
+    perWarning: new Map(eventsPerWarning)
+  };
+}
+//# sourceMappingURL=WarningsHandler.js.map

package/models/trace/handlers/WarningsHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/WarningsHandler.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {type TraceEventHandlerName} from './types.js';\nimport {data as userInteractionsHandlerData} from './UserInteractionsHandler.js';\n\nexport interface WarningsData {\n  // Tracks warnings keyed by the event.\n  perEvent: Map<Types.TraceEvents.TraceEventData, Warning[]>;\n  // The same data in reverse: for each type of warning, track the events.\n  // Useful if we need to enumerate events by type of issue\n  perWarning: Map<Warning, Types.TraceEvents.TraceEventData[]>;\n}\n\nexport type Warning = 'LONG_TASK'|'IDLE_CALLBACK_OVER_TIME'|'FORCED_REFLOW'|'LONG_INTERACTION';\n\nconst warningsPerEvent: WarningsData['perEvent'] = new Map();\nconst eventsPerWarning: WarningsData['perWarning'] = new Map();\n\n/**\n * Tracks the stack formed by nested trace events up to a given point\n */\nconst allEventsStack: Types.TraceEvents.TraceEventData[] = [];\n/**\n * Tracks the stack formed by JS invocation trace events up to a given point.\n * F.e. FunctionCall, EvaluateScript, V8Execute.\n * Not to be confused with ProfileCalls.\n */\nconst jsInvokeStack: Types.TraceEvents.TraceEventData[] = [];\n/**\n * Tracks reflow events in a task.\n */\nconst taskReflowEvents: Types.TraceEvents.TraceEventData[] = [];\n\nexport const FORCED_REFLOW_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(30));\n\nexport const LONG_MAIN_THREAD_TASK_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(50));\n\nexport function reset(): void {\n  warningsPerEvent.clear();\n  eventsPerWarning.clear();\n  allEventsStack.length = 0;\n  jsInvokeStack.length = 0;\n  taskReflowEvents.length = 0;\n}\n\nfunction storeWarning(event: Types.TraceEvents.TraceEventData, warning: Warning): void {\n  const existingWarnings = Platform.MapUtilities.getWithDefault(warningsPerEvent, event, () => []);\n  existingWarnings.push(warning);\n  warningsPerEvent.set(event, existingWarnings);\n\n  const existingEvents = Platform.MapUtilities.getWithDefault(eventsPerWarning, warning, () => []);\n  existingEvents.push(event);\n  eventsPerWarning.set(warning, existingEvents);\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  processForcedReflowWarning(event);\n  if (event.name === Types.TraceEvents.KnownEventName.RunTask) {\n    const {duration} = Helpers.Timing.eventTimingsMicroSeconds(event);\n    if (duration > LONG_MAIN_THREAD_TASK_THRESHOLD) {\n      storeWarning(event, 'LONG_TASK');\n    }\n    return;\n  }\n\n  if (Types.TraceEvents.isTraceEventFireIdleCallback(event)) {\n    const {duration} = Helpers.Timing.eventTimingsMilliSeconds(event);\n    if (duration > event.args.data.allottedMilliseconds) {\n      storeWarning(event, 'IDLE_CALLBACK_OVER_TIME');\n    }\n    return;\n  }\n}\n\n/**\n * Reflows* are added a warning to if:\n * 1. They are forced/sync, meaning they are invoked by JS and finish\n *    during the Script execution.\n * 2. Their duration exceeds a threshold.\n * - *Reflow: The style recalculation and layout steps in a render task.\n */\nfunction processForcedReflowWarning(event: Types.TraceEvents.TraceEventData): void {\n  // Update the event and the JS invocation stacks.\n  accomodateEventInStack(event, allEventsStack);\n  accomodateEventInStack(event, jsInvokeStack, /* pushEventToStack */ Types.TraceEvents.isJSInvocationEvent(event));\n  if (jsInvokeStack.length) {\n    // Current event falls inside a JS call.\n    if (event.name === Types.TraceEvents.KnownEventName.Layout ||\n        event.name === Types.TraceEvents.KnownEventName.RecalculateStyles ||\n        event.name === Types.TraceEvents.KnownEventName.UpdateLayoutTree) {\n      // A forced reflow happened. However we need to check if\n      // the threshold is surpassed to add a warning. Accumulate the\n      // event to check for this after the current Task is over.\n      taskReflowEvents.push(event);\n      return;\n    }\n  }\n  if (allEventsStack.length === 1) {\n    // We hit a new task. Check if the forced reflows in the previous\n    // task exceeded the threshold and add a warning if so.\n    const totalTime = taskReflowEvents.reduce((time, event) => time + (event.dur || 0), 0);\n    if (totalTime >= FORCED_REFLOW_THRESHOLD) {\n      taskReflowEvents.forEach(reflowEvent => storeWarning(reflowEvent, 'FORCED_REFLOW'));\n    }\n    taskReflowEvents.length = 0;\n  }\n}\n\n/**\n * Updates a given trace event stack given a new event.\n */\nfunction accomodateEventInStack(\n    event: Types.TraceEvents.TraceEventData, stack: Types.TraceEvents.TraceEventData[], pushEventToStack = true): void {\n  let nextItem = stack.at(-1);\n  while (nextItem && event.ts > nextItem.ts + (nextItem.dur || 0)) {\n    stack.pop();\n    nextItem = stack.at(-1);\n  }\n  if (!pushEventToStack) {\n    return;\n  }\n  stack.push(event);\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['UserInteractions'];\n}\n\nexport async function finalize(): Promise<void> {\n  // These events do exist on the UserInteractionsHandler, but we also put\n  // them into the WarningsHandler so that the warnings handler can be the\n  // source of truth and the way to look up all warnings for a given event.\n  // Otherwise, we would have to look up warnings across multiple handlers for\n  // a given event, which will start to get messy very quickly.\n  const longInteractions = userInteractionsHandlerData().interactionsOverThreshold;\n  for (const interaction of longInteractions) {\n    storeWarning(interaction, 'LONG_INTERACTION');\n  }\n}\n\nexport function data(): WarningsData {\n  return {\n    perEvent: new Map(warningsPerEvent),\n    perWarning: new Map(eventsPerWarning),\n  };\n}\n"],
+  "mappings": "AAIA;AACA;AACA;AAGA;AAYA,MAAM,mBAA6C,oBAAI;AACvD,MAAM,mBAA+C,oBAAI;AAKzD,MAAM,iBAAqD;AAM3D,MAAM,gBAAoD;AAI1D,MAAM,mBAAuD;AAEtD,aAAM,0BAA0B,QAAQ,OAAO,2BAA2B,MAAM,OAAO,aAAa;AAEpG,aAAM,kCAAkC,QAAQ,OAAO,2BAA2B,MAAM,OAAO,aAAa;AAE5G,wBAAuB;AAC5B,mBAAiB;AACjB,mBAAiB;AACjB,iBAAe,SAAS;AACxB,gBAAc,SAAS;AACvB,mBAAiB,SAAS;AAAA;AAG5B,sBAAsB,OAAyC,SAAwB;AACrF,QAAM,mBAAmB,SAAS,aAAa,eAAe,kBAAkB,OAAO,MAAM;AAC7F,mBAAiB,KAAK;AACtB,mBAAiB,IAAI,OAAO;AAE5B,QAAM,iBAAiB,SAAS,aAAa,eAAe,kBAAkB,SAAS,MAAM;AAC7F,iBAAe,KAAK;AACpB,mBAAiB,IAAI,SAAS;AAAA;AAGzB,4BAAqB,OAA+C;AACzE,6BAA2B;AAC3B,MAAI,MAAM,SAAS,MAAM,YAAY,eAAe,SAAS;AAC3D,UAAM,EAAC,aAAY,QAAQ,OAAO,yBAAyB;AAC3D,QAAI,WAAW,iCAAiC;AAC9C,mBAAa,OAAO;AAAA;AAEtB;AAAA;AAGF,MAAI,MAAM,YAAY,6BAA6B,QAAQ;AACzD,UAAM,EAAC,aAAY,QAAQ,OAAO,yBAAyB;AAC3D,QAAI,WAAW,MAAM,KAAK,KAAK,sBAAsB;AACnD,mBAAa,OAAO;AAAA;AAEtB;AAAA;AAAA;AAWJ,oCAAoC,OAA+C;AAEjF,yBAAuB,OAAO;AAC9B,yBAAuB,OAAO,eAAsC,MAAM,YAAY,oBAAoB;AAC1G,MAAI,cAAc,QAAQ;AAExB,QAAI,MAAM,SAAS,MAAM,YAAY,eAAe,UAChD,MAAM,SAAS,MAAM,YAAY,eAAe,qBAChD,MAAM,SAAS,MAAM,YAAY,eAAe,kBAAkB;AAIpE,uBAAiB,KAAK;AACtB;AAAA;AAAA;AAGJ,MAAI,eAAe,WAAW,GAAG;AAG/B,UAAM,YAAY,iBAAiB,OAAO,CAAC,MAAM,WAAU,OAAQ,QAAM,OAAO,IAAI;AACpF,QAAI,aAAa,yBAAyB;AACxC,uBAAiB,QAAQ,iBAAe,aAAa,aAAa;AAAA;AAEpE,qBAAiB,SAAS;AAAA;AAAA;AAO9B,gCACI,OAAyC,OAA2C,mBAAmB,MAAY;AACrH,MAAI,WAAW,MAAM,GAAG;AACxB,SAAO,YAAY,MAAM,KAAK,SAAS,KAAM,UAAS,OAAO,IAAI;AAC/D,UAAM;AACN,eAAW,MAAM,GAAG;AAAA;AAEtB,MAAI,CAAC,kBAAkB;AACrB;AAAA;AAEF,QAAM,KAAK;AAAA;AAGN,uBAAyC;AAC9C,SAAO,CAAC;AAAA;AAGV,iCAAgD;AAM9C,QAAM,mBAAmB,8BAA8B;AACvD,aAAW,eAAe,kBAAkB;AAC1C,iBAAa,aAAa;AAAA;AAAA;AAIvB,uBAA8B;AACnC,SAAO;AAAA,IACL,UAAU,IAAI,IAAI;AAAA,IAClB,YAAY,IAAI,IAAI;AAAA;AAAA;",
+  "names": []
+}

package/models/trace/handlers/WorkersHandler.js

@@ -0,0 +1,50 @@
+import * as Types from "../types/types.js";
+import { HandlerState } from "./types.js";
+let handlerState = HandlerState.UNINITIALIZED;
+const sessionIdEvents = [];
+const workerIdByThread = /* @__PURE__ */ new Map();
+const workerURLById = /* @__PURE__ */ new Map();
+export function initialize() {
+  if (handlerState !== HandlerState.UNINITIALIZED) {
+    throw new Error("Workers Handler was not reset");
+  }
+  handlerState = HandlerState.INITIALIZED;
+}
+export function reset() {
+  sessionIdEvents.length = 0;
+  workerIdByThread.clear();
+  workerURLById.clear();
+  handlerState = HandlerState.UNINITIALIZED;
+}
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Workers Handler is not initialized");
+  }
+  if (Types.TraceEvents.isTraceEventTracingSessionIdForWorker(event)) {
+    sessionIdEvents.push(event);
+  }
+}
+export async function finalize() {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Handler is not initialized");
+  }
+  for (const sessionIdEvent of sessionIdEvents) {
+    if (!sessionIdEvent.args.data) {
+      continue;
+    }
+    workerIdByThread.set(sessionIdEvent.args.data.workerThreadId, sessionIdEvent.args.data.workerId);
+    workerURLById.set(sessionIdEvent.args.data.workerId, sessionIdEvent.args.data.url);
+  }
+  handlerState = HandlerState.FINALIZED;
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("Workers Handler is not finalized");
+  }
+  return {
+    workerSessionIdEvents: [...sessionIdEvents],
+    workerIdByThread: new Map(workerIdByThread),
+    workerURLById: new Map(workerURLById)
+  };
+}
+//# sourceMappingURL=WorkersHandler.js.map

package/models/trace/handlers/WorkersHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/WorkersHandler.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Types from '../types/types.js';\n\nimport {HandlerState} from './types.js';\n\nexport interface WorkersData {\n  workerSessionIdEvents: readonly Types.TraceEvents.TraceEventTracingSessionIdForWorker[];\n  workerIdByThread: Map<Types.TraceEvents.ThreadID, Types.TraceEvents.WorkerId>;\n  workerURLById: Map<Types.TraceEvents.WorkerId, string>;\n}\nlet handlerState = HandlerState.UNINITIALIZED;\n\nconst sessionIdEvents: Types.TraceEvents.TraceEventTracingSessionIdForWorker[] = [];\nconst workerIdByThread: Map<Types.TraceEvents.ThreadID, Types.TraceEvents.WorkerId> = new Map();\nconst workerURLById: Map<Types.TraceEvents.WorkerId, string> = new Map();\n\nexport function initialize(): void {\n  if (handlerState !== HandlerState.UNINITIALIZED) {\n    throw new Error('Workers Handler was not reset');\n  }\n\n  handlerState = HandlerState.INITIALIZED;\n}\n\nexport function reset(): void {\n  sessionIdEvents.length = 0;\n  workerIdByThread.clear();\n  workerURLById.clear();\n  handlerState = HandlerState.UNINITIALIZED;\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('Workers Handler is not initialized');\n  }\n  if (Types.TraceEvents.isTraceEventTracingSessionIdForWorker(event)) {\n    sessionIdEvents.push(event);\n  }\n}\n\nexport async function finalize(): Promise<void> {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('Handler is not initialized');\n  }\n  for (const sessionIdEvent of sessionIdEvents) {\n    if (!sessionIdEvent.args.data) {\n      continue;\n    }\n    workerIdByThread.set(sessionIdEvent.args.data.workerThreadId, sessionIdEvent.args.data.workerId);\n    workerURLById.set(sessionIdEvent.args.data.workerId, sessionIdEvent.args.data.url);\n  }\n  handlerState = HandlerState.FINALIZED;\n}\n\nexport function data(): WorkersData {\n  if (handlerState !== HandlerState.FINALIZED) {\n    throw new Error('Workers Handler is not finalized');\n  }\n\n  return {\n    workerSessionIdEvents: [...sessionIdEvents],\n    workerIdByThread: new Map(workerIdByThread),\n    workerURLById: new Map(workerURLById),\n  };\n}\n"],
+  "mappings": "AAIA;AAEA;AAOA,IAAI,eAAe,aAAa;AAEhC,MAAM,kBAA2E;AACjF,MAAM,mBAAgF,oBAAI;AAC1F,MAAM,gBAAyD,oBAAI;AAE5D,6BAA4B;AACjC,MAAI,iBAAiB,aAAa,eAAe;AAC/C,UAAM,IAAI,MAAM;AAAA;AAGlB,iBAAe,aAAa;AAAA;AAGvB,wBAAuB;AAC5B,kBAAgB,SAAS;AACzB,mBAAiB;AACjB,gBAAc;AACd,iBAAe,aAAa;AAAA;AAGvB,4BAAqB,OAA+C;AACzE,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAElB,MAAI,MAAM,YAAY,sCAAsC,QAAQ;AAClE,oBAAgB,KAAK;AAAA;AAAA;AAIzB,iCAAgD;AAC9C,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAElB,aAAW,kBAAkB,iBAAiB;AAC5C,QAAI,CAAC,eAAe,KAAK,MAAM;AAC7B;AAAA;AAEF,qBAAiB,IAAI,eAAe,KAAK,KAAK,gBAAgB,eAAe,KAAK,KAAK;AACvF,kBAAc,IAAI,eAAe,KAAK,KAAK,UAAU,eAAe,KAAK,KAAK;AAAA;AAEhF,iBAAe,aAAa;AAAA;AAGvB,uBAA6B;AAClC,MAAI,iBAAiB,aAAa,WAAW;AAC3C,UAAM,IAAI,MAAM;AAAA;AAGlB,SAAO;AAAA,IACL,uBAAuB,CAAC,GAAG;AAAA,IAC3B,kBAAkB,IAAI,IAAI;AAAA,IAC1B,eAAe,IAAI,IAAI;AAAA;AAAA;",
+  "names": []
+}

package/models/trace/handlers/bundle-tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"composite":true,"outDir":".","baseUrl":".","rootDir":"../../../../../../../front_end/models/trace/handlers"},"files":["../../../../../../../front_end/models/trace/handlers/handlers.ts"],"references":[{"path":"./handlers-tsconfig.json"}]}

package/models/trace/handlers/devtools_entrypoint-bundle-typescript-tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "composite": true,
+    "declaration": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "inlineSources": true,
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable"
+    ],
+    "module": "esnext",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": ".",
+    "rootDir": "../../../../../../../front_end/models/trace/handlers",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "devtools_entrypoint-bundle-typescript-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../../front_end/models/trace/handlers/handlers.ts",
+    "../../../../../../../front_end/legacy/legacy-defs.d.ts",
+    "../../../../../../../front_end/global_typings/global_defs.d.ts",
+    "../../../../../../../front_end/global_typings/request_idle_callback.d.ts",
+    "../../../../../../../node_modules/@types/filesystem/index.d.ts",
+    "../../../../../../../node_modules/@webgpu/types/dist/index.d.ts"
+  ],
+  "references": [
+    {
+      "path": "./handlers-tsconfig.json"
+    }
+  ]
+}

package/models/trace/handlers/handlers-tsconfig.json

@@ -0,0 +1,79 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "composite": true,
+    "declaration": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "inlineSources": true,
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable"
+    ],
+    "module": "esnext",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": ".",
+    "rootDir": "../../../../../../../front_end/models/trace/handlers",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "handlers-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../../front_end/models/trace/handlers/AnimationHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/AuctionWorkletsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/FramesHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/GPUHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/InitiatorsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/InvalidationsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/LargestImagePaintHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/LargestTextPaintHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/LayerTreeHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/LayoutShiftsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/MemoryHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/MetaHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/ModelHandlers.ts",
+    "../../../../../../../front_end/models/trace/handlers/NetworkRequestsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/PageLoadMetricsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/RendererHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/SamplesHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/ScreenshotsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/Threads.ts",
+    "../../../../../../../front_end/models/trace/handlers/UserInteractionsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/UserTimingsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/WarningsHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/WorkersHandler.ts",
+    "../../../../../../../front_end/models/trace/handlers/types.ts",
+    "../../../../../../../front_end/legacy/legacy-defs.d.ts",
+    "../../../../../../../front_end/global_typings/global_defs.d.ts",
+    "../../../../../../../front_end/global_typings/request_idle_callback.d.ts",
+    "../../../../../../../node_modules/@types/filesystem/index.d.ts",
+    "../../../../../../../node_modules/@webgpu/types/dist/index.d.ts"
+  ],
+  "references": [
+    {
+      "path": "../../../core/platform/bundle-tsconfig.json"
+    },
+    {
+      "path": "../../../generated/generated-tsconfig.json"
+    },
+    {
+      "path": "../../cpu_profile/bundle-tsconfig.json"
+    },
+    {
+      "path": "../helpers/bundle-tsconfig.json"
+    },
+    {
+      "path": "../types/bundle-tsconfig.json"
+    }
+  ]
+}

package/models/trace/handlers/handlers.js

@@ -0,0 +1,4 @@
+export * as ModelHandlers from "./ModelHandlers.js";
+export * as Threads from "./Threads.js";
+export * as Types from "./types.js";
+//# sourceMappingURL=handlers.js.map

package/models/trace/handlers/handlers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/handlers.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nexport * as ModelHandlers from './ModelHandlers.js';\nexport * as Threads from './Threads.js';\nexport * as Types from './types.js';\n"],
+  "mappings": "AAIA;AACA;AACA;",
+  "names": []
+}

package/models/trace/handlers/types.js

@@ -0,0 +1,18 @@
+import * as ModelHandlers from "./ModelHandlers.js";
+export function handlerDataHasAllHandlers(data) {
+  let isMissingHandler = false;
+  for (const handlerName of Object.keys(ModelHandlers)) {
+    if (handlerName in data === false) {
+      isMissingHandler = true;
+      break;
+    }
+  }
+  return !isMissingHandler;
+}
+export var HandlerState = /* @__PURE__ */ ((HandlerState2) => {
+  HandlerState2[HandlerState2["UNINITIALIZED"] = 1] = "UNINITIALIZED";
+  HandlerState2[HandlerState2["INITIALIZED"] = 2] = "INITIALIZED";
+  HandlerState2[HandlerState2["FINALIZED"] = 3] = "FINALIZED";
+  return HandlerState2;
+})(HandlerState || {});
+//# sourceMappingURL=types.js.map

package/models/trace/handlers/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/types.ts"],
+  "sourcesContent": ["\n// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\nimport type * as Types from './../types/types.js';\nimport * as ModelHandlers from './ModelHandlers.js';\n\nexport interface TraceEventHandler {\n  reset(): void;\n  initialize?(freshRecording?: boolean): void;\n  handleEvent(data: {}): void;\n  finalize?(): Promise<void>;\n  data(): unknown;\n  deps?(): TraceEventHandlerName[];\n  handleUserConfig?(config: Types.Configuration.Configuration): void;\n}\nexport type TraceEventHandlerName = keyof typeof ModelHandlers;\n\n// This type maps TraceEventHandler names to the return type of their data\n// function. So, for example, if we are given an object with a key of 'foo'\n// and a value which is a TraceHandler containing a data() function that\n// returns a string, this type will be { foo: string }.\n//\n// This allows us to model the behavior of the TraceProcessor in the model,\n// which takes an object with TraceEventHandlers as part of its config, and\n// which ultimately returns an object keyed off the names of the\n// TraceEventHandlers, and with values that are derived from each\n// TraceEventHandler's data function.\n//\n// So, concretely, we provide a TraceEventHandler for calculating the #time\n// bounds of a trace called TraceBounds, whose data() function returns a\n// TraceWindow. The HandlerData, therefore, would determine that the\n// TraceProcessor would contain a key called 'TraceBounds' whose value is\n// a TraceWindow.\nexport type EnabledHandlerDataWithMeta<T extends {[key: string]: TraceEventHandler}> = {\n  // We allow the user to configure which handlers are created by passing them\n  // in when constructing a model instance. However, we then ensure that the\n  // Meta handler is added to that, as the Model relies on some of the data\n  // from the Meta handler when creating the file. Therefore, this type\n  // explicitly defines that the Meta data is present, before then extending it\n  // with the index type to represent all the other handlers.\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Meta: Readonly<ReturnType<typeof ModelHandlers['Meta']['data']>>,\n}&{\n  // For every key in the object, look up the TraceEventHandler's data function\n  // and use its return type as the value for the object.\n  [K in keyof T]: Readonly<ReturnType<T[K]['data']>>;\n};\n\nexport type HandlersWithMeta<T extends {[key: string]: TraceEventHandler}> = {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Meta: typeof ModelHandlers.Meta,\n}&{\n  [K in keyof T]: T[K];\n};\n\n// Represents the final parsed data from all of the handlers. Note that because\n// we are currently in the middle of the migration of data engines, not all the\n// handlers are enabled. Therefore for now you should use the type defined in\n// models/trace/handlers/Migration.ts, `PartialTraceData`, which\n// represents the final parsed data for only the enabled handlers.\nexport type TraceParseData = Readonly<EnabledHandlerDataWithMeta<typeof ModelHandlers>>;\n\n/**\n * Because you can run the trace engine with a subset of handlers enabled,\n * there can be times when you need to confirm if the trace contains all\n * handlers or not, because some parts of the engine expect to be given all\n * the handlers.\n */\nexport function handlerDataHasAllHandlers(data: Readonly<EnabledHandlerDataWithMeta<{}>>): data is TraceParseData {\n  let isMissingHandler = false;\n  for (const handlerName of Object.keys(ModelHandlers)) {\n    if (handlerName in data === false) {\n      isMissingHandler = true;\n      break;\n    }\n  }\n  return !isMissingHandler;\n}\n\ntype DeepWriteable<T> = {\n  -readonly[P in keyof T]: DeepWriteable<T[P]>\n};\nexport type TraceParseDataMutable = DeepWriteable<TraceParseData>;\n\nexport type Handlers = typeof ModelHandlers;\n\nexport const enum HandlerState {\n  UNINITIALIZED = 1,\n  INITIALIZED = 2,\n  FINALIZED = 3,\n}\n"],
+  "mappings": "AAKA;AAgEO,0CAAmC,MAAwE;AAChH,MAAI,mBAAmB;AACvB,aAAW,eAAe,OAAO,KAAK,gBAAgB;AACpD,QAAI,eAAe,SAAS,OAAO;AACjC,yBAAmB;AACnB;AAAA;AAAA;AAGJ,SAAO,CAAC;AAAA;AAUH,WAAW,eAAX,kBAAW,kBAAX;AACL,iDAAgB,KAAhB;AACA,+CAAc,KAAd;AACA,6CAAY,KAAZ;AAHgB;AAAA;",
+  "names": []
+}

package/models/trace/helpers/SamplesIntegrator.js

@@ -0,0 +1,220 @@
+import * as Types from "../types/types.js";
+import { millisecondsToMicroseconds } from "./Timing.js";
+import { makeProfileCall, mergeEventsInOrder } from "./Trace.js";
+export class SamplesIntegrator {
+  #constructedProfileCalls = [];
+  #currentJSStack = [];
+  #processId;
+  #threadId;
+  #lockedJsStackDepth = [];
+  #fakeJSInvocation = false;
+  #profileModel;
+  #nodeForGC = /* @__PURE__ */ new Map();
+  #engineConfig;
+  constructor(profileModel, pid, tid, configuration) {
+    this.#profileModel = profileModel;
+    this.#threadId = tid;
+    this.#processId = pid;
+    this.#engineConfig = configuration || Types.Configuration.DEFAULT;
+  }
+  buildProfileCalls(traceEvents) {
+    const mergedEvents = mergeEventsInOrder(traceEvents, this.callsFromProfileSamples());
+    const stack = [];
+    for (let i = 0; i < mergedEvents.length; i++) {
+      const event = mergedEvents[i];
+      if (event.ph === Types.TraceEvents.Phase.INSTANT) {
+        continue;
+      }
+      if (stack.length === 0) {
+        if (Types.TraceEvents.isProfileCall(event)) {
+          this.#onProfileCall(event);
+          continue;
+        }
+        stack.push(event);
+        this.#onTraceEventStart(event);
+        continue;
+      }
+      const parentEvent = stack.at(-1);
+      if (parentEvent === void 0) {
+        continue;
+      }
+      const begin = event.ts;
+      const parentBegin = parentEvent.ts;
+      const parentDuration = parentEvent.dur || 0;
+      const parentEnd = parentBegin + parentDuration;
+      const startsAfterParent = begin >= parentEnd;
+      if (startsAfterParent) {
+        this.#onTraceEventEnd(parentEvent);
+        stack.pop();
+        i--;
+        continue;
+      }
+      if (Types.TraceEvents.isProfileCall(event)) {
+        this.#onProfileCall(event, parentEvent);
+        continue;
+      }
+      this.#onTraceEventStart(event);
+      stack.push(event);
+    }
+    while (stack.length) {
+      const last = stack.pop();
+      if (last) {
+        this.#onTraceEventEnd(last);
+      }
+    }
+    return this.#constructedProfileCalls;
+  }
+  #onTraceEventStart(event) {
+    if (event.name === Types.TraceEvents.KnownEventName.RunMicrotasks || event.name === Types.TraceEvents.KnownEventName.RunTask) {
+      this.#lockedJsStackDepth = [];
+      this.#truncateJSStack(0, event.ts);
+      this.#fakeJSInvocation = false;
+    }
+    if (this.#fakeJSInvocation) {
+      this.#truncateJSStack(this.#lockedJsStackDepth.pop() || 0, event.ts);
+      this.#fakeJSInvocation = false;
+    }
+    this.#extractStackTrace(event);
+    this.#lockedJsStackDepth.push(this.#currentJSStack.length);
+  }
+  #onProfileCall(event, parent) {
+    if (parent && Types.TraceEvents.isJSInvocationEvent(parent) || this.#fakeJSInvocation) {
+      this.#extractStackTrace(event);
+    } else if (Types.TraceEvents.isProfileCall(event) && this.#currentJSStack.length === 0) {
+      this.#fakeJSInvocation = true;
+      const stackDepthBefore = this.#currentJSStack.length;
+      this.#extractStackTrace(event);
+      this.#lockedJsStackDepth.push(stackDepthBefore);
+    }
+  }
+  #onTraceEventEnd(event) {
+    const endTime = Types.Timing.MicroSeconds(event.ts + (event.dur || 0));
+    this.#truncateJSStack(this.#lockedJsStackDepth.pop() || 0, endTime);
+  }
+  callsFromProfileSamples() {
+    const samples = this.#profileModel.samples;
+    const timestamps = this.#profileModel.timestamps;
+    if (!samples) {
+      return [];
+    }
+    const calls = [];
+    let prevNode;
+    for (let i = 0; i < samples.length; i++) {
+      const node = this.#profileModel.nodeByIndex(i);
+      const timestamp = millisecondsToMicroseconds(Types.Timing.MilliSeconds(timestamps[i]));
+      if (!node) {
+        continue;
+      }
+      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 = node?.id === this.#profileModel.gcNode?.id;
+    if (isGarbageCollection) {
+      node = this.#nodeForGC.get(profileCall) || null;
+    }
+    if (!node) {
+      return [];
+    }
+    const callFrames = new Array(node.depth + 1 + Number(isGarbageCollection));
+    let i = callFrames.length - 1;
+    if (isGarbageCollection) {
+      callFrames[i--] = profileCall;
+    }
+    while (node) {
+      callFrames[i--] = makeProfileCall(node, profileCall.ts, this.#processId, this.#threadId);
+      node = node.parent;
+    }
+    return callFrames;
+  }
+  #extractStackTrace(event) {
+    const stackTrace = Types.TraceEvents.isProfileCall(event) ? this.#getStackTraceFromProfileCall(event) : this.#currentJSStack;
+    SamplesIntegrator.filterStackFrames(stackTrace, this.#engineConfig);
+    const endTime = event.ts + (event.dur || 0);
+    const minFrames = Math.min(stackTrace.length, this.#currentJSStack.length);
+    let i;
+    for (i = this.#lockedJsStackDepth.at(-1) || 0; i < minFrames; ++i) {
+      const newFrame = stackTrace[i].callFrame;
+      const oldFrame = this.#currentJSStack[i].callFrame;
+      if (!SamplesIntegrator.framesAreEqual(newFrame, oldFrame)) {
+        break;
+      }
+      this.#currentJSStack[i].dur = Types.Timing.MicroSeconds(Math.max(this.#currentJSStack[i].dur || 0, endTime - this.#currentJSStack[i].ts));
+    }
+    this.#truncateJSStack(i, event.ts);
+    for (; i < stackTrace.length; ++i) {
+      const call = stackTrace[i];
+      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);
+    }
+  }
+  #truncateJSStack(depth, time) {
+    if (this.#lockedJsStackDepth.length) {
+      const lockedDepth = this.#lockedJsStackDepth.at(-1);
+      if (lockedDepth && depth < lockedDepth) {
+        console.error(`Child stack is shallower (${depth}) than the parent stack (${lockedDepth}) at ${time}`);
+        depth = lockedDepth;
+      }
+    }
+    if (this.#currentJSStack.length < depth) {
+      console.error(`Trying to truncate higher than the current stack size at ${time}`);
+      depth = this.#currentJSStack.length;
+    }
+    for (let k = 0; k < this.#currentJSStack.length; ++k) {
+      this.#currentJSStack[k].dur = Types.Timing.MicroSeconds(Math.max(time - this.#currentJSStack[k].ts, 0));
+    }
+    this.#currentJSStack.length = depth;
+  }
+  static framesAreEqual(frame1, frame2) {
+    return frame1.scriptId === frame2.scriptId && frame1.functionName === frame2.functionName && frame1.lineNumber === frame2.lineNumber;
+  }
+  static showNativeName(name, runtimeCallStatsEnabled) {
+    return runtimeCallStatsEnabled && Boolean(SamplesIntegrator.nativeGroup(name));
+  }
+  static nativeGroup(nativeName) {
+    if (nativeName.startsWith("Parse")) {
+      return "Parse";
+    }
+    if (nativeName.startsWith("Compile") || nativeName.startsWith("Recompile")) {
+      return "Compile";
+    }
+    return null;
+  }
+  static isNativeRuntimeFrame(frame) {
+    return frame.url === "native V8Runtime";
+  }
+  static filterStackFrames(stack, engineConfig) {
+    const showAllEvents = engineConfig.experiments.timelineShowAllEvents;
+    if (showAllEvents) {
+      return;
+    }
+    let previousNativeFrameName = null;
+    let j = 0;
+    for (let i = 0; i < stack.length; ++i) {
+      const frame = stack[i].callFrame;
+      const nativeRuntimeFrame = SamplesIntegrator.isNativeRuntimeFrame(frame);
+      if (nativeRuntimeFrame && !SamplesIntegrator.showNativeName(frame.functionName, engineConfig.experiments.timelineV8RuntimeCallStats)) {
+        continue;
+      }
+      const nativeFrameName = nativeRuntimeFrame ? SamplesIntegrator.nativeGroup(frame.functionName) : null;
+      if (previousNativeFrameName && previousNativeFrameName === nativeFrameName) {
+        continue;
+      }
+      previousNativeFrameName = nativeFrameName;
+      stack[j++] = stack[i];
+    }
+    stack.length = j;
+  }
+}
+//# sourceMappingURL=SamplesIntegrator.js.map