@paulirish/trace_engine 0.0.8 → 0.0.10

package/models/trace/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",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "devtools_entrypoint-bundle-typescript-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../front_end/models/trace/trace.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": "./trace-tsconfig.json"
+    }
+  ]
+}

package/models/trace/devtools_entrypoint-legacy-typescript-tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "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",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "devtools_entrypoint-legacy-typescript-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../front_end/models/trace/trace-legacy.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"
+  ],
+  "references": [
+    {
+      "path": "./bundle-tsconfig.json"
+    }
+  ]
+}

package/models/trace/extras/FetchNodes.js

@@ -0,0 +1,104 @@
+import * as SDK from "../../../core/sdk/sdk.js";
+const domLookUpSingleNodeCache = /* @__PURE__ */ new Map();
+const domLookUpBatchNodesCache = /* @__PURE__ */ new Map();
+export function _TEST_clearCache() {
+  domLookUpSingleNodeCache.clear();
+  domLookUpBatchNodesCache.clear();
+  layoutShiftSourcesCache.clear();
+  normalizedLayoutShiftNodesCache.clear();
+}
+export async function domNodeForBackendNodeID(modelData, nodeId) {
+  const fromCache = domLookUpSingleNodeCache.get(modelData)?.get(nodeId);
+  if (fromCache !== void 0) {
+    return fromCache;
+  }
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const domModel = target?.model(SDK.DOMModel.DOMModel);
+  if (!domModel) {
+    return null;
+  }
+  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(/* @__PURE__ */ new Set([nodeId]));
+  const result = domNodesMap?.get(nodeId) || null;
+  const cacheForModel = domLookUpSingleNodeCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(nodeId, result);
+  domLookUpSingleNodeCache.set(modelData, cacheForModel);
+  return result;
+}
+export async function domNodesForMultipleBackendNodeIds(modelData, nodeIds) {
+  const fromCache = domLookUpBatchNodesCache.get(modelData)?.get(nodeIds);
+  if (fromCache) {
+    return fromCache;
+  }
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const domModel = target?.model(SDK.DOMModel.DOMModel);
+  if (!domModel) {
+    return /* @__PURE__ */ new Map();
+  }
+  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(nodeIds) || /* @__PURE__ */ new Map();
+  const cacheForModel = domLookUpBatchNodesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(nodeIds, domNodesMap);
+  domLookUpBatchNodesCache.set(modelData, cacheForModel);
+  return domNodesMap;
+}
+const layoutShiftSourcesCache = /* @__PURE__ */ new Map();
+const normalizedLayoutShiftNodesCache = /* @__PURE__ */ new Map();
+export async function sourcesForLayoutShift(modelData, event) {
+  const fromCache = layoutShiftSourcesCache.get(modelData)?.get(event);
+  if (fromCache) {
+    return fromCache;
+  }
+  const impactedNodes = event.args.data?.impacted_nodes;
+  if (!impactedNodes) {
+    return [];
+  }
+  const sources = [];
+  await Promise.all(impactedNodes.map(async (node) => {
+    const domNode = await domNodeForBackendNodeID(modelData, node.node_id);
+    if (domNode) {
+      sources.push({
+        previousRect: new DOMRect(node.old_rect[0], node.old_rect[1], node.old_rect[2], node.old_rect[3]),
+        currentRect: new DOMRect(node.new_rect[0], node.new_rect[1], node.new_rect[2], node.new_rect[3]),
+        node: domNode
+      });
+    }
+  }));
+  const cacheForModel = layoutShiftSourcesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(event, sources);
+  layoutShiftSourcesCache.set(modelData, cacheForModel);
+  return sources;
+}
+export async function normalizedImpactedNodesForLayoutShift(modelData, event) {
+  const fromCache = normalizedLayoutShiftNodesCache.get(modelData)?.get(event);
+  if (fromCache) {
+    return fromCache;
+  }
+  const impactedNodes = event.args?.data?.impacted_nodes;
+  if (!impactedNodes) {
+    return [];
+  }
+  let viewportScale = null;
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const evaluateResult = await target?.runtimeAgent().invoke_evaluate({ expression: "window.devicePixelRatio" });
+  if (evaluateResult?.result.type === "number") {
+    viewportScale = evaluateResult?.result.value ?? null;
+  }
+  if (!viewportScale) {
+    return impactedNodes;
+  }
+  const normalizedNodes = [];
+  for (const impactedNode of impactedNodes) {
+    const newNode = { ...impactedNode };
+    for (let i = 0; i < impactedNode.old_rect.length; i++) {
+      newNode.old_rect[i] /= viewportScale;
+    }
+    for (let i = 0; i < impactedNode.new_rect.length; i++) {
+      newNode.new_rect[i] /= viewportScale;
+    }
+    normalizedNodes.push(newNode);
+  }
+  const cacheForModel = normalizedLayoutShiftNodesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(event, normalizedNodes);
+  normalizedLayoutShiftNodesCache.set(modelData, cacheForModel);
+  return normalizedNodes;
+}
+//# sourceMappingURL=FetchNodes.js.map

