chrome-devtools-mcp 0.1.0 → 0.2.1

package/build/node_modules/chrome-devtools-frontend/front_end/models/source_map_scopes/ScopeTreeCache.js

@@ -0,0 +1,32 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Formatter from '../formatter/formatter.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+/** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
+const scopeTrees = new WeakMap();
+/**
+ * Computes and caches the scope tree for `script`.
+ *
+ * We use {@link SDK.Script.Script} as a key to uniquely identify scripts.
+ * {@link SDK.Script.Script} boils down to "target" + "script ID". This
+ * duplicates work in case of identitical script running on multiple targets
+ * (e.g. workers).
+ */
+export function scopeTreeForScript(script) {
+    let promise = scopeTrees.get(script);
+    if (promise === undefined) {
+        promise = script.requestContentData().then(content => {
+            if (TextUtils.ContentData.ContentData.isError(content)) {
+                return null;
+            }
+            const sourceType = script.isModule ? 'module' : 'script';
+            return Formatter.FormatterWorkerPool.formatterWorkerPool()
+                .javaScriptScopeTree(content.text, sourceType)
+                .catch(() => null);
+        });
+        scopeTrees.set(script, promise);
+    }
+    // We intentionally return `null` here if the script already failed to parse once.
+    return promise;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/source_map_scopes/source_map_scopes.js

@@ -0,0 +1,7 @@
+// Copyright 2022 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as NamesResolver from './NamesResolver.js';
+import * as ScopeChainModel from './ScopeChainModel.js';
+import * as ScopeTreeCache from './ScopeTreeCache.js';
+export { NamesResolver, ScopeChainModel, ScopeTreeCache, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/StackTrace.js

@@ -0,0 +1,4 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export {};

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/StackTraceImpl.js

@@ -0,0 +1,67 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+export class StackTraceImpl extends Common.ObjectWrapper.ObjectWrapper {
+    syncFragment;
+    asyncFragments;
+    constructor(syncFragment, asyncFragments) {
+        super();
+        this.syncFragment = syncFragment;
+        this.asyncFragments = asyncFragments;
+        syncFragment.stackTraces.add(this);
+        this.asyncFragments.forEach(asyncFragment => asyncFragment.fragment.stackTraces.add(this));
+    }
+}
+export class FragmentImpl {
+    node;
+    stackTraces = new Set();
+    /**
+     * Fragments are deduplicated based on the node.
+     *
+     * In turn, each fragment can be part of multiple stack traces.
+     */
+    static getOrCreate(node) {
+        if (!node.fragment) {
+            node.fragment = new FragmentImpl(node);
+        }
+        return node.fragment;
+    }
+    constructor(node) {
+        this.node = node;
+    }
+    get frames() {
+        const frames = [];
+        for (const node of this.node.getCallStack()) {
+            frames.push(...node.frames);
+        }
+        return frames;
+    }
+}
+export class AsyncFragmentImpl {
+    description;
+    fragment;
+    constructor(description, fragment) {
+        this.description = description;
+        this.fragment = fragment;
+    }
+    get frames() {
+        return this.fragment.frames;
+    }
+}
+export class FrameImpl {
+    url;
+    uiSourceCode;
+    name;
+    line;
+    column;
+    missingDebugInfo;
+    constructor(url, uiSourceCode, name, line, column, missingDebugInfo) {
+        this.url = url;
+        this.uiSourceCode = uiSourceCode;
+        this.name = name;
+        this.line = line;
+        this.column = column;
+        this.missingDebugInfo = missingDebugInfo;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/StackTraceModel.js

@@ -0,0 +1,97 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as SDK from '../../core/sdk/sdk.js';
+// eslint-disable-next-line rulesdir/es-modules-import
+import * as StackTrace from './stack_trace.js';
+import { AsyncFragmentImpl, FragmentImpl, FrameImpl, StackTraceImpl } from './StackTraceImpl.js';
+import { Trie } from './Trie.js';
+/**
+ * The {@link StackTraceModel} is a thin wrapper around a fragment trie.
+ *
+ * We want to store stack trace fragments per target so a SDKModel is the natural choice.
+ */
+export class StackTraceModel extends SDK.SDKModel.SDKModel {
+    #trie = new Trie();
+    /** @returns the {@link StackTraceModel} for the target, or the model for the primaryPageTarget when passing null/undefined */
+    static #modelForTarget(target) {
+        const model = (target ?? SDK.TargetManager.TargetManager.instance().primaryPageTarget())?.model(StackTraceModel);
+        if (!model) {
+            throw new Error('Unable to find StackTraceModel');
+        }
+        return model;
+    }
+    async createFromProtocolRuntime(stackTrace, rawFramesToUIFrames) {
+        const translatePromises = [];
+        const fragment = this.#createFragment(stackTrace.callFrames);
+        translatePromises.push(this.#translateFragment(fragment, rawFramesToUIFrames));
+        const asyncFragments = [];
+        const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
+        if (debuggerModel) {
+            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTrace)) {
+                const model = StackTraceModel.#modelForTarget(target);
+                const asyncFragment = model.#createFragment(asyncStackTrace.callFrames);
+                translatePromises.push(model.#translateFragment(asyncFragment, rawFramesToUIFrames));
+                asyncFragments.push(new AsyncFragmentImpl(asyncStackTrace.description ?? '', asyncFragment));
+            }
+        }
+        await Promise.all(translatePromises);
+        return new StackTraceImpl(fragment, asyncFragments);
+    }
+    /** Trigger re-translation of all fragments with the provide script in their call stack */
+    async scriptInfoChanged(script, translateRawFrames) {
+        const translatePromises = [];
+        let stackTracesToUpdate = new Set();
+        for (const fragment of this.#affectedFragments(script)) {
+            // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
+            // is re-translated as a side-effect.
+            // We just need to remember the stack traces of the skipped over fragments, so we can send the
+            // UPDATED event also to them.
+            if (fragment.node.children.length === 0) {
+                translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+            }
+            stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
+        }
+        await Promise.all(translatePromises);
+        for (const stackTrace of stackTracesToUpdate) {
+            stackTrace.dispatchEventToListeners("UPDATED" /* StackTrace.StackTrace.Events.UPDATED */);
+        }
+    }
+    #createFragment(frames) {
+        return FragmentImpl.getOrCreate(this.#trie.insert(frames));
+    }
+    async #translateFragment(fragment, rawFramesToUIFrames) {
+        const rawFrames = fragment.node.getCallStack().map(node => node.rawFrame).toArray();
+        const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
+        console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
+        let i = 0;
+        for (const node of fragment.node.getCallStack()) {
+            node.frames = uiFrames[i++].map(frame => new FrameImpl(frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo));
+        }
+    }
+    #affectedFragments(script) {
+        // 1. Collect branches with the matching script.
+        const affectedBranches = new Set();
+        this.#trie.walk(null, node => {
+            // scriptId has precedence, but if the frame does not have one, check the URL.
+            if (node.rawFrame.scriptId === script.scriptId ||
+                (!node.rawFrame.scriptId && node.rawFrame.url === script.sourceURL)) {
+                affectedBranches.add(node);
+                return false;
+            }
+            return true;
+        });
+        // 2. For each branch collect all the fragments.
+        const fragments = new Set();
+        for (const branch of affectedBranches) {
+            this.#trie.walk(branch, node => {
+                if (node.fragment) {
+                    fragments.add(node.fragment);
+                }
+                return true;
+            });
+        }
+        return fragments;
+    }
+}
+SDK.SDKModel.SDKModel.register(StackTraceModel, { capabilities: 0 /* SDK.Target.Capability.NONE */, autostart: false });

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/Trie.js

