chrome-devtools-frontend 1.0.1697998 → 1.0.1698733

package/front_end/core/sdk/DebuggerModel.ts

@@ -23,7 +23,7 @@ import {
   pauseOnExceptionEnabledSettingDescriptor,
   pauseOnUncaughtExceptionSettingDescriptor,
 } from './SDKSettings.js';
-import {SourceMap} from './SourceMap.js';
+import {SourceMap, SourceMapProvenance} from './SourceMap.js';
 import {SourceMapManager} from './SourceMapManager.js';
 import {Capability, type Target} from './Target.js';
 
@@ -189,10 +189,10 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.agent = target.debuggerAgent();
     this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
 
-    this.#sourceMapManager =
-        new SourceMapManager(target,
-                             (compiledURL, sourceMappingURL, payload, script) => new SourceMap(
-                                 compiledURL, sourceMappingURL, payload, target.targetManager().getConsole(), script));
+    this.#sourceMapManager = new SourceMapManager(
+        target,
+        (compiledURL, sourceMappingURL, payload, script, provenance) => new SourceMap(
+            compiledURL, sourceMappingURL, payload, target.targetManager().getConsole(), script, provenance));
 
     const settings = this.target().targetManager().settings;
     this.#pauseOnExceptionEnabledSetting = settings.resolve(pauseOnExceptionEnabledSettingDescriptor);
@@ -719,7 +719,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
 
     if ((!selectedDebugSymbol || selectedDebugSymbol.type === Protocol.Debugger.DebugSymbolsType.SourceMap) &&
         script.sourceMapURL && !hasSyntaxError) {
-      this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+      this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL, SourceMapProvenance.CDP);
     }
 
     const isDiscardable = hasSyntaxError && script.isAnonymousScript();
@@ -730,11 +730,12 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     return script;
   }
 
-  setSourceMapURL(script: Script, newSourceMapURL: Platform.DevToolsPath.UrlString): void {
+  setSourceMapURL(script: Script, newSourceMapURL: Platform.DevToolsPath.UrlString,
+                  provenance: SourceMapProvenance): void {
     // Detach any previous source map from the `script` first.
     this.#sourceMapManager.detachSourceMap(script);
     script.sourceMapURL = newSourceMapURL;
-    this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL);
+    this.#sourceMapManager.attachSourceMap(script, script.sourceURL, script.sourceMapURL, provenance);
   }
 
   async setDebugInfoURL(script: Script, _externalURL: Platform.DevToolsPath.UrlString): Promise<void> {

package/front_end/core/sdk/NetworkRequest.ts

@@ -1566,7 +1566,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     return this.#signedExchangeInfo;
   }
 