package/models/trace/extras/FetchNodes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/extras/FetchNodes.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 type * as Protocol from '../../../generated/protocol.js';\nimport * as SDK from '../../../core/sdk/sdk.js';\nimport type * as Handlers from '../handlers/handlers.js';\nimport type * as Types from '../types/types.js';\n\nconst domLookUpSingleNodeCache =\n    new Map<Handlers.Types.TraceParseData, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>();\nconst domLookUpBatchNodesCache = new Map<\n    Handlers.Types.TraceParseData,\n    Map<Set<Protocol.DOM.BackendNodeId>, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>>();\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function _TEST_clearCache(): void {\n  domLookUpSingleNodeCache.clear();\n  domLookUpBatchNodesCache.clear();\n  layoutShiftSourcesCache.clear();\n  normalizedLayoutShiftNodesCache.clear();\n}\n\n/**\n * Looks up the DOM Node on the page for the given BackendNodeId. Uses the\n * provided TraceParseData as the cache and will cache the result after the\n * first lookup.\n */\nexport async function domNodeForBackendNodeID(\n    modelData: Handlers.Types.TraceParseData, nodeId: Protocol.DOM.BackendNodeId): Promise<SDK.DOMModel.DOMNode|null> {\n  const fromCache = domLookUpSingleNodeCache.get(modelData)?.get(nodeId);\n  if (fromCache !== undefined) {\n    return fromCache;\n  }\n\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  const domModel = target?.model(SDK.DOMModel.DOMModel);\n  if (!domModel) {\n    return null;\n  }\n\n  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(new Set([nodeId]));\n  const result = domNodesMap?.get(nodeId) || null;\n\n  const cacheForModel =\n      domLookUpSingleNodeCache.get(modelData) || new Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>();\n  cacheForModel.set(nodeId, result);\n  domLookUpSingleNodeCache.set(modelData, cacheForModel);\n\n  return result;\n}\n\n/**\n * Takes a set of Protocol.DOM.BackendNodeId ids and will return a map of NodeId=>DOMNode.\n * Results are cached based on 1) the provided TraceParseData and 2) the provided set of IDs.\n */\nexport async function domNodesForMultipleBackendNodeIds(\n    modelData: Handlers.Types.TraceParseData,\n    nodeIds: Set<Protocol.DOM.BackendNodeId>): Promise<Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>> {\n  const fromCache = domLookUpBatchNodesCache.get(modelData)?.get(nodeIds);\n  if (fromCache) {\n    return fromCache;\n  }\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  const domModel = target?.model(SDK.DOMModel.DOMModel);\n  if (!domModel) {\n    return new Map();\n  }\n\n  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(nodeIds) || new Map();\n\n  const cacheForModel = domLookUpBatchNodesCache.get(modelData) ||\n      new Map<Set<Protocol.DOM.BackendNodeId>, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>();\n  cacheForModel.set(nodeIds, domNodesMap);\n  domLookUpBatchNodesCache.set(modelData, cacheForModel);\n\n  return domNodesMap;\n}\n\nconst layoutShiftSourcesCache = new Map<\n    Handlers.Types.TraceParseData, Map<Types.TraceEvents.TraceEventLayoutShift, readonly LayoutShiftSource[]>>();\n\nconst normalizedLayoutShiftNodesCache = new Map<\n    Handlers.Types.TraceParseData,\n    Map<Types.TraceEvents.TraceEventLayoutShift, readonly Types.TraceEvents.TraceImpactedNode[]>>();\n\nexport interface LayoutShiftSource {\n  previousRect: DOMRect;\n  currentRect: DOMRect;\n  node: SDK.DOMModel.DOMNode;\n}\n\n/**\n * Calculates and returns a list of sources for a LayoutShift.\n * Here, a source is considered as a node that moved and contributed to the\n * given LayoutShift existing and the score it was given. Each source returned\n * contains a reference to the DOM Node, and its dimensions (as a DOMRect), both\n * before and now, so we can see how this node changed and how that impacted the\n * layout shift.\n *\n * This data is cached based on the provided model data and the given layout\n * shift, so it is is safe to call multiple times with the same input.\n */\nexport async function sourcesForLayoutShift(\n    modelData: Handlers.Types.TraceParseData,\n    event: Types.TraceEvents.TraceEventLayoutShift): Promise<readonly LayoutShiftSource[]> {\n  const fromCache = layoutShiftSourcesCache.get(modelData)?.get(event);\n  if (fromCache) {\n    return fromCache;\n  }\n  const impactedNodes = event.args.data?.impacted_nodes;\n  if (!impactedNodes) {\n    return [];\n  }\n  const sources: LayoutShiftSource[] = [];\n  await Promise.all(impactedNodes.map(async node => {\n    const domNode = await domNodeForBackendNodeID(modelData, node.node_id);\n    if (domNode) {\n      sources.push({\n        previousRect: new DOMRect(node.old_rect[0], node.old_rect[1], node.old_rect[2], node.old_rect[3]),\n        currentRect: new DOMRect(node.new_rect[0], node.new_rect[1], node.new_rect[2], node.new_rect[3]),\n        node: domNode,\n      });\n    }\n  }));\n  const cacheForModel =\n      layoutShiftSourcesCache.get(modelData) || new Map<Types.TraceEvents.TraceEventLayoutShift, LayoutShiftSource[]>();\n  cacheForModel.set(event, sources);\n  layoutShiftSourcesCache.set(modelData, cacheForModel);\n  return sources;\n}\n\n/**\n * Takes a LayoutShift and normalizes its node dimensions based on the device\n * pixel ratio (DPR) of the user's display.\n * This is required because the Layout Instability API is not based on CSS\n * pixels, but physical pixels. Therefore we need to map these to normalized CSS\n * pixels if we can. For example, if the user is on a device with a DPR of 2,\n * the values of the node dimensions reported by the Instability API need to be\n * divided by 2 to be accurate.\n * This function is safe to call multiple times as results are cached based on\n * the provided model data.\n * See https://crbug.com/1300309 for details.\n */\nexport async function normalizedImpactedNodesForLayoutShift(\n    modelData: Handlers.Types.TraceParseData,\n    event: Types.TraceEvents.TraceEventLayoutShift): Promise<readonly Types.TraceEvents.TraceImpactedNode[]> {\n  const fromCache = normalizedLayoutShiftNodesCache.get(modelData)?.get(event);\n  if (fromCache) {\n    return fromCache;\n  }\n  const impactedNodes = event.args?.data?.impacted_nodes;\n  if (!impactedNodes) {\n    return [];\n  }\n\n  let viewportScale: number|null = null;\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  // Get the CSS-to-physical pixel ratio of the device the inspected\n  // target is running at.\n  const evaluateResult = await target?.runtimeAgent().invoke_evaluate({expression: 'window.devicePixelRatio'});\n  if (evaluateResult?.result.type === 'number') {\n    viewportScale = evaluateResult?.result.value as number ?? null;\n  }\n\n  if (!viewportScale) {\n    // Bail and return the nodes as is.\n    return impactedNodes;\n  }\n\n  const normalizedNodes: Types.TraceEvents.TraceImpactedNode[] = [];\n  for (const impactedNode of impactedNodes) {\n    const newNode = {...impactedNode};\n    for (let i = 0; i < impactedNode.old_rect.length; i++) {\n      newNode.old_rect[i] /= viewportScale;\n    }\n    for (let i = 0; i < impactedNode.new_rect.length; i++) {\n      newNode.new_rect[i] /= viewportScale;\n    }\n    normalizedNodes.push(newNode);\n  }\n\n  const cacheForModel = normalizedLayoutShiftNodesCache.get(modelData) ||\n      new Map<Types.TraceEvents.TraceEventLayoutShift, readonly Types.TraceEvents.TraceImpactedNode[]>();\n  cacheForModel.set(event, normalizedNodes);\n  normalizedLayoutShiftNodesCache.set(modelData, cacheForModel);\n\n  return normalizedNodes;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/extras/FilmStrip.js

@@ -0,0 +1,37 @@
+import * as Platform from "../../../core/platform/platform.js";
+const filmStripCache = /* @__PURE__ */ new Map();
+export function fromTraceData(traceData, customZeroTime) {
+  const frames = [];
+  const zeroTime = typeof customZeroTime !== "undefined" ? customZeroTime : traceData.Meta.traceBounds.min;
+  const spanTime = traceData.Meta.traceBounds.range;
+  const fromCache = filmStripCache.get(traceData)?.get(zeroTime);
+  if (fromCache) {
+    return fromCache;
+  }
+  for (const screenshotEvent of traceData.Screenshots) {
+    if (screenshotEvent.ts < zeroTime) {
+      continue;
+    }
+    const frame = {
+      index: frames.length,
+      screenshotEvent
+    };
+    frames.push(frame);
+  }
+  const result = {
+    zeroTime,
+    spanTime,
+    frames: Array.from(frames)
+  };
+  const cachedForData = Platform.MapUtilities.getWithDefault(filmStripCache, traceData, () => /* @__PURE__ */ new Map());
+  cachedForData.set(zeroTime, result);
+  return result;
+}
+export function frameClosestToTimestamp(filmStrip, searchTimestamp) {
+  const closestFrameIndexBeforeTimestamp = Platform.ArrayUtilities.nearestIndexFromEnd(filmStrip.frames, (frame) => frame.screenshotEvent.ts < searchTimestamp);
+  if (closestFrameIndexBeforeTimestamp === null) {
+    return null;
+  }
+  return filmStrip.frames[closestFrameIndexBeforeTimestamp];
+}
+//# sourceMappingURL=FilmStrip.js.map

package/models/trace/extras/FilmStrip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/extras/FilmStrip.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 type * as Handlers from '../handlers/handlers.js';\nimport type * as Types from '../types/types.js';\n\nexport interface Data {\n  zeroTime: Types.Timing.MicroSeconds;\n  spanTime: Types.Timing.MicroSeconds;\n  frames: readonly Frame[];\n}\n\nexport interface Frame {\n  screenshotEvent: Types.TraceEvents.SyntheticScreenshot;\n  index: number;\n}\n\nexport type HandlersWithFilmStrip = Handlers.Types.HandlersWithMeta<{\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Screenshots: typeof Handlers.ModelHandlers.Screenshots,\n}>;\n\nexport type HandlerDataWithScreenshots = Handlers.Types.EnabledHandlerDataWithMeta<{\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Screenshots: typeof Handlers.ModelHandlers.Screenshots,\n}>;\n\n// Cache film strips based on:\n// 1. The trace parsed data object\n// 2. The start time.\nconst filmStripCache = new Map<HandlerDataWithScreenshots, Map<Types.Timing.MicroSeconds, Data>>();\n\nexport function fromTraceData(traceData: HandlerDataWithScreenshots, customZeroTime?: Types.Timing.MicroSeconds): Data {\n  const frames: Frame[] = [];\n\n  const zeroTime = typeof customZeroTime !== 'undefined' ? customZeroTime : traceData.Meta.traceBounds.min;\n  const spanTime = traceData.Meta.traceBounds.range;\n  const fromCache = filmStripCache.get(traceData)?.get(zeroTime);\n  if (fromCache) {\n    return fromCache;\n  }\n\n  for (const screenshotEvent of traceData.Screenshots) {\n    if (screenshotEvent.ts < zeroTime) {\n      continue;\n    }\n    const frame: Frame = {\n      index: frames.length,\n      screenshotEvent: screenshotEvent,\n    };\n    frames.push(frame);\n  }\n\n  const result: Data = {\n    zeroTime,\n    spanTime,\n    frames: Array.from(frames),\n  };\n\n  const cachedForData =\n      Platform.MapUtilities.getWithDefault(filmStripCache, traceData, () => new Map<Types.Timing.MicroSeconds, Data>());\n  cachedForData.set(zeroTime, result);\n\n  return result;\n}\n\nexport function frameClosestToTimestamp(filmStrip: Data, searchTimestamp: Types.Timing.MicroSeconds): Frame|null {\n  const closestFrameIndexBeforeTimestamp = Platform.ArrayUtilities.nearestIndexFromEnd(\n      filmStrip.frames, frame => frame.screenshotEvent.ts < searchTimestamp);\n  if (closestFrameIndexBeforeTimestamp === null) {\n    return null;\n  }\n  return filmStrip.frames[closestFrameIndexBeforeTimestamp];\n}\n"],
+  "mappings": "AAIA;AA4BA,MAAM,iBAAiB,oBAAI;AAEpB,8BAAuB,WAAuC,gBAAkD;AACrH,QAAM,SAAkB;AAExB,QAAM,WAAW,OAAO,mBAAmB,cAAc,iBAAiB,UAAU,KAAK,YAAY;AACrG,QAAM,WAAW,UAAU,KAAK,YAAY;AAC5C,QAAM,YAAY,eAAe,IAAI,YAAY,IAAI;AACrD,MAAI,WAAW;AACb,WAAO;AAAA;AAGT,aAAW,mBAAmB,UAAU,aAAa;AACnD,QAAI,gBAAgB,KAAK,UAAU;AACjC;AAAA;AAEF,UAAM,QAAe;AAAA,MACnB,OAAO,OAAO;AAAA,MACd;AAAA;AAEF,WAAO,KAAK;AAAA;AAGd,QAAM,SAAe;AAAA,IACnB;AAAA,IACA;AAAA,IACA,QAAQ,MAAM,KAAK;AAAA;AAGrB,QAAM,gBACF,SAAS,aAAa,eAAe,gBAAgB,WAAW,MAAM,oBAAI;AAC9E,gBAAc,IAAI,UAAU;AAE5B,SAAO;AAAA;AAGF,wCAAiC,WAAiB,iBAAwD;AAC/G,QAAM,mCAAmC,SAAS,eAAe,oBAC7D,UAAU,QAAQ,WAAS,MAAM,gBAAgB,KAAK;AAC1D,MAAI,qCAAqC,MAAM;AAC7C,WAAO;AAAA;AAET,SAAO,UAAU,OAAO;AAAA;",
+  "names": []
+}