@@ -0,0 +1,113 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export class FrameNode {
+    parent;
+    children = [];
+    rawFrame;
+    frames = [];
+    fragment;
+    constructor(rawFrame, parent) {
+        this.rawFrame = rawFrame;
+        this.parent = parent;
+    }
+    /**
+     * Produces the ancestor chain. Including `this` but excluding the `RootFrameNode`.
+     */
+    *getCallStack() {
+        // The `RootFrameNode` doesn't have an actual frame attached, that's why we check for `node.parent` instead of `node`.
+        for (let node = this; node.parent; node = node.parent) {
+            yield node;
+        }
+    }
+}
+/**
+ * Stores stack trace fragments in a trie, but does not own them/keep them alive.
+ */
+export class Trie {
+    #root = { parent: null, children: [] };
+    /**
+     * Most sources produce stack traces in "top-to-bottom" order, so that is what this method expects.
+     *
+     * @returns The {@link FrameNode} corresponding to the top-most stack frame.
+     */
+    insert(frames) {
+        if (frames.length === 0) {
+            throw new Error('Trie.insert called with an empty frames array.');
+        }
+        let currentNode = this.#root;
+        for (let i = frames.length - 1; i >= 0; --i) {
+            currentNode = this.#insert(currentNode, frames[i]);
+        }
+        return currentNode;
+    }
+    /**
+     * Inserts `rawFrame` into the children of the provided node if not already there.
+     *
+     * @returns the child node corresponding to `rawFrame`.
+     */
+    #insert(node, rawFrame) {
+        let i = 0;
+        for (; i < node.children.length; ++i) {
+            const maybeChild = node.children[i];
+            const child = maybeChild instanceof WeakRef ? maybeChild.deref() : maybeChild;
+            if (!child) {
+                continue;
+            }
+            const compareResult = compareRawFrames(child.rawFrame, rawFrame);
+            if (compareResult === 0) {
+                return child;
+            }
+            if (compareResult > 0) {
+                break;
+            }
+        }
+        const newNode = new FrameNode(rawFrame, node);
+        if (node.parent) {
+            node.children.splice(i, 0, newNode);
+        }
+        else {
+            node.children.splice(i, 0, new WeakRef(newNode));
+        }
+        return newNode;
+    }
+    /**
+     * Traverses the trie in pre-order.
+     *
+     * @param node Start at `node` or `null` to start with the children of the root.
+     * @param visit Called on each node in the trie. Return `true` if the visitor should descend into child nodes of the provided node.
+     */
+    walk(node, visit) {
+        const stack = node ? [node] : [...this.#root.children].map(ref => ref.deref()).filter(node => Boolean(node));
+        for (let node = stack.pop(); node; node = stack.pop()) {
+            const visitChildren = visit(node);
+            if (visitChildren) {
+                // Pushing the children in reverse means the "left-most" child is visited first (i.e. pre-order).
+                for (let i = node.children.length - 1; i >= 0; --i) {
+                    stack.push(node.children[i]);
+                }
+            }
+        }
+    }
+}
+/**
+ * @returns a number < 0, 0 or > 0, if the `a` is smaller then, equal or greater then `b`.
+ */
+export function compareRawFrames(a, b) {
+    const scriptIdCompare = (a.scriptId ?? '').localeCompare(b.scriptId ?? '');
+    if (scriptIdCompare !== 0) {
+        return scriptIdCompare;
+    }
+    const urlCompare = (a.url ?? '').localeCompare(b.url ?? '');
+    if (urlCompare !== 0) {
+        return urlCompare;
+    }
+    const nameCompare = (a.functionName ?? '').localeCompare(b.functionName ?? '');
+    if (nameCompare !== 0) {
+        return nameCompare;
+    }
+    if (a.lineNumber !== b.lineNumber) {
+        return a.lineNumber - b.lineNumber;
+    }
+    return a.columnNumber - b.columnNumber;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/stack_trace.js

@@ -0,0 +1,5 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as StackTrace from './StackTrace.js';
+export { StackTrace, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/stack_trace_impl.js

@@ -0,0 +1,7 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as StackTraceImpl from './StackTraceImpl.js';
+import * as StackTraceModel from './StackTraceModel.js';
+import * as Trie from './Trie.js';
+export { StackTraceImpl, StackTraceModel, Trie, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/text_utils/TextUtils.js

@@ -330,3 +330,26 @@ export const performSearchInSearchMatches = function (matches, query, caseSensit
     }
     return result;
 };
+/**
+ * Finds the longest overlapping string segment between the end of the first
+ * string and the beginning of the second string.
+ *
+ * @param s1 The first string (whose suffix will be checked).
+ * @param s2 The second string (whose prefix will be checked).
+ * @returns The overlapping string segment, or an empty string ("")
+ * if no overlap is found.
+ */
+export const getOverlap = function (s1, s2) {
+    const minLen = Math.min(s1.length, s2.length);
+    // Check from longest possible overlap down to 1
+    for (let n = minLen; n > 0; n--) {
+        // slice(-n) gets the last 'n' chars
+        const suffix = s1.slice(-n);
+        // substring(0, n) gets the first 'n' chars
+        const prefix = s2.substring(0, n);
+        if (suffix === prefix) {
+            return suffix;
+        }
+    }
+    return null;
+};

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/ModelImpl.js

@@ -6,6 +6,9 @@ import * as Handlers from './handlers/handlers.js';
 import * as Helpers from './helpers/helpers.js';
 import { TraceParseProgressEvent, TraceProcessor } from './Processor.js';
 import * as Types from './types/types.js';
+// Note: this model is implemented in a way that can support multiple trace
+// processors. Currently there is only one implemented, but you will see
+// references to "processors" plural because it can easily be extended in the future.
 /**
  * The Model is responsible for parsing arrays of raw trace events and storing the
  * resulting data. It can store multiple traces at once, and can return the data for
@@ -69,8 +72,6 @@ export class Model extends EventTarget {
      **/
     async parse(traceEvents, config) {
         const metadata = config?.metadata || {};
-        const isFreshRecording = config?.isFreshRecording || false;
-        const isCPUProfile = metadata?.dataOrigin === "CPUProfile" /* Types.File.DataOrigin.CPU_PROFILE */;
         // During parsing, periodically update any listeners on each processors'
         // progress (if they have any updates).
         const onTraceUpdate = (event) => {
@@ -83,13 +84,7 @@ export class Model extends EventTarget {
         try {
             // Wait for all outstanding promises before finishing the async execution,
             // but perform all tasks in parallel.
-            const parseConfig = {
-                isFreshRecording,
-                isCPUProfile,
-                metadata,
-                resolveSourceMap: config?.resolveSourceMap,
-            };
-            await this.#processor.parse(traceEvents, parseConfig);
+            await this.#processor.parse(traceEvents, config ?? {});
             if (!this.#processor.data) {
                 throw new Error('processor did not parse trace');
             }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/Processor.js

@@ -1,6 +1,7 @@
 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+var _a;
 import * as Handlers from './handlers/handlers.js';
 import * as Helpers from './helpers/helpers.js';
 import * as Insights from './insights/insights.js';
@@ -31,7 +32,7 @@ export class TraceProcessor extends EventTarget {
     #data = null;
     #insights = null;
     static createWithAllHandlers() {
-        return new TraceProcessor(Handlers.ModelHandlers, Types.Configuration.defaults());
+        return new _a(Handlers.ModelHandlers, Types.Configuration.defaults());
     }
     /**
      * This function is kept for testing with `stub`.
@@ -111,6 +112,9 @@ export class TraceProcessor extends EventTarget {
         if (this.#status !== "IDLE" /* Status.IDLE */) {
             throw new Error(`Trace processor can't start parsing when not idle. Current state: ${this.#status}`);
         }
+        if (typeof options.isCPUProfile === 'undefined' && options.metadata) {
+            options.isCPUProfile = options.metadata.dataOrigin === "CPUProfile" /* Types.File.DataOrigin.CPU_PROFILE */;
+        }
         options.logger?.start('total');
         try {
             this.#status = "PARSING" /* Status.PARSING */;
@@ -345,7 +349,8 @@ export class TraceProcessor extends EventTarget {
         }
         insightSet.model = newModel;
     }
-    #computeInsightSet(data, context, options) {
+    #computeInsightSet(data, context) {
+        const logger = context.options.logger;
         let id, urlString, navigation;
         if (context.navigation) {
             id = context.navigationId;
@@ -357,10 +362,10 @@ export class TraceProcessor extends EventTarget {
             urlString = data.Meta.finalDisplayUrlByNavigationId.get('') ?? data.Meta.mainFrameURL;
         }
         const insightSetModel = {};
-        for (const [name, insight] of Object.entries(TraceProcessor.getInsightRunners())) {
+        for (const [name, insight] of Object.entries(_a.getInsightRunners())) {
             let model;
             try {
-                options.logger?.start(`insights:${name}`);
+                logger?.start(`insights:${name}`);
                 model = insight.generateInsight(data, context);
                 model.frameId = context.frameId;
                 const navId = context.navigation?.args.data?.navigationId;
@@ -376,7 +381,7 @@ export class TraceProcessor extends EventTarget {
                 model = err;
             }
             finally {
-                options.logger?.end(`insights:${name}`);
+                logger?.end(`insights:${name}`);
             }
             Object.assign(insightSetModel, { [name]: model });
         }
@@ -420,7 +425,7 @@ export class TraceProcessor extends EventTarget {
             this.#insights = new Map();
         }
         this.#insights.set(insightSet.id, insightSet);
-        this.sortInsightSet(insightSet, options.metadata ?? null);
+        this.sortInsightSet(insightSet, context.options.metadata ?? null);
     }
     /**
      * Run all the insights and set the result to `#insights`.
@@ -449,11 +454,12 @@ export class TraceProcessor extends EventTarget {
             Helpers.Timing.traceWindowFromMicroSeconds(data.Meta.traceBounds.min, navigations[0].ts) :
             data.Meta.traceBounds;
         const context = {
+            options,
             bounds,
             frameId: data.Meta.mainFrameId,
             // No navigation or lantern context applies to this initial/no-navigation period.
         };
-        this.#computeInsightSet(data, context, options);
+        this.#computeInsightSet(data, context);
     }
     /**
      * Computes insights for a specific navigation event.
@@ -497,15 +503,17 @@ export class TraceProcessor extends EventTarget {
             options.logger?.end('insights:createLanternContext');
         }
         const context = {
+            options,
             bounds,
             frameId,
             navigation,
             navigationId,
             lantern,
         };
-        this.#computeInsightSet(data, context, options);
+        this.#computeInsightSet(data, context);
     }
 }
+_a = TraceProcessor;
 /**
  * Some Handlers need data provided by others. Dependencies of a handler handler are
  * declared in the `deps` field.

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/AuctionWorkletsHandler.js

@@ -157,6 +157,6 @@ export async function finalize() {
 }
 export function data() {
     return {
-        worklets: new Map(createdSyntheticEvents),
+        worklets: createdSyntheticEvents,
     };
 }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/FramesHandler.js

@@ -67,8 +67,8 @@ export async function finalize() {
 }
 export function data() {
     return {
-        frames: model ? Array.from(model.frames()) : [],
-        framesById: model ? { ...model.framesById() } : {},
+        frames: model?.frames() ?? [],
+        framesById: model?.framesById() ?? {},
     };
 }
 export function deps() {

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/LayoutShiftsHandler.js

@@ -419,15 +419,14 @@ export function data() {
         prePaintEvents,
         layoutInvalidationEvents,
         scheduleStyleInvalidationEvents,
-        styleRecalcInvalidationEvents: [],
+        styleRecalcInvalidationEvents,
         renderFrameImplCreateChildFrameEvents,
         domLoadingEvents,
         layoutImageUnsizedEvents,
         remoteFonts,
         scoreRecords,
-        // TODO(crbug/41484172): change the type so no need to clone
-        backendNodeIds: [...backendNodeIds],
-        clustersByNavigationId: new Map(clustersByNavigationId),
+        backendNodeIds,
+        clustersByNavigationId,
         paintImageEvents,
     };
 }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/MetaHandler.js

@@ -21,11 +21,14 @@ let viewportRect = null;
 let devicePixelRatio = null;
 let processNames = new Map();
 let topLevelRendererIds = new Set();
-const traceBounds = {
-    min: Types.Timing.Micro(Number.POSITIVE_INFINITY),
-    max: Types.Timing.Micro(Number.NEGATIVE_INFINITY),
-    range: Types.Timing.Micro(Number.POSITIVE_INFINITY),
-};
+function makeNewTraceBounds() {
+    return {
+        min: Types.Timing.Micro(Number.POSITIVE_INFINITY),
+        max: Types.Timing.Micro(Number.NEGATIVE_INFINITY),
+        range: Types.Timing.Micro(Number.POSITIVE_INFINITY),
+    };
+}
+let traceBounds = makeNewTraceBounds();
 /**
  * These represent the user navigating. Values such as First Contentful Paint,
  * etc, are relative to the navigation.
@@ -84,9 +87,7 @@ export function reset() {
     threadsInProcess = new Map();
     rendererProcessesByFrameId = new Map();
     framesByProcessId = new Map();
-    traceBounds.min = Types.Timing.Micro(Number.POSITIVE_INFINITY);
-    traceBounds.max = Types.Timing.Micro(Number.NEGATIVE_INFINITY);
-    traceBounds.range = Types.Timing.Micro(Number.POSITIVE_INFINITY);
+    traceBounds = makeNewTraceBounds();
     traceStartedTimeFromTracingStartedEvent = Types.Timing.Micro(-1);
     traceIsGeneric = true;
 }
@@ -377,7 +378,7 @@ export async function finalize() {
 }
 export function data() {
     return {
-        traceBounds: { ...traceBounds },
+        traceBounds,
         browserProcessId,
         browserThreadId,
         processNames,

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/ScreenshotsHandler.js

@@ -86,7 +86,6 @@ function getPresentationTimestamp(screenshotEvent) {
     // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.
     return updatedTs ?? screenshotEvent.ts;
 }
-// TODO(crbug/41484172): should be readonly
 export function data() {
     return {
         legacySyntheticScreenshots: syntheticScreenshots.length ? syntheticScreenshots : null,

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/ScriptsHandler.js

@@ -19,14 +19,14 @@ export function handleEvent(event) {
         const key = `${isolate}.${scriptId}`;
         return Platform.MapUtilities.getWithDefault(scriptById, key, () => ({ isolate, scriptId, frame: '', ts: 0 }));
     };
-    if (Types.Events.isTargetRundownEvent(event) && event.args.data) {
+    if (Types.Events.isRundownScriptCompiled(event) && event.args.data) {
         const { isolate, scriptId, frame } = event.args.data;
         const script = getOrMakeScript(isolate, scriptId);
         script.frame = frame;
         script.ts = event.ts;
         return;
     }
-    if (Types.Events.isV8SourceRundownEvent(event)) {
+    if (Types.Events.isRundownScript(event)) {
         const { isolate, scriptId, url, sourceUrl, sourceMapUrl, sourceMapUrlElided } = event.args.data;
         const script = getOrMakeScript(isolate, scriptId);
         script.url = url;
@@ -46,13 +46,13 @@ export function handleEvent(event) {
         }
         return;
     }
-    if (Types.Events.isV8SourceRundownSourcesScriptCatchupEvent(event)) {
+    if (Types.Events.isRundownScriptSource(event)) {
         const { isolate, scriptId, sourceText } = event.args.data;
         const script = getOrMakeScript(isolate, scriptId);
         script.content = sourceText;
         return;
     }
-    if (Types.Events.isV8SourceRundownSourcesLargeScriptCatchupEvent(event)) {
+    if (Types.Events.isRundownScriptSourceLarge(event)) {
         const { isolate, scriptId, sourceText } = event.args.data;
         const script = getOrMakeScript(isolate, scriptId);
         script.content = (script.content ?? '') + sourceText;

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/UserInteractionsHandler.js

@@ -4,13 +4,8 @@
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 import { data as metaHandlerData } from './MetaHandler.js';
-// This handler serves two purposes. It generates a list of events that are
-// used to show user clicks in the timeline. It is also used to gather
-// EventTimings into Interactions, which we use to show interactions and
-// highlight long interactions to the user, along with INP.
-// We don't need to know which process / thread these events occurred in,
-// because they are effectively global, so we just track all that we find.
-let allEvents = [];
+// This handler gathers EventTimings into Interactions, which we use to show
+// interactions and highlight long interactions to the user, along with INP.
 let beginCommitCompositorFrameEvents = [];
 let parseMetaViewportEvents = [];
 export const LONG_INTERACTION_THRESHOLD = Helpers.Timing.milliToMicro(Types.Timing.Milli(200));
@@ -22,7 +17,6 @@ let interactionEventsWithNoNesting = [];
 let eventTimingEndEventsById = new Map();
 let eventTimingStartEventsForInteractions = [];
 export function reset() {
-    allEvents = [];
     beginCommitCompositorFrameEvents = [];
     parseMetaViewportEvents = [];
     interactionEvents = [];
@@ -47,7 +41,6 @@ export function handleEvent(event) {
         // Store the end event; for each start event that is an interaction, we need the matching end event to calculate the duration correctly.
         eventTimingEndEventsById.set(event.id, event);
     }
-    allEvents.push(event);
     // From this point on we want to find events that represent interactions.
     // These events are always start events - those are the ones that contain all
     // the metadata about the interaction.
@@ -268,7 +261,6 @@ export async function finalize() {
 }
 export function data() {
     return {
-        allEvents,
         beginCommitCompositorFrameEvents,
         parseMetaViewportEvents,
         interactionEvents,