-  async populateImageSource(image: HTMLImageElement): Promise<void> {
+  async populateImageSource(image: {src: string}): Promise<void> {
     const contentData = await this.requestContentData();
     if (TextUtils.ContentData.ContentData.isError(contentData)) {
       return;

package/front_end/core/sdk/PageFunctions.ts

@@ -0,0 +1,187 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Protocol from '../../generated/protocol.js';
+
+/**
+ * Functions in this file are serialized via `.toString()` and evaluated in the
+ * inspected page context over CDP (e.g. `Runtime.callFunctionOn`). Because they
+ * execute in the inspected browser environment, they use standard DOM types.
+ */
+
+export function scrollListenerInPage(this: HTMLElement|Document, id: number, reportScrollPositionBindingName: string,
+                                     scrollListenerNameInPage: string): void {
+  if ('scrollingElement' in this && !this.scrollingElement) {
+    return;
+  }
+
+  const scrollingElement = ('scrollingElement' in this ? this.scrollingElement : this) as HTMLElement;
+  // @ts-expect-error We're setting a custom field on `Element` or `Document` for retaining the function on the page.
+  this[scrollListenerNameInPage] = () => {
+    // @ts-expect-error `reportScrollPosition` binding is injected to the page before calling the function.
+    globalThis[reportScrollPositionBindingName](
+        JSON.stringify({scrollTop: scrollingElement.scrollTop, scrollLeft: scrollingElement.scrollLeft, id}));
+  };
+
+  // @ts-expect-error We've already defined the function used below.
+  this.addEventListener('scroll', this[scrollListenerNameInPage], true);
+}
+
+export function removeScrollListenerInPage(this: HTMLElement|Document, scrollListenerNameInPage: string): void {
+  // @ts-expect-error We've already set this custom field while adding scroll listener.
+  this.removeEventListener('scroll', this[scrollListenerNameInPage]);
+  // @ts-expect-error We've already set this custom field while adding scroll listener.
+  delete this[scrollListenerNameInPage];
+}
+
+export function scrollTopInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollTop;
+  }
+  return this.scrollTop;
+}
+
+export function scrollLeftInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollLeft;
+  }
+  return this.scrollLeft;
+}
+
+export function setScrollTopInPage(this: Element|Document, offsetInPage: number): void {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return;
+    }
+
+    this.scrollingElement.scrollTop = offsetInPage;
+  } else {
+    this.scrollTop = offsetInPage;
+  }
+}
+
+export function setScrollLeftInPage(this: Element|Document, offsetInPage: number): void {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return;
+    }
+
+    this.scrollingElement.scrollLeft = offsetInPage;
+  } else {
+    this.scrollLeft = offsetInPage;
+  }
+}
+
+export function verticalScrollRangeInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollHeight - this.scrollingElement.clientHeight;
+  }
+
+  return this.scrollHeight - this.clientHeight;
+}
+
+export function horizontalScrollRangeInPage(this: Element|Document): number {
+  if ('scrollingElement' in this) {
+    if (!this.scrollingElement) {
+      return 0;
+    }
+
+    return this.scrollingElement.scrollWidth - this.scrollingElement.clientWidth;
+  }
+
+  return this.scrollWidth - this.clientWidth;
+}
+
+export function toggleClassAndInjectStyleRule(this: Element, pseudoElementName: string|null, hidden: boolean): void {
+  const classNamePrefix = '__web-inspector-hide';
+  const classNameSuffix = '-shortcut__';
+  const styleTagId = '__web-inspector-hide-shortcut-style__';
+  const pseudoElementNameEscaped = pseudoElementName ? pseudoElementName.replace(/[\(\)\:]/g, '_') : '';
+  const className = classNamePrefix + pseudoElementNameEscaped + classNameSuffix;
+  this.classList.toggle(className, hidden);
+
+  let localRoot: Element|HTMLHeadElement = this;
+  while (localRoot.parentNode) {
+    localRoot = (localRoot.parentNode as Element);
+  }
+  if (localRoot.nodeType === Node.DOCUMENT_NODE) {
+    localRoot = document.head;
+  }
+
+  let style = localRoot.querySelector('style#' + styleTagId);
+  if (!style) {
+    const selectors = [];
+    selectors.push('.__web-inspector-hide-shortcut__');
+    selectors.push('.__web-inspector-hide-shortcut__ *');
+    const selector = selectors.join(', ');
+    const ruleBody = '    visibility: hidden !important;';
+    const rule = '\n' + selector + '\n{\n' + ruleBody + '\n}\n';
+
+    style = document.createElement('style');
+    style.id = styleTagId;
+    style.textContent = rule;
+
+    localRoot.appendChild(style);
+  }
+
+  // In addition to putting them on the element we want to hide, we will
+  // also add pseudo element classes to the style element to keep track of
+  // which pseudo elements we have style rules for.
+  if (pseudoElementName && !style.classList.contains(className)) {
+    style.classList.add(className);
+    style.textContent = `.${className}${pseudoElementName}, ${style.textContent}`;
+  }
+}
+
+export function scrollIntoViewInPage(this: Element): void {
+  this.scrollIntoViewIfNeeded(true);
+}
+
+export function focusInPage(this: HTMLElement): void {
+  this.focus();
+}
+
+export function toStringForClipboard(this: Object, data: {
+  subtype: string|undefined,
+  indent: string,
+}): string|undefined {
+  const subtype = data.subtype;
+  const indent = data.indent;
+
+  if (subtype === 'node') {
+    return this instanceof Element ? this.outerHTML : undefined;
+  }
+  if (subtype && typeof this === 'undefined') {
+    return String(subtype);
+  }
+  try {
+    return JSON.stringify(this, null, indent);
+  } catch {
+    return String(this);
+  }
+}
+
+export function saveVariable(this: Window, value: Protocol.Runtime.CallArgument): string {
+  const prefix = 'temp';
+  let index = 1;
+  while ((prefix + index) in this) {
+    ++index;
+  }
+  const name = prefix + index;
+  // @ts-expect-error Assignment to global object
+  this[name] = value;
+  return name;
+}

