@mcp-b/chrome-devtools-mcp 2.1.0 → 2.2.0

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

@@ -1,259 +0,0 @@
-// 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) {
-        super(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) {
-                    // TODO(crbug.com/406991275): This should also grant the `STORAGE` capability, but first the
-                    // crashers in https://crbug.com/466134219 have to be resolved.
-                    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 */;
-                if (parentTarget?.type() !== Type.FRAME) {
-                    this.#capabilitiesMask |= 8192 /* Capability.STORAGE */;
-                }
-                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 */;
-                if (parentTarget?.type() !== Type.FRAME) {
-                    this.#capabilitiesMask |= 8192 /* Capability.STORAGE */;
-                }
-                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;
-    }
-    /** Creates the models in the order in which they are provided */
-    createModels(models) {
-        this.#creatingModels = true;
-        for (const model of models) {
-            this.model(model);
-        }
-        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() {
-        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/vendor/chrome-devtools-frontend/front_end/core/sdk/TargetManager.js

@@ -1,395 +0,0 @@
-// 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 { SDKModel } from './SDKModel.js';
-import { Target, Type as TargetType } from './Target.js';
-export class TargetManager extends Common.ObjectWrapper.ObjectWrapper {
-    /**
-     * @deprecated
-     *
-     * Intended for {@link SDKModel} classes to be able to retrieve scoped singletons like
-     * the "PageResourceLoader" or the "FrameManager".
-     *
-     * This is only an intermediate step to migrate towards our "layering vision" where
-     * SDKModels don't require things from the next layer.
-     */
-    context;
-    #targets;
-    #observers;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    #modelListeners;
-    #modelObservers;
-    #scopedObservers;
-    /* eslint-enable @typescript-eslint/no-explicit-any */
-    #isSuspended;
-    #browserTarget;
-    #scopeTarget;
-    #defaultScopeSet;
-    #scopeChangeListeners;
-    #overrideAutoStartModels;
-    /**
-     * @param overrideAutoStartModels If provided, then the `autostart` flag on {@link RegistrationInfo} will be ignored.
-     */
-    constructor(context, overrideAutoStartModels) {
-        super();
-        this.context = context;
-        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();
-        this.#overrideAutoStartModels = overrideAutoStartModels;
-    }
-    static instance({ forceNew } = { forceNew: false }) {
-        if (!Root.DevToolsContext.globalInstance().has(TargetManager) || forceNew) {
-            Root.DevToolsContext.globalInstance().set(TargetManager, new TargetManager(Root.DevToolsContext.globalInstance()));
-        }
-        return Root.DevToolsContext.globalInstance().get(TargetManager);
-    }
-    static removeInstance() {
-        Root.DevToolsContext.globalInstance().delete(TargetManager);
-    }
-    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);
-    }
-    /** @returns The set of models we create unconditionally for new targets in the order in which they should be created */
-    #autoStartModels() {
-        const earlyModels = new Set();
-        const models = new Set();
-        const shouldAutostart = (model, info) => this.#overrideAutoStartModels ? this.#overrideAutoStartModels.has(model) : info.autostart;
-        for (const [model, info] of SDKModel.registeredModels) {
-            if (info.early) {
-                earlyModels.add(model);
-            }
-            else if (shouldAutostart(model, info) || this.#modelObservers.has(model)) {
-                models.add(model);
-            }
-        }
-        return [...earlyModels, ...models];
-    }
-    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(this.#autoStartModels());
-        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;
-    }
-    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(this.#autoStartModels());
-        }
-        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;
-}