package/models/trace/extras/MainThreadActivity.js

@@ -0,0 +1,61 @@
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+const IDLE_FUNCTION_CALL_NAMES = /* @__PURE__ */ new Set([
+  "(program)",
+  "(idle)",
+  "(root)"
+]);
+export function calculateWindow(traceBounds, mainThreadEntries) {
+  if (!mainThreadEntries.length) {
+    return traceBounds;
+  }
+  const entriesWithIdleRemoved = mainThreadEntries.filter((entry) => {
+    if (Types.TraceEvents.isProfileCall(entry) && (IDLE_FUNCTION_CALL_NAMES.has(entry.callFrame.functionName) || !entry.callFrame.functionName)) {
+      return false;
+    }
+    return true;
+  });
+  if (entriesWithIdleRemoved.length === 0) {
+    return traceBounds;
+  }
+  function findLowUtilizationRegion(startIndex, stopIndex) {
+    const threshold = 0.1;
+    let cutIndex = startIndex;
+    const entryAtCut = entriesWithIdleRemoved[cutIndex];
+    const timings = Helpers.Timing.eventTimingsMicroSeconds(entryAtCut);
+    let cutTime = (timings.startTime + timings.endTime) / 2;
+    let usedTime = 0;
+    const step = Math.sign(stopIndex - startIndex);
+    for (let i = startIndex; i !== stopIndex; i += step) {
+      const task = entriesWithIdleRemoved[i];
+      const taskTimings = Helpers.Timing.eventTimingsMicroSeconds(task);
+      const taskTime = (taskTimings.startTime + taskTimings.endTime) / 2;
+      const interval = Math.abs(cutTime - taskTime);
+      if (usedTime < threshold * interval) {
+        cutIndex = i;
+        cutTime = taskTime;
+        usedTime = 0;
+      }
+      usedTime += taskTimings.duration;
+    }
+    return cutIndex;
+  }
+  const rightIndex = findLowUtilizationRegion(entriesWithIdleRemoved.length - 1, 0);
+  const leftIndex = findLowUtilizationRegion(0, rightIndex);
+  const leftTimings = Helpers.Timing.eventTimingsMicroSeconds(entriesWithIdleRemoved[leftIndex]);
+  const rightTimings = Helpers.Timing.eventTimingsMicroSeconds(entriesWithIdleRemoved[rightIndex]);
+  let leftTime = leftTimings.startTime;
+  let rightTime = rightTimings.endTime;
+  const zoomedInSpan = rightTime - leftTime;
+  if (zoomedInSpan < traceBounds.range * 0.1) {
+    return traceBounds;
+  }
+  leftTime = Types.Timing.MicroSeconds(Math.max(leftTime - 0.05 * zoomedInSpan, traceBounds.min));
+  rightTime = Types.Timing.MicroSeconds(Math.min(rightTime + 0.05 * zoomedInSpan, traceBounds.max));
+  return {
+    min: leftTime,
+    max: rightTime,
+    range: Types.Timing.MicroSeconds(rightTime - leftTime)
+  };
+}
+//# sourceMappingURL=MainThreadActivity.js.map

