chrome-devtools-mcp 0.0.1 → 0.0.2

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/Target.js

@@ -0,0 +1,262 @@
+// Copyright 2021 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 '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+import { SDKModel } from './SDKModel.js';
+export class Target extends ProtocolClient.InspectorBackend.TargetBase {
+    #targetManager;
+    #name;
+    #inspectedURL = Platform.DevToolsPath.EmptyUrlString;
+    #inspectedURLName = '';
+    #capabilitiesMask;
+    #type;
+    #parentTarget;
+    #id;
+    #modelByConstructor = new Map();
+    #isSuspended;
+    /**
+     * Generally when a target crashes we don't need to know, with one exception.
+     * If a target crashes during the recording of a performance trace, after the
+     * trace when we try to resume() it, it will fail because it has crashed. This
+     * causes the performance panel to freeze (see crbug.com/333989070). So we
+     * mark the target as crashed so we can exit without trying to resume it. In
+     * `ChildTargetManager` we will mark a target as "un-crashed" when we get the
+     * `targetInfoChanged` event. This helps ensure we can deal with cases where
+     * the page crashes, but a reload fixes it and the targets get restored (see
+     * crbug.com/387258086).
+     */
+    #hasCrashed = false;
+    #targetInfo;
+    #creatingModels;
+    constructor(targetManager, id, name, type, parentTarget, sessionId, suspended, connection, targetInfo) {
+        const needsNodeJSPatching = type === Type.NODE;
+        super(needsNodeJSPatching, parentTarget, sessionId, connection);
+        this.#targetManager = targetManager;
+        this.#name = name;
+        this.#capabilitiesMask = 0;
+        switch (type) {
+            case Type.FRAME:
+                this.#capabilitiesMask = 1 /* Capability.BROWSER */ | 8192 /* Capability.STORAGE */ | 2 /* Capability.DOM */ | 4 /* Capability.JS */ |
+                    8 /* Capability.LOG */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ | 128 /* Capability.TRACING */ | 256 /* Capability.EMULATION */ |
+                    1024 /* Capability.INPUT */ | 2048 /* Capability.INSPECTOR */ | 32768 /* Capability.AUDITS */ | 65536 /* Capability.WEB_AUTHN */ | 131072 /* Capability.IO */ |
+                    262144 /* Capability.MEDIA */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                if (parentTarget?.type() !== Type.FRAME) {
+                    // This matches backend exposing certain capabilities only for the main frame.
+                    this.#capabilitiesMask |=
+                        4096 /* Capability.DEVICE_EMULATION */ | 64 /* Capability.SCREEN_CAPTURE */ | 512 /* Capability.SECURITY */ | 16384 /* Capability.SERVICE_WORKER */;
+                    if (Common.ParsedURL.schemeIs(targetInfo?.url, 'chrome-extension:')) {
+                        this.#capabilitiesMask &= ~512 /* Capability.SECURITY */;
+                    }
+                    // TODO(dgozman): we report service workers for the whole frame tree on the main frame,
+                    // while we should be able to only cover the subtree corresponding to the target.
+                }
+                break;
+            case Type.ServiceWorker:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 8 /* Capability.LOG */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ |
+                    2048 /* Capability.INSPECTOR */ | 131072 /* Capability.IO */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                if (parentTarget?.type() !== Type.FRAME) {
+                    this.#capabilitiesMask |= 1 /* Capability.BROWSER */;
+                }
+                break;
+            case Type.SHARED_WORKER:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 8 /* Capability.LOG */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ |
+                    131072 /* Capability.IO */ | 262144 /* Capability.MEDIA */ | 2048 /* Capability.INSPECTOR */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                break;
+            case Type.SHARED_STORAGE_WORKLET:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 8 /* Capability.LOG */ | 2048 /* Capability.INSPECTOR */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                break;
+            case Type.Worker:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 8 /* Capability.LOG */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ |
+                    131072 /* Capability.IO */ | 262144 /* Capability.MEDIA */ | 256 /* Capability.EMULATION */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                break;
+            case Type.WORKLET:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 8 /* Capability.LOG */ | 524288 /* Capability.EVENT_BREAKPOINTS */ | 16 /* Capability.NETWORK */;
+                break;
+            case Type.NODE:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ | 131072 /* Capability.IO */;
+                break;
+            case Type.AUCTION_WORKLET:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 524288 /* Capability.EVENT_BREAKPOINTS */;
+                break;
+            case Type.BROWSER:
+                this.#capabilitiesMask = 32 /* Capability.TARGET */ | 131072 /* Capability.IO */;
+                break;
+            case Type.TAB:
+                this.#capabilitiesMask = 32 /* Capability.TARGET */ | 128 /* Capability.TRACING */;
+                break;
+            case Type.NODE_WORKER:
+                this.#capabilitiesMask = 4 /* Capability.JS */ | 16 /* Capability.NETWORK */ | 32 /* Capability.TARGET */ | 131072 /* Capability.IO */;
+        }
+        this.#type = type;
+        this.#parentTarget = parentTarget;
+        this.#id = id;
+        this.#isSuspended = suspended;
+        this.#targetInfo = targetInfo;
+    }
+    createModels(required) {
+        this.#creatingModels = true;
+        const registeredModels = Array.from(SDKModel.registeredModels.entries());
+        // Create early models.
+        for (const [modelClass, info] of registeredModels) {
+            if (info.early) {
+                this.model(modelClass);
+            }
+        }
+        // Create autostart and required models.
+        for (const [modelClass, info] of registeredModels) {
+            if (info.autostart || required.has(modelClass)) {
+                this.model(modelClass);
+            }
+        }
+        this.#creatingModels = false;
+    }
+    id() {
+        return this.#id;
+    }
+    name() {
+        return this.#name || this.#inspectedURLName;
+    }
+    setName(name) {
+        if (this.#name === name) {
+            return;
+        }
+        this.#name = name;
+        this.#targetManager.onNameChange(this);
+    }
+    type() {
+        return this.#type;
+    }
+    markAsNodeJSForTest() {
+        super.markAsNodeJSForTest();
+        this.#type = Type.NODE;
+    }
+    targetManager() {
+        return this.#targetManager;
+    }
+    hasAllCapabilities(capabilitiesMask) {
+        // TODO(dgozman): get rid of this method, once we never observe targets with
+        // capability mask.
+        return (this.#capabilitiesMask & capabilitiesMask) === capabilitiesMask;
+    }
+    decorateLabel(label) {
+        return (this.#type === Type.Worker || this.#type === Type.ServiceWorker) ? '\u2699 ' + label : label;
+    }
+    parentTarget() {
+        return this.#parentTarget;
+    }
+    outermostTarget() {
+        let lastTarget = null;
+        let currentTarget = this;
+        do {
+            if (currentTarget.type() !== Type.TAB && currentTarget.type() !== Type.BROWSER) {
+                lastTarget = currentTarget;
+            }
+            currentTarget = currentTarget.parentTarget();
+        } while (currentTarget);
+        return lastTarget;
+    }
+    dispose(reason) {
+        super.dispose(reason);
+        this.#targetManager.removeTarget(this);
+        for (const model of this.#modelByConstructor.values()) {
+            model.dispose();
+        }
+    }
+    model(modelClass) {
+        if (!this.#modelByConstructor.get(modelClass)) {
+            const info = SDKModel.registeredModels.get(modelClass);
+            if (info === undefined) {
+                throw new Error('Model class is not registered');
+            }
+            if ((this.#capabilitiesMask & info.capabilities) === info.capabilities) {
+                const model = new modelClass(this);
+                this.#modelByConstructor.set(modelClass, model);
+                if (!this.#creatingModels) {
+                    this.#targetManager.modelAdded(modelClass, model, this.#targetManager.isInScope(this));
+                }
+            }
+        }
+        return this.#modelByConstructor.get(modelClass) || null;
+    }
+    models() {
+        return this.#modelByConstructor;
+    }
+    inspectedURL() {
+        return this.#inspectedURL;
+    }
+    setInspectedURL(inspectedURL) {
+        this.#inspectedURL = inspectedURL;
+        const parsedURL = Common.ParsedURL.ParsedURL.fromString(inspectedURL);
+        this.#inspectedURLName = parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + this.#id;
+        this.#targetManager.onInspectedURLChange(this);
+        if (!this.#name) {
+            this.#targetManager.onNameChange(this);
+        }
+    }
+    hasCrashed() {
+        return this.#hasCrashed;
+    }
+    setHasCrashed(isCrashed) {
+        const wasCrashed = this.#hasCrashed;
+        this.#hasCrashed = isCrashed;
+        // If the target has now been restored, check to see if it needs resuming.
+        // This ensures that if a target crashes whilst suspended, it is resumed
+        // when it is recovered.
+        // If the target is not suspended, resume() is a no-op, so it's safe to call.
+        if (wasCrashed && !isCrashed) {
+            void this.resume();
+        }
+    }
+    async suspend(reason) {
+        if (this.#isSuspended) {
+            return;
+        }
+        this.#isSuspended = true;
+        // If the target has crashed, we will not attempt to suspend all the
+        // models, but we still mark it as suspended so we correctly track the
+        // state.
+        if (this.#hasCrashed) {
+            return;
+        }
+        await Promise.all(Array.from(this.models().values(), m => m.preSuspendModel(reason)));
+        await Promise.all(Array.from(this.models().values(), m => m.suspendModel(reason)));
+    }
+    async resume() {
+        if (!this.#isSuspended) {
+            return;
+        }
+        this.#isSuspended = false;
+        if (this.#hasCrashed) {
+            return;
+        }
+        await Promise.all(Array.from(this.models().values(), m => m.resumeModel()));
+        await Promise.all(Array.from(this.models().values(), m => m.postResumeModel()));
+    }
+    suspended() {
+        return this.#isSuspended;
+    }
+    updateTargetInfo(targetInfo) {
+        this.#targetInfo = targetInfo;
+    }
+    targetInfo() {
+        return this.#targetInfo;
+    }
+}
+export var Type;
+(function (Type) {
+    Type["FRAME"] = "frame";
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+    Type["ServiceWorker"] = "service-worker";
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+    Type["Worker"] = "worker";
+    Type["SHARED_WORKER"] = "shared-worker";
+    Type["SHARED_STORAGE_WORKLET"] = "shared-storage-worklet";
+    Type["NODE"] = "node";
+    Type["BROWSER"] = "browser";
+    Type["AUCTION_WORKLET"] = "auction-worklet";
+    Type["WORKLET"] = "worklet";
+    Type["TAB"] = "tab";
+    Type["NODE_WORKER"] = "node-worker";
+})(Type || (Type = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/TargetManager.js

@@ -0,0 +1,382 @@
+// Copyright 2021 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 '../common/common.js';
+import * as Host from '../host/host.js';
+import * as Platform from '../platform/platform.js';
+import { assertNotNullOrUndefined } from '../platform/platform.js';
+import * as Root from '../root/root.js';
+import { StubConnection } from './Connections.js';
+import { RehydratingConnection } from './RehydratingConnection.js';
+import { SDKModel } from './SDKModel.js';
+import { Target, Type as TargetType } from './Target.js';
+let targetManagerInstance;
+export class TargetManager extends Common.ObjectWrapper.ObjectWrapper {
+    #targets;
+    #observers;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    #modelListeners;
+    #modelObservers;
+    #scopedObservers;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    #isSuspended;
+    #browserTarget;
+    #scopeTarget;
+    #defaultScopeSet;
+    #scopeChangeListeners;
+    constructor() {
+        super();
+        this.#targets = new Set();
+        this.#observers = new Set();
+        this.#modelListeners = new Platform.MapUtilities.Multimap();
+        this.#modelObservers = new Platform.MapUtilities.Multimap();
+        this.#isSuspended = false;
+        this.#browserTarget = null;
+        this.#scopeTarget = null;
+        this.#scopedObservers = new WeakSet();
+        this.#defaultScopeSet = false;
+        this.#scopeChangeListeners = new Set();
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!targetManagerInstance || forceNew) {
+            targetManagerInstance = new TargetManager();
+        }
+        return targetManagerInstance;
+    }
+    static removeInstance() {
+        targetManagerInstance = undefined;
+    }
+    onInspectedURLChange(target) {
+        if (target !== this.#scopeTarget) {
+            return;
+        }
+        Host.InspectorFrontendHost.InspectorFrontendHostInstance.inspectedURLChanged(target.inspectedURL() || Platform.DevToolsPath.EmptyUrlString);
+        this.dispatchEventToListeners("InspectedURLChanged" /* Events.INSPECTED_URL_CHANGED */, target);
+    }
+    onNameChange(target) {
+        this.dispatchEventToListeners("NameChanged" /* Events.NAME_CHANGED */, target);
+    }
+    async suspendAllTargets(reason) {
+        if (this.#isSuspended) {
+            return;
+        }
+        this.#isSuspended = true;
+        this.dispatchEventToListeners("SuspendStateChanged" /* Events.SUSPEND_STATE_CHANGED */);
+        const suspendPromises = Array.from(this.#targets.values(), target => target.suspend(reason));
+        await Promise.all(suspendPromises);
+    }
+    async resumeAllTargets() {
+        if (!this.#isSuspended) {
+            return;
+        }
+        this.#isSuspended = false;
+        this.dispatchEventToListeners("SuspendStateChanged" /* Events.SUSPEND_STATE_CHANGED */);
+        const resumePromises = Array.from(this.#targets.values(), target => target.resume());
+        await Promise.all(resumePromises);
+    }
+    allTargetsSuspended() {
+        return this.#isSuspended;
+    }
+    models(modelClass, opts) {
+        const result = [];
+        for (const target of this.#targets) {
+            if (opts?.scoped && !this.isInScope(target)) {
+                continue;
+            }
+            const model = target.model(modelClass);
+            if (!model) {
+                continue;
+            }
+            result.push(model);
+        }
+        return result;
+    }
+    inspectedURL() {
+        const mainTarget = this.primaryPageTarget();
+        return mainTarget ? mainTarget.inspectedURL() : '';
+    }
+    observeModels(modelClass, observer, opts) {
+        const models = this.models(modelClass, opts);
+        this.#modelObservers.set(modelClass, observer);
+        if (opts?.scoped) {
+            this.#scopedObservers.add(observer);
+        }
+        for (const model of models) {
+            observer.modelAdded(model);
+        }
+    }
+    unobserveModels(modelClass, observer) {
+        this.#modelObservers.delete(modelClass, observer);
+        this.#scopedObservers.delete(observer);
+    }
+    modelAdded(modelClass, model, inScope) {
+        for (const observer of this.#modelObservers.get(modelClass).values()) {
+            if (!this.#scopedObservers.has(observer) || inScope) {
+                observer.modelAdded(model);
+            }
+        }
+    }
+    modelRemoved(modelClass, model, inScope) {
+        for (const observer of this.#modelObservers.get(modelClass).values()) {
+            if (!this.#scopedObservers.has(observer) || inScope) {
+                observer.modelRemoved(model);
+            }
+        }
+    }
+    addModelListener(modelClass, eventType, listener, thisObject, opts) {
+        const wrappedListener = (event) => {
+            if (!opts?.scoped || this.isInScope(event)) {
+                listener.call(thisObject, event);
+            }
+        };
+        for (const model of this.models(modelClass)) {
+            model.addEventListener(eventType, wrappedListener);
+        }
+        this.#modelListeners.set(eventType, { modelClass, thisObject, listener, wrappedListener });
+    }
+    removeModelListener(modelClass, eventType, listener, thisObject) {
+        if (!this.#modelListeners.has(eventType)) {
+            return;
+        }
+        let wrappedListener = null;
+        for (const info of this.#modelListeners.get(eventType)) {
+            if (info.modelClass === modelClass && info.listener === listener && info.thisObject === thisObject) {
+                wrappedListener = info.wrappedListener;
+                this.#modelListeners.delete(eventType, info);
+            }
+        }
+        if (wrappedListener) {
+            for (const model of this.models(modelClass)) {
+                model.removeEventListener(eventType, wrappedListener);
+            }
+        }
+    }
+    observeTargets(targetObserver, opts) {
+        if (this.#observers.has(targetObserver)) {
+            throw new Error('Observer can only be registered once');
+        }
+        if (opts?.scoped) {
+            this.#scopedObservers.add(targetObserver);
+        }
+        for (const target of this.#targets) {
+            if (!opts?.scoped || this.isInScope(target)) {
+                targetObserver.targetAdded(target);
+            }
+        }
+        this.#observers.add(targetObserver);
+    }
+    unobserveTargets(targetObserver) {
+        this.#observers.delete(targetObserver);
+        this.#scopedObservers.delete(targetObserver);
+    }
+    createTarget(id, name, type, parentTarget, sessionId, waitForDebuggerInPage, connection, targetInfo) {
+        const target = new Target(this, id, name, type, parentTarget, sessionId || '', this.#isSuspended, connection || null, targetInfo);
+        if (waitForDebuggerInPage) {
+            void target.pageAgent().invoke_waitForDebugger();
+        }
+        target.createModels(new Set(this.#modelObservers.keysArray()));
+        this.#targets.add(target);
+        const inScope = this.isInScope(target);
+        // Iterate over a copy. #observers might be modified during iteration.
+        for (const observer of [...this.#observers]) {
+            if (!this.#scopedObservers.has(observer) || inScope) {
+                observer.targetAdded(target);
+            }
+        }
+        for (const [modelClass, model] of target.models().entries()) {
+            this.modelAdded(modelClass, model, inScope);
+        }
+        for (const key of this.#modelListeners.keysArray()) {
+            for (const info of this.#modelListeners.get(key)) {
+                const model = target.model(info.modelClass);
+                if (model) {
+                    model.addEventListener(key, info.wrappedListener);
+                }
+            }
+        }
+        if ((target === target.outermostTarget() &&
+            (target.type() !== TargetType.FRAME || target === this.primaryPageTarget())) &&
+            !this.#defaultScopeSet) {
+            this.setScopeTarget(target);
+        }
+        return target;
+    }
+    removeTarget(target) {
+        if (!this.#targets.has(target)) {
+            return;
+        }
+        const inScope = this.isInScope(target);
+        this.#targets.delete(target);
+        for (const modelClass of target.models().keys()) {
+            const model = target.models().get(modelClass);
+            assertNotNullOrUndefined(model);
+            this.modelRemoved(modelClass, model, inScope);
+        }
+        // Iterate over a copy. #observers might be modified during iteration.
+        for (const observer of [...this.#observers]) {
+            if (!this.#scopedObservers.has(observer) || inScope) {
+                observer.targetRemoved(target);
+            }
+        }
+        for (const key of this.#modelListeners.keysArray()) {
+            for (const info of this.#modelListeners.get(key)) {
+                const model = target.model(info.modelClass);
+                if (model) {
+                    model.removeEventListener(key, info.wrappedListener);
+                }
+            }
+        }
+    }
+    targets() {
+        return [...this.#targets];
+    }
+    targetById(id) {
+        // TODO(dgozman): add a map #id -> #target.
+        return this.targets().find(target => target.id() === id) || null;
+    }
+    rootTarget() {
+        if (this.#targets.size === 0) {
+            return null;
+        }
+        return this.#targets.values().next().value ?? null;
+    }
+    primaryPageTarget() {
+        let target = this.rootTarget();
+        if (target?.type() === TargetType.TAB) {
+            target =
+                this.targets().find(t => t.parentTarget() === target && t.type() === TargetType.FRAME && !t.targetInfo()?.subtype?.length) ||
+                    null;
+        }
+        return target;
+    }
+    browserTarget() {
+        return this.#browserTarget;
+    }
+    /**
+     * If this returns true, the target is not connected to a legit CDP server.
+     * However, it's not exhaustive, so some `false` responses may be misleading.
+     *    (eg., tab URL of `devtools://devtools/bundled/devtools_app.html` uses a MainConnection but has no CDP server behind it).
+     */
+    hasFakeConnection() {
+        // There _may_ be a race condition hiding here on the router/connection creation.
+        // So we play it safe and consider "no connection yet" as "not fake".
+        const connection = this.primaryPageTarget()?.router()?.connection();
+        if (!connection) {
+            return false;
+        }
+        const isFakeConnection = (connection instanceof StubConnection) || (connection instanceof RehydratingConnection);
+        return isFakeConnection;
+    }
+    async maybeAttachInitialTarget() {
+        if (!Boolean(Root.Runtime.Runtime.queryParam('browserConnection'))) {
+            return false;
+        }
+        if (!this.#browserTarget) {
+            this.#browserTarget = new Target(this, /* #id*/ 'main', /* #name*/ 'browser', TargetType.BROWSER, /* #parentTarget*/ null, 
+            /* #sessionId */ '', /* suspended*/ false, /* #connection*/ null, /* targetInfo*/ undefined);
+            this.#browserTarget.createModels(new Set(this.#modelObservers.keysArray()));
+        }
+        const targetId = await Host.InspectorFrontendHost.InspectorFrontendHostInstance.initialTargetId();
+        // Do not await for Target.autoAttachRelated to return, as it goes throguh the renderer and we don't want to block early
+        // at front-end initialization if a renderer is stuck. The rest of #target discovery and auto-attach process should happen
+        // asynchronously upon Target.attachedToTarget.
+        void this.#browserTarget.targetAgent().invoke_autoAttachRelated({
+            targetId,
+            waitForDebuggerOnStart: true,
+        });
+        return true;
+    }
+    clearAllTargetsForTest() {
+        this.#targets.clear();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isInScope(arg) {
+        if (!arg) {
+            return false;
+        }
+        if (isSDKModelEvent(arg)) {
+            arg = arg.source;
+        }
+        if (arg instanceof SDKModel) {
+            arg = arg.target();
+        }
+        while (arg && arg !== this.#scopeTarget) {
+            arg = arg.parentTarget();
+        }
+        return Boolean(arg) && arg === this.#scopeTarget;
+    }
+    // Sets a root of a scope substree.
+    // TargetManager API invoked with `scoped: true` will behave as if targets
+    // outside of the scope subtree don't exist. Concretely this means that
+    // target observers, model observers and model listeners won't be invoked for targets outside of the
+    // scope tree. This method will invoke targetRemoved and modelRemoved for
+    // objects in the previous scope, as if they disappear and then will invoke
+    // targetAdded and modelAdded as if they just appeared.
+    // Note that scopeTarget could be null, which will effectively prevent scoped
+    // observes from getting any events.
+    setScopeTarget(scopeTarget) {
+        if (scopeTarget === this.#scopeTarget) {
+            return;
+        }
+        for (const target of this.targets()) {
+            if (!this.isInScope(target)) {
+                continue;
+            }
+            for (const modelClass of this.#modelObservers.keysArray()) {
+                const model = target.models().get(modelClass);
+                if (!model) {
+                    continue;
+                }
+                for (const observer of [...this.#modelObservers.get(modelClass)].filter(o => this.#scopedObservers.has(o))) {
+                    observer.modelRemoved(model);
+                }
+            }
+            // Iterate over a copy. #observers might be modified during iteration.
+            for (const observer of [...this.#observers].filter(o => this.#scopedObservers.has(o))) {
+                observer.targetRemoved(target);
+            }
+        }
+        this.#scopeTarget = scopeTarget;
+        for (const target of this.targets()) {
+            if (!this.isInScope(target)) {
+                continue;
+            }
+            for (const observer of [...this.#observers].filter(o => this.#scopedObservers.has(o))) {
+                observer.targetAdded(target);
+            }
+            for (const [modelClass, model] of target.models().entries()) {
+                for (const observer of [...this.#modelObservers.get(modelClass)].filter(o => this.#scopedObservers.has(o))) {
+                    observer.modelAdded(model);
+                }
+            }
+        }
+        for (const scopeChangeListener of this.#scopeChangeListeners) {
+            scopeChangeListener();
+        }
+        if (scopeTarget?.inspectedURL()) {
+            this.onInspectedURLChange(scopeTarget);
+        }
+    }
+    addScopeChangeListener(listener) {
+        this.#scopeChangeListeners.add(listener);
+    }
+    scopeTarget() {
+        return this.#scopeTarget;
+    }
+}
+export class Observer {
+    targetAdded(_target) {
+    }
+    targetRemoved(_target) {
+    }
+}
+export class SDKModelObserver {
+    modelAdded(_model) {
+    }
+    modelRemoved(_model) {
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isSDKModelEvent(arg) {
+    return 'source' in arg && arg.source instanceof SDKModel;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/TraceObject.js

@@ -0,0 +1,49 @@
+// Copyright 2024 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';
+import { ResourceTreeModel } from './ResourceTreeModel.js';
+// A thin wrapper class, mostly to enable instanceof-based revealing of traces to open in Timeline.
+export class TraceObject {
+    traceEvents;
+    metadata;
+    constructor(traceEvents, metadata = {}) {
+        this.traceEvents = traceEvents;
+        this.metadata = metadata;
+    }
+}
+// Another thin wrapper class to enable revealing individual trace events (aka entries) in Timeline panel.
+export class RevealableEvent {
+    event;
+    // Only Trace.Types.Events.Event are passed in, but we can't depend on that type from SDK
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    constructor(event) {
+        this.event = event;
+    }
+}
+/**
+ * Another wrapper class for revealing network requests in Network panel. The reason is the `Open in Network panel`
+ * option is handled by the context menu provider, which will add this option for all supporting types. And there are a
+ * lot of context menu providers that support `SDK.NetworkRequest.NetworkRequest`, for example `Override content` by
+ * PersistenceActions, but we so far just want the one to reveal in network panel, so add a new class which will only be
+ * supported by Network panel.
+ *
+ * Also we want to have a different behavior(select the network request) from the `SDK.NetworkRequest.NetworkRequest`
+ * (highlight the network request once).
+ */
+export class RevealableNetworkRequest {
+    networkRequest;
+    constructor(networkRequest) {
+        this.networkRequest = networkRequest;
+    }
+    // Only Trace.Types.Events.SyntheticNetworkRequest are passed in, but we can't depend on that type from SDK
+    static create(event) {
+        const syntheticNetworkRequest = event;
+        // @ts-expect-error We don't have type checking here to confirm these events have .args.data.url.
+        const url = syntheticNetworkRequest.args.data.url;
+        const urlWithoutHash = Common.ParsedURL.ParsedURL.urlWithoutHash(url);
+        const resource = ResourceTreeModel.resourceForURL(url) ?? ResourceTreeModel.resourceForURL(urlWithoutHash);
+        const sdkNetworkRequest = resource?.request;
+        return sdkNetworkRequest ? new RevealableNetworkRequest(sdkNetworkRequest) : null;
+    }
+}