chrome-devtools-mcp 0.10.1 → 0.11.0

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

@@ -4,7 +4,7 @@
 import * as Common from '../common/common.js';
 import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
-import { FrameManager } from './FrameManager.js';
+import * as Root from '../root/root.js';
 import { IOModel } from './IOModel.js';
 import { MultitargetNetworkManager, NetworkManager } from './NetworkManager.js';
 import { Events as ResourceTreeModelEvents, ResourceTreeModel, } from './ResourceTreeModel.js';
@@ -27,37 +27,41 @@ export class ResourceKey {
         this.key = key;
     }
 }
-let pageResourceLoader = null;
 /**
  * The page resource loader is a bottleneck for all DevTools-initiated resource loads. For each such load, it keeps a
  * `PageResource` object around that holds meta information. This can be as the basis for reporting to the user which
  * resources were loaded, and whether there was a load error.
  */
 export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
+    #targetManager;
+    #settings;
+    #userAgentProvider;
     #currentlyLoading = 0;
     #currentlyLoadingPerTarget = new Map();
     #maxConcurrentLoads;
     #pageResources = new Map();
     #queuedLoads = [];
     #loadOverride;
-    constructor(loadOverride, maxConcurrentLoads) {
+    constructor(targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads = 500) {
         super();
+        this.#targetManager = targetManager;
+        this.#settings = settings;
+        this.#userAgentProvider = userAgentProvider;
         this.#maxConcurrentLoads = maxConcurrentLoads;
-        TargetManager.instance().addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
+        this.#targetManager.addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
         this.#loadOverride = loadOverride;
     }
-    static instance({ forceNew, loadOverride, maxConcurrentLoads } = {
+    static instance({ forceNew, targetManager, settings, userAgentProvider, loadOverride, maxConcurrentLoads } = {
         forceNew: false,
         loadOverride: null,
-        maxConcurrentLoads: 500,
     }) {
-        if (!pageResourceLoader || forceNew) {
-            pageResourceLoader = new PageResourceLoader(loadOverride, maxConcurrentLoads);
+        if (forceNew) {
+            Root.DevToolsContext.globalInstance().set(PageResourceLoader, new PageResourceLoader(targetManager ?? TargetManager.instance(), settings ?? Common.Settings.Settings.instance(), userAgentProvider ?? MultitargetNetworkManager.instance(), loadOverride, maxConcurrentLoads));
         }
-        return pageResourceLoader;
+        return Root.DevToolsContext.globalInstance().get(PageResourceLoader);
     }
     static removeInstance() {
-        pageResourceLoader = null;
+        Root.DevToolsContext.globalInstance().delete(PageResourceLoader);
     }
     onPrimaryPageChanged(event) {
         const { frame: mainFrame, type } = event.data;
@@ -85,7 +89,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
         return this.#pageResources;
     }
     getScopedResourcesLoaded() {
-        return new Map([...this.#pageResources].filter(([_, pageResource]) => TargetManager.instance().isInScope(pageResource.initiator.target) ||
+        return new Map([...this.#pageResources].filter(([_, pageResource]) => this.#targetManager.isInScope(pageResource.initiator.target) ||
             isExtensionInitiator(pageResource.initiator)));
     }
     /**
@@ -97,11 +101,10 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
         return { loading: this.#currentlyLoading, queued: this.#queuedLoads.length, resources: this.#pageResources.size };
     }
     getScopedNumberOfResources() {
-        const targetManager = TargetManager.instance();
         let loadingCount = 0;
         for (const [targetId, count] of this.#currentlyLoadingPerTarget) {
-            const target = targetManager.targetById(targetId);
-            if (targetManager.isInScope(target)) {
+            const target = this.#targetManager.targetById(targetId);
+            if (this.#targetManager.isInScope(target)) {
                 loadingCount += count;
             }
         }
@@ -197,22 +200,15 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             return await this.#loadOverride(url);
         }
         const parsedURL = new Common.ParsedURL.ParsedURL(url);
-        const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.scheme !== 'file' &&
-            parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools';
+        const eligibleForLoadFromTarget = this.getLoadThroughTargetSetting().get() && parsedURL &&
+            parsedURL.scheme !== 'file' && parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools' &&
+            initiator.target;
         Host.userMetrics.developerResourceScheme(this.getDeveloperResourceScheme(parsedURL));
         if (eligibleForLoadFromTarget) {
             try {
-                if (initiator.target) {
-                    Host.userMetrics.developerResourceLoaded(0 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET */);
-                    const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
-                    return result;
-                }
-                const frame = FrameManager.instance().getFrame(initiator.frameId);
-                if (frame) {
-                    Host.userMetrics.developerResourceLoaded(1 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_FRAME */);
-                    const result = await this.loadFromTarget(frame.resourceTreeModel().target(), initiator.frameId, url, isBinary);
-                    return result;
-                }
+                Host.userMetrics.developerResourceLoaded(0 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET */);
+                const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
+                return result;
             }
             catch (e) {
                 if (e instanceof Error) {
@@ -229,12 +225,12 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             Host.userMetrics.developerResourceLoaded(3 /* Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FALLBACK */);
         }
         else {
-            const code = getLoadThroughTargetSetting().get() ?
+            const code = this.getLoadThroughTargetSetting().get() ?
                 6 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_PROTOCOL */ :
                 5 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_OVERRIDE */;
             Host.userMetrics.developerResourceLoaded(code);
         }
-        const result = await MultitargetNetworkManager.instance().loadResource(url);
+        const result = await this.loadFromHostBindings(url);
         if (eligibleForLoadFromTarget && !result.success) {
             Host.userMetrics.developerResourceLoaded(7 /* Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_FAILURE */);
         }
@@ -269,7 +265,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
     async loadFromTarget(target, frameId, url, isBinary) {
         const networkManager = target.model(NetworkManager);
         const ioModel = target.model(IOModel);
-        const disableCache = Common.Settings.Settings.instance().moduleSetting('cache-disabled').get();
+        const disableCache = this.#settings.moduleSetting('cache-disabled').get();
         const resource = await networkManager.loadNetworkResource(frameId, url, { disableCache, includeCredentials: true });
         try {
             const content = resource.stream ?
@@ -294,7 +290,21 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper {
             }
         }
     }
-}
-export function getLoadThroughTargetSetting() {
-    return Common.Settings.Settings.instance().createSetting('load-through-target', true);
+    async loadFromHostBindings(url) {
+        const headers = {};
+        const currentUserAgent = this.#userAgentProvider.currentUserAgent();
+        if (currentUserAgent) {
+            headers['User-Agent'] = currentUserAgent;
+        }
+        if (this.#settings.moduleSetting('cache-disabled').get()) {
+            headers['Cache-Control'] = 'no-cache';
+        }
+        const allowRemoteFilePaths = this.#settings.moduleSetting('network.enable-remote-file-loading').get();
+        return await new Promise(resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {
+            resolve({ success, content, errorDescription });
+        }, allowRemoteFilePaths));
+    }
+    getLoadThroughTargetSetting() {
+        return this.#settings.createSetting('load-through-target', true);
+    }
 }

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

@@ -25,7 +25,7 @@ export class PreloadingModel extends SDKModel {
         this.agent = target.preloadAgent();
         void this.agent.invoke_enable();
         const targetInfo = target.targetInfo();
-        if (targetInfo !== undefined && targetInfo.subtype === 'prerender') {
+        if (targetInfo?.subtype === 'prerender') {
             this.lastPrimaryPageModel = TargetManager.instance().primaryPageTarget()?.model(PreloadingModel) || null;
         }
         TargetManager.instance().addModelListener(ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);

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

@@ -665,6 +665,9 @@ export class LocalJSONObject extends RemoteObject {
         if (this.#value instanceof Date) {
             return 'date';
         }
+        if (this.#value instanceof Error) {
+            return 'error';
+        }
         return undefined;
     }
     get hasChildren() {
@@ -764,7 +767,7 @@ export class RemoteArray {
         this.#object = object;
     }
     static objectAsArray(object) {
-        if (!object || object.type !== 'object' || (object.subtype !== 'array' && object.subtype !== 'typedarray')) {
+        if (object?.type !== 'object' || (object.subtype !== 'array' && object.subtype !== 'typedarray')) {
             throw new Error('Object is empty or not an array');
         }
         return new RemoteArray(object);

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

@@ -722,7 +722,7 @@ export class ResourceTreeFrame {
     }
     addRequest(request) {
         let resource = this.resourcesMap.get(request.url());
-        if (resource && resource.request === request) {
+        if (resource?.request === request) {
             // Already in the tree, we just got an extra update.
             return;
         }

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

@@ -1,6 +1,31 @@
 // 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.
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import * as Platform from '../../core/platform/platform.js';
 import * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as Common from '../common/common.js';
 import * as i18n from '../i18n/i18n.js';
@@ -366,7 +391,7 @@ function frameIdForScript(script) {
 }
 export const sourceURLRegex = /^[\x20\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/;
 export async function disassembleWasm(content) {
-    const worker = Common.Worker.WorkerWrapper.fromURL(new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url));
+    const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url).toString());
     const promise = new Promise((resolve, reject) => {
         worker.onmessage = ({ data }) => {
             if ('method' in data) {

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

@@ -28,6 +28,9 @@ export class ServerSentEventsParser {
     async addBase64Chunk(raw) {
         await this.#decoder.addBase64Chunk(raw);
     }
+    addTextChunk(chunk) {
+        this.#onTextChunk(chunk);
+    }
     #onTextChunk(chunk) {
         // A line consists of "this.#line" plus a slice of "chunk[start:<next new cr/lf>]".
         let start = 0;

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

@@ -609,6 +609,10 @@ export class SourceMap {
         this.#ensureSourceMapProcessed();
         return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
     }
+    findOriginalFunctionScope(position) {
+        this.#ensureSourceMapProcessed();
+        return this.#scopesInfo?.findOriginalFunctionScope(position) ?? null;
+    }
     isOutlinedFrame(generatedLine, generatedColumn) {
         this.#ensureSourceMapProcessed();
         return this.#scopesInfo?.isOutlinedFrame(generatedLine, generatedColumn) ?? false;

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

@@ -5,6 +5,10 @@
 export class SourceMapCache {
     static #INSTANCE = new SourceMapCache('devtools-source-map-cache');
     static instance() {
+        if (typeof window === 'undefined') {
+            // TODO(crbug.com/451502260): Move this behind a `HostRuntime` interface.
+            return IN_MEMORY_INSTANCE; // TS doesn't like that our in-memory class doesn't have the same private fields.
+        }
         return this.#INSTANCE;
     }
     static createForTest(name) {
@@ -39,3 +43,15 @@ export class SourceMapCache {
         await window.caches.delete(this.#name);
     }
 }
+const IN_MEMORY_INSTANCE = new (class {
+    #cache = new Map();
+    async set(debugId, sourceMap) {
+        this.#cache.set(debugId, sourceMap);
+    }
+    async get(debugId) {
+        return this.#cache.get(debugId) ?? null;
+    }
+    async disposeForTest() {
+        // Do nothing.
+    }
+})();

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

@@ -89,8 +89,14 @@ export class SourceMapManager extends Common.ObjectWrapper.ObjectWrapper {
                 if (this.#attachingClient === client) {
                     this.#attachingClient = null;
                     const initiator = client.createPageResourceLoadInitiator();
+                    // TODO(crbug.com/458180550): Pass PageResourceLoader via constructor.
+                    //     The reason we grab it here lazily from the context is that otherwise every
+                    //     unit test using `createTarget` would need to set up a `PageResourceLoader`, as
+                    //     CSSModel and DebuggerModel are autostarted by default, and they create a
+                    //     SourceMapManager in their respective constructors.
+                    const resourceLoader = this.#target.targetManager().context.get(PageResourceLoader);
                     clientData.sourceMapPromise =
-                        loadSourceMap(sourceMapURL, client.debugId(), initiator)
+                        loadSourceMap(resourceLoader, sourceMapURL, client.debugId(), initiator)
                             .then(payload => {
                             const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
                             if (this.#clientData.get(client) === clientData) {
@@ -155,7 +161,7 @@ export class SourceMapManager extends Common.ObjectWrapper.ObjectWrapper {
         return Promise.all(this.#sourceMaps.keys().map(sourceMap => sourceMap.scopesFallbackPromiseForTest));
     }
 }
-export async function loadSourceMap(url, debugId, initiator) {
+async function loadSourceMap(resourceLoader, url, debugId, initiator) {
     try {
         if (debugId) {
             const cachedSourceMap = await SourceMapCache.instance().get(debugId);
@@ -163,7 +169,7 @@ export async function loadSourceMap(url, debugId, initiator) {
                 return cachedSourceMap;
             }
         }
-        const { content } = await PageResourceLoader.instance().loadResource(url, initiator);
+        const { content } = await resourceLoader.loadResource(url, initiator);
         const sourceMap = parseSourceMap(content);
         if ('debugId' in sourceMap && sourceMap.debugId) {
             // In case something goes wrong with updating the cache, we still want to use the source map.
@@ -175,9 +181,9 @@ export async function loadSourceMap(url, debugId, initiator) {
         throw new Error(`Could not load content for ${url}: ${cause.message}`, { cause });
     }
 }
-export async function tryLoadSourceMap(url, initiator) {
+export async function tryLoadSourceMap(resourceLoader, url, initiator) {
     try {
-        return await loadSourceMap(url, null, initiator);
+        return await loadSourceMap(resourceLoader, url, null, initiator);
     }
     catch (cause) {
         console.error(cause);

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

@@ -14,28 +14,106 @@ export class SourceMapScopesInfo {
         this.#generatedRanges = scopeInfo.ranges;
     }
     /**
-     * If the source map does not contain any scopes information, this factory function attempts to create bare bones scope information
+     * If the source map does not contain any scopes information, this factory function attempts to create scope information
      * via the script's AST combined with the mappings.
      *
      * We create the generated ranges from the scope tree and for each range we create an original scope that matches the bounds 1:1.
-     * We don't map the bounds via mappings as mappings are often iffy and it's not strictly required to translate stack traces where we
-     * map call-sites separately.
      */
     static createFromAst(sourceMap, scopeTree, text) {
-        const { scope, range } = convertScope(scopeTree, undefined, undefined);
-        return new SourceMapScopesInfo(sourceMap, { scopes: [scope], ranges: [range] });
-        function convertScope(node, parentScope, parentRange) {
-            const start = positionFromOffset(node.start);
-            const end = positionFromOffset(node.end);
-            const isStackFrame = node.kind === 2 /* Formatter.FormatterWorkerPool.ScopeKind.FUNCTION */;
+        const numSourceUrls = sourceMap.sourceURLs().length;
+        const scopeBySourceUrl = [];
+        for (let i = 0; i < numSourceUrls; i++) {
             const scope = {
-                start,
-                end,
-                name: sourceMap.findEntry(start.line, start.column, 0)?.name,
-                isStackFrame,
+                start: { line: 0, column: 0 },
+                end: { line: Number.POSITIVE_INFINITY, column: Number.POSITIVE_INFINITY },
+                isStackFrame: false,
                 variables: [],
                 children: [],
             };
+            scopeBySourceUrl.push(scope);
+        }
+        // Convert the entire scopeTree. Returns a root range that encompasses everything,
+        // and inserts scopes by sourceIndex into the above scopeBySourceUrl.
+        const { range } = convertScope(scopeTree, undefined);
+        return new SourceMapScopesInfo(sourceMap, { scopes: scopeBySourceUrl, ranges: [range] });
+        /**
+         * Recursively finds the correct place in the tree to insert the new scope.
+         * Maintains the invariant that children are sorted and contained by their parent.
+         */
+        function insertInScope(parent, newScope) {
+            // Check if the newScope fits strictly inside any of the existing children.
+            for (const child of parent.children) {
+                if (contains(child, newScope)) {
+                    insertInScope(child, newScope);
+                    return;
+                }
+            }
+            // When here, newScope belongs directly in parent.
+            // However, newScope might encompass some of parent's existing children (due
+            // to compiler transform quirks or arbitrary insertion order). We must move
+            // those children inside newScope.
+            const childrenToKeep = [];
+            for (const child of parent.children) {
+                if (contains(newScope, child)) {
+                    // child is actually inside newScope, so re-parent it.
+                    newScope.children.push(child);
+                    child.parent = newScope;
+                }
+                else {
+                    childrenToKeep.push(child);
+                }
+            }
+            // Find the correct index in the remaining children to insert newScope.
+            // We look for the first child that starts after the new scope.
+            const insertIndex = childrenToKeep.findIndex(child => compareScopes(newScope, child) < 0);
+            if (insertIndex === -1) {
+                // If no child starts after, it goes at the end.
+                childrenToKeep.push(newScope);
+            }
+            else {
+                childrenToKeep.splice(insertIndex, 0, newScope);
+            }
+            // Update parent's children to only be the ones that don't belong to newScope.
+            parent.children = childrenToKeep;
+            newScope.parent = parent;
+        }
+        function contains(outer, inner) {
+            return comparePositions(outer.start, inner.start) <= 0 && comparePositions(outer.end, inner.end) >= 0;
+        }
+        function compareScopes(a, b) {
+            return comparePositions(a.start, b.start);
+        }
+        function comparePositions(a, b) {
+            if (a.line !== b.line) {
+                return a.line - b.line;
+            }
+            return a.column - b.column;
+        }
+        function convertScope(node, parentRange) {
+            const start = positionFromOffset(node.start);
+            const end = positionFromOffset(node.end);
+            const startEntry = sourceMap.findEntry(start.line, start.column);
+            const endEntry = sourceMap.findEntry(end.line, end.column);
+            const sourceIndex = startEntry?.sourceIndex;
+            const canMapOriginalPosition = startEntry && endEntry && sourceIndex !== undefined &&
+                startEntry.sourceIndex === endEntry.sourceIndex && startEntry.sourceIndex !== undefined && sourceIndex >= 0 &&
+                sourceIndex < numSourceUrls;
+            const isStackFrame = node.kind === 2 /* Formatter.FormatterWorkerPool.ScopeKind.FUNCTION */ ||
+                node.kind === 4 /* Formatter.FormatterWorkerPool.ScopeKind.ARROW_FUNCTION */;
+            // TODO(crbug.com/368222773): Instead of mapping `start`, we should report a number of candidates. e.g. for arrow functions we should
+            //     follow the spec and map the `=>` as the spec says that is where the original name (if any) for arrow functions can be found.
+            const name = node.kind === 2 /* Formatter.FormatterWorkerPool.ScopeKind.FUNCTION */ ? startEntry?.name : undefined;
+            let scope;
+            if (canMapOriginalPosition) {
+                scope = {
+                    start: { line: startEntry.sourceLineNumber, column: startEntry.sourceColumnNumber },
+                    end: { line: endEntry.sourceLineNumber, column: endEntry.sourceColumnNumber },
+                    name,
+                    isStackFrame,
+                    variables: [],
+                    children: [],
+                };
+            }
             const range = {
                 start,
                 end,
@@ -46,9 +124,12 @@ export class SourceMapScopesInfo {
                 children: [],
             };
             parentRange?.children.push(range);
-            parentScope?.children.push(scope);
-            node.children.forEach(child => convertScope(child, scope, range));
-            return { scope, range };
+            if (canMapOriginalPosition && scope) {
+                const rootScope = scopeBySourceUrl[sourceIndex];
+                insertInScope(rootScope, scope);
+            }
+            node.children.forEach(child => convertScope(child, range));
+            return { range };
         }
         function positionFromOffset(offset) {
             const location = text.positionFromOffset(offset);
@@ -290,7 +371,14 @@ export class SourceMapScopesInfo {
     /**
      * Returns the authored function name of the function containing the provided generated position.
      */
-    findOriginalFunctionName({ line, column }) {
+    findOriginalFunctionName(position) {
+        const originalInnerMostScope = this.findOriginalFunctionScope(position)?.scope ?? undefined;
+        return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope);
+    }
+    /**
+     * Returns the authored function scope of the function containing the provided generated position.
+     */
+    findOriginalFunctionScope({ line, column }) {
         // There are 2 approaches:
         //   1) Find the inner-most generated range containing the provided generated position
         //      and use it's OriginalScope (then walk it outwards until we hit a function).
@@ -316,7 +404,21 @@ export class SourceMapScopesInfo {
                 this.#findOriginalScopeChain({ sourceIndex: entry.sourceIndex, line: entry.sourceLineNumber, column: entry.sourceColumnNumber })
                     .at(-1);
         }
-        return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope) ?? null;
+        if (!originalInnerMostScope) {
+            return null;
+        }
+        const functionScope = this.#findFunctionScopeInOriginalScopeChain(originalInnerMostScope);
+        if (!functionScope) {
+            return null;
+        }
+        // Find the root scope for some given original source, to get the source url.
+        let rootScope = functionScope;
+        while (rootScope.parent) {
+            rootScope = rootScope.parent;
+        }
+        const sourceIndex = this.#originalScopes.indexOf(rootScope);
+        const url = sourceIndex !== -1 ? this.#sourceMap.sourceURLForSourceIndex(sourceIndex) : undefined;
+        return functionScope ? { scope: functionScope, url } : null;
     }
     /**
      * Given an original position, this returns all the surrounding original scopes from outer
@@ -339,14 +441,21 @@ export class SourceMapScopesInfo {
         })([scope]);
         return result;
     }
-    #findFunctionNameInOriginalScopeChain(innerOriginalScope) {
+    #findFunctionScopeInOriginalScopeChain(innerOriginalScope) {
         for (let originalScope = innerOriginalScope; originalScope; originalScope = originalScope.parent) {
             if (originalScope.isStackFrame) {
-                return originalScope.name ?? '';
+                return originalScope;
             }
         }
         return null;
     }
+    #findFunctionNameInOriginalScopeChain(innerOriginalScope) {
+        const functionScope = this.#findFunctionScopeInOriginalScopeChain(innerOriginalScope);
+        if (!functionScope) {
+            return null;
+        }
+        return functionScope.name ?? '';
+    }
     /**
      * Returns one or more original stack frames for this single "raw frame" or call-site.
      *

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

@@ -31,8 +31,7 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
     #targetInfo;
     #creatingModels;
     constructor(targetManager, id, name, type, parentTarget, sessionId, suspended, connection, targetInfo) {
-        const needsNodeJSPatching = type === Type.NODE;
-        super(needsNodeJSPatching, parentTarget, sessionId, connection);
+        super(parentTarget, sessionId, connection);
         this.#targetManager = targetManager;
         this.#name = name;
         this.#capabilitiesMask = 0;
@@ -101,20 +100,11 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
         this.#isSuspended = suspended;
         this.#targetInfo = targetInfo;
     }
-    createModels(required) {
+    /** Creates the models in the order in which they are provided */
+    createModels(models) {
         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);
-            }
+        for (const model of models) {
+            this.model(model);
         }
         this.#creatingModels = false;
     }
@@ -135,7 +125,6 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
         return this.#type;
     }
     markAsNodeJSForTest() {
-        super.markAsNodeJSForTest();
         this.#type = Type.NODE;
     }
     targetManager() {