package/models/trace/extras/MainThreadActivity.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/extras/MainThreadActivity.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.\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nconst IDLE_FUNCTION_CALL_NAMES = new Set([\n  '(program)',\n  '(idle)',\n  '(root)',\n]);\n\nexport function calculateWindow(\n    traceBounds: Types.Timing.TraceWindowMicroSeconds,\n    mainThreadEntries: readonly Types.TraceEvents.SyntheticTraceEntry[]): Types.Timing.TraceWindowMicroSeconds {\n  if (!mainThreadEntries.length) {\n    return traceBounds;\n  }\n  const entriesWithIdleRemoved = mainThreadEntries.filter(entry => {\n    if (Types.TraceEvents.isProfileCall(entry) &&\n        (IDLE_FUNCTION_CALL_NAMES.has(entry.callFrame.functionName) || !entry.callFrame.functionName)) {\n      return false;\n    }\n    return true;\n  });\n\n  if (entriesWithIdleRemoved.length === 0) {\n    return traceBounds;\n  }\n  /**\n   * Calculates regions of low utilization and returns the index of the event\n   * that is the first event that should be included.\n   **/\n  function findLowUtilizationRegion(startIndex: number, stopIndex: number): number {\n    const threshold = 0.1;\n\n    let cutIndex = startIndex;\n    const entryAtCut = entriesWithIdleRemoved[cutIndex];\n    const timings = Helpers.Timing.eventTimingsMicroSeconds(entryAtCut);\n    let cutTime = (timings.startTime + timings.endTime) / 2;\n    let usedTime = 0;\n    const step = Math.sign(stopIndex - startIndex);\n    for (let i = startIndex; i !== stopIndex; i += step) {\n      const task = entriesWithIdleRemoved[i];\n      const taskTimings = Helpers.Timing.eventTimingsMicroSeconds(task);\n      const taskTime = (taskTimings.startTime + taskTimings.endTime) / 2;\n      const interval = Math.abs(cutTime - taskTime);\n      if (usedTime < threshold * interval) {\n        cutIndex = i;\n        cutTime = taskTime;\n        usedTime = 0;\n      }\n      usedTime += taskTimings.duration;\n    }\n    return cutIndex;\n  }\n  const rightIndex = findLowUtilizationRegion(entriesWithIdleRemoved.length - 1, 0);\n  const leftIndex = findLowUtilizationRegion(0, rightIndex);\n  const leftTimings = Helpers.Timing.eventTimingsMicroSeconds(entriesWithIdleRemoved[leftIndex]);\n  const rightTimings = Helpers.Timing.eventTimingsMicroSeconds(entriesWithIdleRemoved[rightIndex]);\n\n  let leftTime = leftTimings.startTime;\n  let rightTime = rightTimings.endTime;\n  const zoomedInSpan = rightTime - leftTime;\n\n  if (zoomedInSpan < traceBounds.range * 0.1) {\n    // If the area we have chosen to zoom into is less than 10% of the entire\n    // span, we bail and show the entire trace. It would not be so useful to\n    // the user to zoom in on such a small area; we assume they have\n    // purposefully recorded a trace that contains empty periods of time.\n    return traceBounds;\n  }\n\n  // Adjust the left time down by 5%, and the right time up by 5%, so that\n  // we give the range we want to zoom a bit of breathing space. At the\n  // same time, ensure that we do not stray beyond the bounds of the\n  // min/max time of the entire trace.\n  leftTime = Types.Timing.MicroSeconds(Math.max(leftTime - 0.05 * zoomedInSpan, traceBounds.min));\n  rightTime = Types.Timing.MicroSeconds(Math.min(rightTime + 0.05 * zoomedInSpan, traceBounds.max));\n\n  return {\n    min: leftTime,\n    max: rightTime,\n    range: Types.Timing.MicroSeconds(rightTime - leftTime),\n  };\n}\n"],
+  "mappings": "AAGA;AACA;AAEA,MAAM,2BAA2B,oBAAI,IAAI;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AAAA;AAGK,gCACH,aACA,mBAA2G;AAC7G,MAAI,CAAC,kBAAkB,QAAQ;AAC7B,WAAO;AAAA;AAET,QAAM,yBAAyB,kBAAkB,OAAO,WAAS;AAC/D,QAAI,MAAM,YAAY,cAAc,UAC/B,0BAAyB,IAAI,MAAM,UAAU,iBAAiB,CAAC,MAAM,UAAU,eAAe;AACjG,aAAO;AAAA;AAET,WAAO;AAAA;AAGT,MAAI,uBAAuB,WAAW,GAAG;AACvC,WAAO;AAAA;AAMT,oCAAkC,YAAoB,WAA2B;AAC/E,UAAM,YAAY;AAElB,QAAI,WAAW;AACf,UAAM,aAAa,uBAAuB;AAC1C,UAAM,UAAU,QAAQ,OAAO,yBAAyB;AACxD,QAAI,UAAW,SAAQ,YAAY,QAAQ,WAAW;AACtD,QAAI,WAAW;AACf,UAAM,OAAO,KAAK,KAAK,YAAY;AACnC,aAAS,IAAI,YAAY,MAAM,WAAW,KAAK,MAAM;AACnD,YAAM,OAAO,uBAAuB;AACpC,YAAM,cAAc,QAAQ,OAAO,yBAAyB;AAC5D,YAAM,WAAY,aAAY,YAAY,YAAY,WAAW;AACjE,YAAM,WAAW,KAAK,IAAI,UAAU;AACpC,UAAI,WAAW,YAAY,UAAU;AACnC,mBAAW;AACX,kBAAU;AACV,mBAAW;AAAA;AAEb,kBAAY,YAAY;AAAA;AAE1B,WAAO;AAAA;AAET,QAAM,aAAa,yBAAyB,uBAAuB,SAAS,GAAG;AAC/E,QAAM,YAAY,yBAAyB,GAAG;AAC9C,QAAM,cAAc,QAAQ,OAAO,yBAAyB,uBAAuB;AACnF,QAAM,eAAe,QAAQ,OAAO,yBAAyB,uBAAuB;AAEpF,MAAI,WAAW,YAAY;AAC3B,MAAI,YAAY,aAAa;AAC7B,QAAM,eAAe,YAAY;AAEjC,MAAI,eAAe,YAAY,QAAQ,KAAK;AAK1C,WAAO;AAAA;AAOT,aAAW,MAAM,OAAO,aAAa,KAAK,IAAI,WAAW,OAAO,cAAc,YAAY;AAC1F,cAAY,MAAM,OAAO,aAAa,KAAK,IAAI,YAAY,OAAO,cAAc,YAAY;AAE5F,SAAO;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,OAAO,MAAM,OAAO,aAAa,YAAY;AAAA;AAAA;",
+  "names": []
+}

package/models/trace/extras/Metadata.js

@@ -0,0 +1,28 @@
+import * as SDK from "../../../core/sdk/sdk.js";
+export async function forNewRecording(recordStartTime) {
+  try {
+    let getConcurrencyOrTimeout = function() {
+      return Promise.race([
+        SDK.CPUThrottlingManager.CPUThrottlingManager.instance().getHardwareConcurrency(),
+        new Promise((resolve) => {
+          setTimeout(() => resolve(void 0), 1e3);
+        })
+      ]);
+    };
+    const cpuThrottlingManager = SDK.CPUThrottlingManager.CPUThrottlingManager.instance();
+    const hardwareConcurrency = cpuThrottlingManager.hasPrimaryPageTargetSet() ? await getConcurrencyOrTimeout() : void 0;
+    const cpuThrottling = SDK.CPUThrottlingManager.CPUThrottlingManager.instance().cpuThrottlingRate();
+    const networkConditions = SDK.NetworkManager.MultitargetNetworkManager.instance().networkConditions();
+    const networkTitle = typeof networkConditions.title === "function" ? networkConditions.title() : networkConditions.title;
+    return {
+      source: "DevTools",
+      startTime: recordStartTime ? new Date(recordStartTime).toJSON() : void 0,
+      cpuThrottling,
+      networkThrottling: networkTitle,
+      hardwareConcurrency
+    };
+  } catch {
+    return {};
+  }
+}
+//# sourceMappingURL=Metadata.js.map

package/models/trace/extras/Metadata.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/extras/Metadata.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 SDK from '../../../core/sdk/sdk.js';\nimport type * as Types from '../types/types.js';\n\nexport async function forNewRecording(recordStartTime?: number): Promise<Types.File.MetaData> {\n  try {\n    const cpuThrottlingManager = SDK.CPUThrottlingManager.CPUThrottlingManager.instance();\n\n    // If the CPU Throttling manager has yet to have its primary page target\n    // set, it will block on the call to get the current hardware concurrency\n    // until it does. At this point where the user has recorded a trace, that\n    // target should have been set. So if it doesn't have it set, we instead\n    // just bail and don't store the hardware concurrency (this is only\n    // metadata, not mission critical information).\n    // We also race this call against a 1s timeout, because sometimes this call\n    // can hang (unsure exactly why) and we do not want to block parsing for\n    // too long as a result.\n    function getConcurrencyOrTimeout(): Promise<number|undefined> {\n      return Promise.race([\n        SDK.CPUThrottlingManager.CPUThrottlingManager.instance().getHardwareConcurrency(),\n        new Promise<undefined>(resolve => {\n          setTimeout(() => resolve(undefined), 1_000);\n        }),\n      ]);\n    }\n\n    const hardwareConcurrency =\n        cpuThrottlingManager.hasPrimaryPageTargetSet() ? await getConcurrencyOrTimeout() : undefined;\n    const cpuThrottling = SDK.CPUThrottlingManager.CPUThrottlingManager.instance().cpuThrottlingRate();\n    const networkConditions = SDK.NetworkManager.MultitargetNetworkManager.instance().networkConditions();\n    const networkTitle =\n        typeof networkConditions.title === 'function' ? networkConditions.title() : networkConditions.title;\n\n    return {\n      source: 'DevTools',\n      startTime: recordStartTime ? new Date(recordStartTime).toJSON() : undefined,  // ISO-8601 timestamp\n      cpuThrottling,\n      networkThrottling: networkTitle,\n      hardwareConcurrency,\n    };\n  } catch {\n    // If anything went wrong, it does not really matter. The impact is that we\n    // will not save the metadata when we save the trace to disk, but that is\n    // not really important, so just return empty object and move on\n    return {};\n  }\n}\n"],
+  "mappings": "AAIA;AAGA,sCAAsC,iBAAwD;AAC5F,MAAI;AAYF,QAAS,0BAAT,WAA8D;AAC5D,aAAO,QAAQ,KAAK;AAAA,QAClB,IAAI,qBAAqB,qBAAqB,WAAW;AAAA,QACzD,IAAI,QAAmB,aAAW;AAChC,qBAAW,MAAM,QAAQ,SAAY;AAAA;AAAA;AAAA;AAf3C,UAAM,uBAAuB,IAAI,qBAAqB,qBAAqB;AAoB3E,UAAM,sBACF,qBAAqB,4BAA4B,MAAM,4BAA4B;AACvF,UAAM,gBAAgB,IAAI,qBAAqB,qBAAqB,WAAW;AAC/E,UAAM,oBAAoB,IAAI,eAAe,0BAA0B,WAAW;AAClF,UAAM,eACF,OAAO,kBAAkB,UAAU,aAAa,kBAAkB,UAAU,kBAAkB;AAElG,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,WAAW,kBAAkB,IAAI,KAAK,iBAAiB,WAAW;AAAA,MAClE;AAAA,MACA,mBAAmB;AAAA,MACnB;AAAA;AAAA,UAEF;AAIA,WAAO;AAAA;AAAA;",
+  "names": []
+}

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

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

package/models/trace/extras/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/extras",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "devtools_entrypoint-bundle-typescript-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../../front_end/models/trace/extras/extras.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": "./extras-tsconfig.json"
+    }
+  ]
+}

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