package/front_end/core/sdk/Resource.ts

@@ -199,7 +199,7 @@ export class Resource implements TextUtils.ContentProvider.ContentProvider {
     return TextUtils.TextUtils.performSearchInSearchMatches(result.result || [], query, caseSensitive, isRegex);
   }
 
-  async populateImageSource(image: HTMLImageElement): Promise<void> {
+  async populateImageSource(image: {src: string}): Promise<void> {
     const contentData = await this.requestContentData();
     if (TextUtils.ContentData.ContentData.isError(contentData)) {
       return;

package/front_end/core/sdk/RuntimeModel.ts

@@ -10,6 +10,7 @@ import type * as Platform from '../platform/platform.js';
 
 import {DebuggerModel, type FunctionDetails} from './DebuggerModel.js';
 import {HeapProfilerModel} from './HeapProfilerModel.js';
+import {toStringForClipboard} from './PageFunctions.js';
 import {
   RemoteFunction,
   RemoteObject,
@@ -313,26 +314,6 @@ export class RuntimeModel extends SDKModel<EventTypes> {
                           }])
         .then(Host.InspectorFrontendHost.InspectorFrontendHostInstance.copyText.bind(
             Host.InspectorFrontendHost.InspectorFrontendHostInstance));
-
-    function toStringForClipboard(this: Object, data: {
-      subtype: string,
-      indent: string,
-    }): string|undefined {
-      const subtype = data.subtype;
-      const indent = data.indent;
-
-      if (subtype === 'node') {
-        return this instanceof Element ? this.outerHTML : undefined;
-      }
-      if (subtype && typeof this === 'undefined') {
-        return String(subtype);
-      }
-      try {
-        return JSON.stringify(this, null, indent);
-      } catch {
-        return String(this);
-      }
-    }
   }
 
   private async queryObjectsRequested(object: RemoteObject, executionContextId?: number): Promise<void> {

package/front_end/core/sdk/Script.ts

@@ -43,6 +43,7 @@ import type {FrameAssociated} from './FrameAssociated.js';
 import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
 import {ResourceTreeModel} from './ResourceTreeModel.js';
 import type {ExecutionContext} from './RuntimeModel.js';
+import {SecurityOrigin} from './SecurityOrigin.js';
 import type {DebugId, SourceMap} from './SourceMap.js';
 import type {Target} from './Target.js';
 
@@ -88,6 +89,7 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
   readonly #language: string|null;
   #contentPromise: Promise<TextUtils.ContentData.ContentDataOrError>|null;
   readonly #embedderName: Platform.DevToolsPath.UrlString|null;
+  readonly #securityOrigin: SecurityOrigin;
   readonly isModule: boolean|null;
   readonly buildId: string|null;
   constructor(debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId,
@@ -119,12 +121,31 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     this.#language = scriptLanguage;
     this.#contentPromise = null;
     this.#embedderName = embedderName;
+    this.#securityOrigin = SecurityOrigin.create(this.#embedderName ?? '');
   }
 
   embedderName(): Platform.DevToolsPath.UrlString|null {
     return this.#embedderName;
   }
 
+  /**
+   * Returns the security origin of the script derived exclusively from its
+   * embedder/network URL (`#embedderName`), or a unique opaque origin if the
+   * script has no valid network provenance (e.g. `eval()` or buffer-based Wasm).
+   *
+   * Security note: Do NOT fall back to `this.sourceURL` or
+   * `this.target().inspectedSecurityOrigin()`:
+   * - `sourceURL` is overwritten by `//# sourceURL=` comments, allowing a script
+   *   to spoof an arbitrary origin.
+   * - Third-party scripts (`<script src="https://attacker.example/...">`) run in
+   *   the same target/frame as the main page; falling back to the target's
+   *   origin would allow them to launder their origin by dynamically evaluating
+   *   code via `eval()` or `WebAssembly.instantiate(buffer)`.
+   */
+  securityOrigin(): SecurityOrigin {
+    return this.#securityOrigin;
+  }
+
   target(): Target {
     return this.debuggerModel.target();
   }

package/front_end/core/sdk/SourceMap.ts

@@ -130,6 +130,12 @@ interface SourceInfo {
   reverseMappings: number[]|null;
 }
 
+export const enum SourceMapProvenance {
+  CDP = 'cdp',
+  EXTENSION = 'extension',
+  USER = 'user',
+}
+
 export class SourceMap {
   static retainRawSourceMaps = false;
 
@@ -149,13 +155,15 @@ export class SourceMap {
 
   #scopesFallbackPromise?: Promise<void>;
   readonly #console: Common.Console.Console;
+  readonly #provenance: SourceMapProvenance;
 
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
    * for format description.
    */
   constructor(compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
-              payload: SourceMapV3, console: Common.Console.Console, script?: Script) {
+              payload: SourceMapV3, console: Common.Console.Console, script?: Script,
+              provenance: SourceMapProvenance = SourceMapProvenance.CDP) {
     this.#json = payload;
     this.#script = script;
     this.#compiledURL = compiledURL;
@@ -163,6 +171,7 @@ export class SourceMap {
     this.#baseURL = (Common.ParsedURL.schemeIs(sourceMappingURL, 'data:')) ? compiledURL : sourceMappingURL;
     this.#debugId = 'debugId' in payload ? (payload.debugId as DebugId | undefined) : undefined;
     this.#console = console;
+    this.#provenance = provenance;
 
     if ('sections' in this.#json) {
       if (this.#json.sections.find(section => 'url' in section)) {
@@ -172,6 +181,10 @@ export class SourceMap {
     this.eachSection(this.parseSources.bind(this));
   }
 
+  provenance(): SourceMapProvenance {
+    return this.#provenance;
+  }
+
   json(): SourceMapV3|null {
     return this.#json;
   }
@@ -823,7 +836,7 @@ export class SourceMap {
 
   resolveScopeChain(frame: CallFrame): ScopeChainEntry[]|null {
     this.#ensureSourceMapProcessed();
-    if (this.#scopesInfo === null) {
+    if (this.#provenance === SourceMapProvenance.USER || !this.#scopesInfo?.hasVariablesAndBindings()) {
       return null;
     }
 

package/front_end/core/sdk/SourceMapCache.ts

@@ -2,15 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import type {DebugId, SourceMapV3} from './SourceMap.js';
 
 /** A thin wrapper around the Cache API to store source map JSONs keyed on Debug IDs */
 export class SourceMapCache {
   static create(): SourceMapCache {
-    if (typeof window === 'undefined') {
-      // TODO(crbug.com/451502260): Move this behind a `HostRuntime` interface.
+    if (!Platform.HostRuntime.HOST_RUNTIME.getCacheStorage()) {
       return IN_MEMORY_INSTANCE as unknown as
           SourceMapCache;  // TS doesn't like that our in-memory class doesn't have the same private fields.
     }
@@ -22,7 +21,7 @@ export class SourceMapCache {
   }
 
   readonly #name: string;
-  #cachePromise?: Promise<Cache>;
+  #cachePromise?: Promise<Platform.HostRuntime.CacheEntry>;
 
   private constructor(name: string) {
     this.#name = name;
@@ -30,21 +29,25 @@ export class SourceMapCache {
 
   async set(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString, sourceMap: SourceMapV3): Promise<void> {
     const cache = await this.#cache();
-    await cache.put(SourceMapCache.#urlForDebugId(debugId, securityOrigin), new Response(JSON.stringify(sourceMap)));
+    await cache?.put(SourceMapCache.#urlForDebugId(debugId, securityOrigin), new Response(JSON.stringify(sourceMap)));
   }
 
   async get(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString): Promise<SourceMapV3|null> {
     const cache = await this.#cache();
-    const response = await cache.match(SourceMapCache.#urlForDebugId(debugId, securityOrigin));
-    return await response?.json() ?? null;
+    const response = await cache?.match(SourceMapCache.#urlForDebugId(debugId, securityOrigin));
+    return (await response?.json() as SourceMapV3 | undefined) ?? null;
   }
 
-  async #cache(): Promise<Cache> {
+  async #cache(): Promise<Platform.HostRuntime.CacheEntry|undefined> {
     if (this.#cachePromise) {
       return await this.#cachePromise;
     }
 
-    this.#cachePromise = window.caches.open(this.#name);
+    const cacheStorage = Platform.HostRuntime.HOST_RUNTIME.getCacheStorage();
+    if (!cacheStorage) {
+      return undefined;
+    }
+    this.#cachePromise = cacheStorage.open(this.#name);
     return await this.#cachePromise;
   }
 
@@ -54,7 +57,7 @@ export class SourceMapCache {
   }
 
   async disposeForTest(): Promise<void> {
-    await window.caches.delete(this.#name);
+    await Platform.HostRuntime.HOST_RUNTIME.getCacheStorage()?.delete(this.#name);
   }
 }
 

package/front_end/core/sdk/SourceMapManager.ts

@@ -7,13 +7,13 @@ import * as Platform from '../platform/platform.js';
 
 import type {FrameAssociated} from './FrameAssociated.js';
 import {PageResourceLoader, type PageResourceLoadInitiator, type ResourceLoader} from './PageResourceLoader.js';
-import {type DebugId, parseSourceMap, SourceMap, type SourceMapV3} from './SourceMap.js';
+import {type DebugId, parseSourceMap, SourceMap, type SourceMapProvenance, type SourceMapV3} from './SourceMap.js';
 import {SourceMapCache} from './SourceMapCache.js';
 import {type Target, Type} from './Target.js';
 
 export type SourceMapFactory<T> =
     (compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
-     payload: SourceMapV3, client: T) => SourceMap;
+     payload: SourceMapV3, client: T, provenance: SourceMapProvenance) => SourceMap;
 
 export const lazyLoadingSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
   name: 'source-maps-lazy-loading',
@@ -37,8 +37,8 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
 
     this.#target = target;
     this.#factory = factory ??
-        ((compiledURL, sourceMappingURL, payload) =>
-             new SourceMap(compiledURL, sourceMappingURL, payload, this.#target.targetManager().getConsole()));
+        ((compiledURL, sourceMappingURL, payload, _client, provenance) => new SourceMap(
+             compiledURL, sourceMappingURL, payload, this.#target.targetManager().getConsole(), undefined, provenance));
     const settings = target.targetManager().settings;
     this.#lazyLoadingSetting = settings.resolve(lazyLoadingSettingDescriptor);
   }
@@ -60,8 +60,8 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
       this.detachSourceMap(client);
     }
     this.#isEnabled = isEnabled;
-    for (const [client, {relativeSourceURL, relativeSourceMapURL}] of clientData) {
-      this.attachSourceMap(client, relativeSourceURL, relativeSourceMapURL);
+    for (const [client, {relativeSourceURL, relativeSourceMapURL, provenance}] of clientData) {
+      this.attachSourceMap(client, relativeSourceURL, relativeSourceMapURL, provenance);
     }
   }
 
@@ -97,8 +97,8 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
   }
 
   // TODO(bmeurer): We are lying about the type of |relativeSourceURL| here.
-  attachSourceMap(
-      client: T, relativeSourceURL: Platform.DevToolsPath.UrlString, relativeSourceMapURL: string|undefined): void {
+  attachSourceMap(client: T, relativeSourceURL: Platform.DevToolsPath.UrlString, relativeSourceMapURL: string|undefined,
+                  provenance: SourceMapProvenance): void {
     if (this.#clientData.has(client)) {
       throw new Error('SourceMap is already attached or being attached to client');
     }
@@ -109,6 +109,7 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
     const clientData: ClientData = {
       relativeSourceURL,
       relativeSourceMapURL,
+      provenance,
       getSourceMap: () => Promise.resolve(undefined),
     };
     this.#clientData.set(client, clientData);
@@ -142,7 +143,7 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
                   loadSourceMap(resourceLoader, this.#sourceMapCache, sourceMapURL, client.debugId(), initiator)
                       .then(
                           payload => {
-                            const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client);
+                            const sourceMap = this.#factory(sourceURL, sourceMapURL, payload, client, provenance);
                             if (this.#clientData.get(client) === clientData) {
                               clientData.sourceMap = sourceMap;
                               this.#sourceMaps.set(sourceMap, client);
@@ -257,6 +258,7 @@ interface ClientData {
   // Stores the raw sourceMappingURL as provided by V8. These are not guaranteed to
   // be valid URLs and will be checked and resolved once `attachSourceMap` is called.
   relativeSourceMapURL: string;
+  provenance: SourceMapProvenance;
   sourceMap?: SourceMap;
   getSourceMap: () => Promise<SourceMap|undefined>;
 }

package/front_end/core/sdk/SourceMapScopeChainEntry.ts

@@ -27,6 +27,10 @@ const UIStrings = {
    * @description Title of a section in the debugger showing JavaScript variables from the global scope.
    */
   global: 'Global',
+  /**
+   * @description Text in Scope Chain section of the Sources panel.
+   */
+  exception: 'Exception',
   /**
    * @description Text in Scope Chain section of the Sources panel.
    */
@@ -60,12 +64,18 @@ export class SourceMapScopeChainEntry implements ScopeChainEntry {
   }
 
   extraProperties(): RemoteObjectProperty[] {
+    const extraProperties = [];
+    if (this.#isInnerMostFunction && this.#callFrame.exception) {
+      extraProperties.push(new RemoteObjectProperty(i18nString(UIStrings.exception), this.#callFrame.exception,
+                                                    undefined, undefined, undefined, undefined, undefined,
+                                                    /* synthetic */ true));
+    }
     if (this.#returnValue) {
-      return [new RemoteObjectProperty(
+      extraProperties.push(new RemoteObjectProperty(
           i18nString(UIStrings.returnValue), this.#returnValue, undefined, undefined, undefined, undefined, undefined,
-          /* synthetic */ true)];
+          /* synthetic */ true, this.#callFrame.setReturnValue.bind(this.#callFrame)));
     }
-    return [];
+    return extraProperties;
   }
 
   callFrame(): CallFrame {
@@ -144,23 +154,55 @@ class SourceMapScopeRemoteObject extends RemoteObjectImpl {
       return {properties: [], internalProperties: []};
     }
 
-    const properties: RemoteObjectProperty[] = [];
-    for (const [index, variable] of this.#scope.variables.entries()) {
-      const expression = this.#findExpression(index);
-      if (expression === null) {
-        properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
-        continue;
+    if (this.#scope.variables.length === 0) {
+      return {properties: [], internalProperties: []};
+    }
+
+    const expressions = this.#scope.variables.map((_, index) => this.#findExpression(index));
+
+    if (expressions.every(expr => expr === null)) {
+      const properties = this.#scope.variables.map(v => SourceMapScopeRemoteObject.#unavailableProperty(v));
+      return {properties, internalProperties: []};
+    }
+
+    const spreadEntries: string[] = [];
+    for (const [index, expr] of expressions.entries()) {
+      if (expr !== null) {
+        spreadEntries.push(`...(() => { try { return {${index}: eval(${JSON.stringify(expr)})}; } catch {} })()`);
       }
+    }
+
+    const batchExpression = `({ __proto__: null, ${spreadEntries.join(', ')} })`;
+    const result = await this.#callFrame.evaluate({
+      expression: batchExpression,
+      generatePreview: false,
+      scopeNumber: this.#scopeNumber,
+    });
+
+    if ('error' in result || result.exceptionDetails || !result.object) {
+      const properties = this.#scope.variables.map(v => SourceMapScopeRemoteObject.#unavailableProperty(v));
+      return {properties, internalProperties: []};
+    }
+
+    const {properties: objectProperties} = await result.object.getOwnProperties(generatePreview);
+    result.object.release();
 
-      const result = await this.#callFrame.evaluate({expression, generatePreview, scopeNumber: this.#scopeNumber});
-      if ('error' in result || result.exceptionDetails) {
-        // TODO(crbug.com/40277685): Make these errors user-visible to aid tooling developers.
-        //         E.g. show the error on hover or expose it in the developer resources panel.
+    const propertyMap = new Map<string, RemoteObjectProperty>();
+    if (objectProperties) {
+      for (const prop of objectProperties) {
+        propertyMap.set(prop.name, prop);
+      }
+    }
+
+    const properties: RemoteObjectProperty[] = [];
+    for (const [index, variable] of this.#scope.variables.entries()) {
+      const prop = propertyMap.get(String(index));
+      if (!prop || !prop.value) {
         properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
       } else {
-        properties.push(new RemoteObjectProperty(
-            variable, result.object, /* enumerable */ false, /* writable */ false, /* isOwn */ true,
-            /* wasThrown */ false));
+        properties.push(new RemoteObjectProperty(variable, prop.value, /* enumerable */ false, /* writable */ false,
+                                                 /* isOwn */ true,
+                                                 /* wasThrown */ false));
       }
     }
 
@@ -177,7 +219,7 @@ class SourceMapScopeRemoteObject extends RemoteObjectImpl {
     if (typeof expressionOrSubRanges === 'string') {
       return expressionOrSubRanges;
     }
-    if (expressionOrSubRanges === null) {
+    if (expressionOrSubRanges === null || expressionOrSubRanges === undefined) {
       return null;
     }
 

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -355,9 +355,10 @@ export class SourceMapScopesInfo {
     //         w.r.t. each other.
 
     let seenFunctionScope = false;
-    const result: SourceMapScopeChainEntry[] = [];
+    const result: ScopeChainEntry[] = [];
     // Walk the original scope chain outwards and try to find the corresponding generated range along the way.
-    for (let originalScope = rangeChain.at(-1)?.originalScope; originalScope; originalScope = originalScope.parent) {
+    for (let originalScope: ScopesCodec.OriginalScope|null|undefined = innerMostOriginalScope; originalScope;
+         originalScope = originalScope.parent) {
       const range = rangeChain.findLast(r => r.originalScope === originalScope);
       // `kind` is just a label for scope UI views and has no semantic significance, so `isStackFrame`
       // decides whether this scope is a function scope.
@@ -370,6 +371,11 @@ export class SourceMapScopesInfo {
       seenFunctionScope ||= isFunctionScope;
     }
 
+    const globalScope = callFrame.scopeChain()?.find(s => s.type() === Protocol.Debugger.ScopeType.Global);
+    if (globalScope) {
+      result.push(globalScope);
+    }
+
     // If we are paused on a return statement, we need to drop inner block scopes. This is because V8 only emits a
     // single return bytecode and "gotos" at the functions' end, where we are now paused.
     if (callFrame.returnValue() !== null) {