@@ -0,0 +1,59 @@
+{
+  "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/extras",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "esnext",
+    "tsBuildInfoFile": "extras-tsconfig.json.tsbuildinfo",
+    "typeRoots": [],
+    "useUnknownInCatchVariables": false
+  },
+  "files": [
+    "../../../../../../../front_end/models/trace/extras/FetchNodes.ts",
+    "../../../../../../../front_end/models/trace/extras/FilmStrip.ts",
+    "../../../../../../../front_end/models/trace/extras/MainThreadActivity.ts",
+    "../../../../../../../front_end/models/trace/extras/Metadata.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": "../../../core/sdk/bundle-tsconfig.json"
+    },
+    {
+      "path": "../../../generated/protocol-tsconfig.json"
+    },
+    {
+      "path": "../handlers/bundle-tsconfig.json"
+    },
+    {
+      "path": "../types/bundle-tsconfig.json"
+    }
+  ]
+}

package/models/trace/extras/extras.d.ts

@@ -0,0 +1 @@
+export {};

package/models/trace/extras/extras.js

@@ -0,0 +1 @@
+export {};

package/models/trace/extras/extras.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/extras/extras.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\nexport * as FetchNodes from './FetchNodes.js';\nexport * as FilmStrip from './FilmStrip.js';\nexport * as MainThreadActivity from './MainThreadActivity.js';\nexport * as Metadata from './Metadata.js';\n"],
+  "mappings": "AAIA;AACA;AACA;AACA;",
+  "names": []
+}