chrome-devtools-frontend 1.0.1698733 → 1.0.1700561

package/front_end/generated/protocol-proxy-api.d.ts

@@ -3368,11 +3368,21 @@ declare namespace ProtocolProxyApi {
     invoke_getManifestIcons(): Promise<Protocol.Page.GetManifestIconsResponse>;
 
     /**
-     * Returns the unique (PWA) app id.
+     * Returns the unique (PWA) app id, along with IWA bundle ID and parent app info.
      * Only returns values if the feature flag 'WebAppEnableManifestId' is enabled
      */
     invoke_getAppId(): Promise<Protocol.Page.GetAppIdResponse>;
 
+    /**
+     * Returns the list of installed child Sub-Apps for the inspected parent app.
+     */
+    invoke_getSubApps(): Promise<Protocol.Page.GetSubAppsResponse>;
+
+    /**
+     * Returns the list of sibling Sub-Apps sharing the same parent app if the inspected context is a Sub-App.
+     */
+    invoke_getSiblingSubApps(): Promise<Protocol.Page.GetSiblingSubAppsResponse>;
+
     invoke_getAdScriptAncestry(params: Protocol.Page.GetAdScriptAncestryRequest): Promise<Protocol.Page.GetAdScriptAncestryResponse>;
 
     /**
@@ -4315,6 +4325,27 @@ declare namespace ProtocolProxyApi {
      */
     invoke_clearTrustTokens(params: Protocol.Storage.ClearTrustTokensRequest): Promise<Protocol.Storage.ClearTrustTokensResponse>;
 
+    /**
+     * Returns all stored Private Verification Tokens for the current browsing
+     * context.
+     */
+    invoke_getPrivateVerificationTokens(): Promise<Protocol.Storage.GetPrivateVerificationTokensResponse>;
+
+    /**
+     * Removes all Private Verification Tokens issued by the provided issuerOrigin.
+     */
+    invoke_clearPrivateVerificationTokens(params: Protocol.Storage.ClearPrivateVerificationTokensRequest): Promise<Protocol.ProtocolResponseWithError>;
+
+    /**
+     * Removes a specific Private Verification Token by its ID.
+     */
+    invoke_deletePrivateVerificationToken(params: Protocol.Storage.DeletePrivateVerificationTokenRequest): Promise<Protocol.ProtocolResponseWithError>;
+
+    /**
+     * Set tracking for Private Verification Tokens.
+     */
+    invoke_setPrivateVerificationTokensTracking(params: Protocol.Storage.SetPrivateVerificationTokensTrackingRequest): Promise<Protocol.ProtocolResponseWithError>;
+
     /**
      * Set tracking for a storage key's buckets.
      */
@@ -4362,6 +4393,11 @@ declare namespace ProtocolProxyApi {
 
     storageBucketDeleted(params: Protocol.Storage.StorageBucketDeletedEvent): void;
 
+    /**
+     * Private Verification Tokens have been stored or deleted.
+     */
+    privateVerificationTokensUpdated(): void;
+
   }
 
   export interface SystemInfoApi {

package/front_end/generated/protocol.ts

@@ -13855,6 +13855,48 @@ export namespace Overlay {
     Apca = 'apca',
   }
 
+  /**
+   * Configuration for Inset-Modified Containing Block (IMCB) and CSS Anchor Positioning highlight.
+   */
+  export interface ImcbHighlightConfig {
+    /**
+     * Border color for the Inset-Modified Containing Block (default: transparent).
+     */
+    imcbBorderColor?: DOM.RGBA;
+    /**
+     * Background fill color for the Inset-Modified Containing Block (default: transparent).
+     */
+    imcbBackgroundColor?: DOM.RGBA;
+    /**
+     * Fill color for the inset modifiers area (difference between CB and IMCB).
+     */
+    insetsBackgroundColor?: DOM.RGBA;
+    /**
+     * Hatch color for the inset modifiers area.
+     */
+    insetsHatchColor?: DOM.RGBA;
+    /**
+     * Border color for the referenced target anchor element(s) (when element is anchor-positioned).
+     */
+    anchorBorderColor?: DOM.RGBA;
+    /**
+     * Background fill color for the referenced target anchor element(s) (when element is anchor-positioned).
+     */
+    anchorBackgroundColor?: DOM.RGBA;
+    /**
+     * Whether to render the 3x3 position-area grid lines when position-area is used.
+     */
+    showPositionAreaGrid?: boolean;
+    /**
+     * Line color for the 3x3 position-area grid lines.
+     */
+    positionAreaGridLineColor?: DOM.RGBA;
+    /**
+     * Fill color for the active region within the position-area grid.
+     */
+    positionAreaActiveRegionColor?: DOM.RGBA;
+  }
+
   /**
    * Configuration data for the highlighting of page elements.
    */
@@ -13935,6 +13977,10 @@ export namespace Overlay {
      * The container query container highlight configuration (default: all transparent).
      */
     containerQueryContainerHighlightConfig?: ContainerQueryContainerHighlightConfig;
+    /**
+     * The IMCB highlight configuration (default: all transparent).
+     */
+    imcbHighlightConfig?: ImcbHighlightConfig;
   }
 
   export const enum ColorFormat {
@@ -15485,6 +15531,25 @@ export namespace Page {
     themeColor?: string;
   }
 
+  export interface SubApp {
+    /**
+     * Display name of the sub-app.
+     */
+    name: string;
+    /**
+     * Scope of the sub-app.
+     */
+    scope: string;
+    /**
+     * Manifest id of the sub-app.
+     */
+    manifestId: string;
+    /**
+     * Start URL of the sub-app.
+     */
+    startUrl: string;
+  }
+
   /**
    * The type of a frameNavigated event.
    */
@@ -15895,6 +15960,22 @@ export namespace Page {
      * Recommendation for manifest's id attribute to match current id computed from start_url
      */
     recommendedId?: string;
+    /**
+     * The bundle ID for an Isolated Web App (IWA)
+     */
+    bundleId?: string;
+    /**
+     * The name of the parent app if this app is a Sub-App
+     */
+    parentAppName?: string;
+  }
+
+  export interface GetSubAppsResponse extends ProtocolResponseWithError {
+    subApps: SubApp[];
+  }
+
+  export interface GetSiblingSubAppsResponse extends ProtocolResponseWithError {
+    subApps: SubApp[];
   }
 
   export interface GetAdScriptAncestryRequest {
@@ -18392,6 +18473,40 @@ export namespace Storage {
     count: number;
   }
 
+  /**
+   * Details of a stored Private Verification Token.
+   */
+  export interface PrivateVerificationToken {
+    /**
+     * Unique identifier of the token in the database.
+     */
+    id: string;
+    /**
+     * Origin of the token issuer.
+     */
+    issuerOrigin: string;
+    /**
+     * Public key ID used to issue the token.
+     */
+    keyId: integer;
+    /**
+     * Expiration timestamp in seconds since the epoch.
+     */
+    expiration: Network.TimeSinceEpoch;
+    /**
+     * Token creation timestamp in seconds since the epoch.
+     */
+    creationTime: Network.TimeSinceEpoch;
+    /**
+     * Token protocol version.
+     */
+    version: integer;
+    /**
+     * Base64-encoded serialized token.
+     */
+    token: string;
+  }
+
   export const enum StorageBucketsDurability {
     Relaxed = 'relaxed',
     Strict = 'strict',
@@ -18619,6 +18734,22 @@ export namespace Storage {
     didDeleteTokens: boolean;
   }
 
+  export interface GetPrivateVerificationTokensResponse extends ProtocolResponseWithError {
+    tokens: PrivateVerificationToken[];
+  }
+
+  export interface ClearPrivateVerificationTokensRequest {
+    issuerOrigin: string;
+  }
+
+  export interface DeletePrivateVerificationTokenRequest {
+    tokenId: string;
+  }
+
+  export interface SetPrivateVerificationTokensTrackingRequest {
+    enable: boolean;
+  }
+
   export interface SetStorageBucketTrackingRequest {
     storageKey: string;
     enable: boolean;

package/front_end/models/bindings/NetworkProject.ts

@@ -15,6 +15,7 @@ const uiSourceCodeToAttributionMap = new WeakMap<Workspace.UISourceCode.UISource
 
 export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
+  readonly #sourceURLSynthesizedUISourceCodes = new WeakSet<Workspace.UISourceCode.UISourceCode>();
 
   static instance({forceNew}: {
     forceNew: boolean,
@@ -41,6 +42,14 @@ export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<Ev
   getTargetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
     return this.#projectToTargetMap.get(uiSourceCode.project()) ?? null;
   }
+
+  setSourceURLSynthesized(uiSourceCode: Workspace.UISourceCode.UISourceCode): void {
+    this.#sourceURLSynthesizedUISourceCodes.add(uiSourceCode);
+  }
+
+  isSourceURLSynthesized(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return this.#sourceURLSynthesizedUISourceCodes.has(uiSourceCode);
+  }
 }
 
 export const enum Events {
@@ -59,6 +68,27 @@ export interface EventTypes {
 }
 
 export class NetworkProject {
+  /**
+   * Records that `uiSourceCode` was synthesized from a `//# sourceURL=` annotation,
+   * and therefore doesn't correspond to an actual network resource.
+   */
+  static setSourceURLSynthesized(uiSourceCode: Workspace.UISourceCode.UISourceCode): void {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    NetworkProjectManager.instance().setSourceURLSynthesized(uiSourceCode);
+  }
+
+  /**
+   * Whether `uiSourceCode` was synthesized from a `//# sourceURL=` annotation.
+   *
+   * Both the URL and the content of such a source are fully controlled by the page,
+   * so it must never be treated like a genuine network resource (for example it must
+   * not be persisted as a local override, see b/553931271).
+   */
+  static isSourceURLSynthesized(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    return NetworkProjectManager.instance().isSourceURLSynthesized(uiSourceCode);
+  }
+
   static resolveFrame(uiSourceCode: Workspace.UISourceCode.UISourceCode, frameId: Protocol.Page.FrameId):
       SDK.ResourceTreeModel.ResourceTreeFrame|null {
     const target = NetworkProject.targetForUISourceCode(uiSourceCode);

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -14,6 +14,19 @@ import {type DebuggerSourceMapping, DebuggerWorkspaceBinding} from './DebuggerWo
 import {NetworkProject} from './NetworkProject.js';
 import {metadataForURL} from './ResourceUtils.js';
 
+/**
+ * The security origin of the URL that `target` (or its closest ancestor that has
+ * one) is inspecting, or `null` if none of them has an inspected URL yet.
+ */
+function inspectedSecurityOrigin(target: SDK.Target.Target): SDK.SecurityOrigin.SecurityOrigin|null {
+  for (let current: SDK.Target.Target|null = target; current; current = current.parentTarget()) {
+    if (current.inspectedURL()) {
+      return current.inspectedSecurityOrigin();
+    }
+  }
+  return null;
+}
+
 export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
   #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -197,6 +210,19 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
       // Try to resolve `//# sourceURL=` annotations relative to
       // the base URL, according to the sourcemap specification.
       url = SDK.SourceMapManager.SourceMapManager.resolveRelativeSourceURL(script.debuggerModel.target(), url);
+
+      // `//# sourceURL=` annotations are fully controlled by the page, so don't let
+      // them impersonate a resource of a different origin (b/553931271).
+      if (!this.#isTrustworthySourceURL(script, url)) {
+        return;
+      }
+
+      // Don't let a synthetic source evict the `UISourceCode` of a script that was
+      // actually fetched from the network under the same URL.
+      const previousUISourceCode = this.project(script).uiSourceCodeForURL(url);
+      if (previousUISourceCode && !NetworkProject.isSourceURLSynthesized(previousUISourceCode)) {
+        return;
+      }
     } else {
       // Ignore inline <script>s without `//# sourceURL` annotation here.
       if (script.isInlineScript()) {
@@ -225,6 +251,9 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     // Create UISourceCode.
     const originalContentProvider = script.originalContentProvider();
     const uiSourceCode = project.createUISourceCode(url, originalContentProvider.contentType());
+    if (script.hasSourceURL) {
+      NetworkProject.setSourceURLSynthesized(uiSourceCode);
+    }
     NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
     const metadata = metadataForURL(this.debuggerModel.target(), script.frameId, url);
 
@@ -238,6 +267,39 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     void this.debuggerWorkspaceBinding.updateLocations(script);
   }
 
+  /**
+   * Whether the (already resolved) `//# sourceURL=` annotation `url` of `script` may
+   * be used as-is.
+   *
+   * Only `http(s)` URLs can collide with genuine network resources, so an origin is
+   * only enforced for those. Annotations using other schemes (e.g. `webpack-internal://`,
+   * `snippet://` or `chrome-extension://` for content scripts) cannot impersonate a
+   * network resource and are always accepted.
+   *
+   * The origin of the script's frame is authoritative. For targets that don't have a
+   * frame (e.g. workers) we fall back to the inspected URL of the target (or of its
+   * closest ancestor that has one). If no origin can be established at all, the
+   * annotation is rejected, since we cannot rule out that it spoofs another origin.
+   */
+  #isTrustworthySourceURL(script: SDK.Script.Script, url: Platform.DevToolsPath.UrlString): boolean {
+    if (script.isContentScript()) {
+      return true;
+    }
+    const parsedURL = Common.ParsedURL.ParsedURL.fromString(url);
+    if (!parsedURL || !['http', 'https'].includes(parsedURL.scheme)) {
+      return true;
+    }
+    const target = script.debuggerModel.target();
+    const frame = script.frameId ?
+        target.model(SDK.ResourceTreeModel.ResourceTreeModel)?.frameForId(script.frameId) ?? null :
+        null;
+    const securityOrigin = frame ? frame.securityOrigin() : inspectedSecurityOrigin(target);
+    if (!securityOrigin) {
+      return false;
+    }
+    return SDK.SecurityOrigin.SecurityOrigin.create(url).isSameOriginWith(securityOrigin);
+  }
+
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode): ResourceScriptFile|null {
     return this.#uiSourceCodeToScriptFile.get(uiSourceCode) || null;
   }

package/front_end/models/change_tracker/ChangeTracker.ts

@@ -25,7 +25,7 @@ export class ChangeTracker {
   }
 
   get isTracking(): boolean {
-    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled);
+    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled) && this.#commentManager.isAgentAttached();
   }
 
   trackChange(

package/front_end/models/comment_manager/CD4ABridge.ts

@@ -132,8 +132,8 @@ export class CD4ABridge extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     });
   }
 
-  takeComments(): CommentThread[] {
-    return this.getCommentThreads();
+  setAgentAttached(value: boolean): void {
+    this.#commentManager.setAgentAttached(value);
   }
 
   resolveCommentThread(threadId: string, replyText?: string): boolean {

package/front_end/models/comment_manager/CommentManager.ts

@@ -32,11 +32,13 @@ export {
 export const enum Events {
   COMMENT_THREADS_CHANGED = 'CommentThreadsChanged',
   COMMENT_MODE_CHANGED = 'CommentModeChanged',
+  AGENT_ATTACHED_CHANGED = 'AgentAttachedChanged',
 }
 
 export interface EventTypes {
   [Events.COMMENT_THREADS_CHANGED]: CommentThread[];
   [Events.COMMENT_MODE_CHANGED]: boolean;
+  [Events.AGENT_ATTACHED_CHANGED]: boolean;
 }
 
 /**
@@ -45,6 +47,7 @@ export interface EventTypes {
 export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #commentThreads = new Map<string, CommentThread>();
   #commentMode = false;
+  #agentAttached = false;
 
   constructor() {
     super();
@@ -55,6 +58,21 @@ export class CommentManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.dispatchEventToListeners(Events.COMMENT_THREADS_CHANGED, this.getCommentThreads());
   }
 
+  setAgentAttached(value: boolean): void {
+    if (this.#agentAttached === value) {
+      return;
+    }
+    this.#agentAttached = value;
+    if (!value) {
+      this.setCommentMode(false);
+    }
+    this.dispatchEventToListeners(Events.AGENT_ATTACHED_CHANGED, value);
+  }
+
+  isAgentAttached(): boolean {
+    return this.#agentAttached;
+  }
+
   setCommentMode(active: boolean): void {
     if (this.#commentMode === active) {
       return;

package/front_end/models/emulation/DeviceModeModel.ts

@@ -70,7 +70,7 @@ const UIStrings = {
    * @description Error message shown on the Devices settings tab when the user enters an invalid
    * device pixel ratio for a custom device.
    */
-  devicePixelRatioMustBeANumberOr: 'Device pixel ratio must be a number or blank.',
+  devicePixelRatioMustBeANumberOr: 'Device pixel ratio must be a number or blank',
   /**
    * @description Error message shown on the Devices settings tab when the user enters a device
    * pixel ratio for a custom device that is too large.

package/front_end/models/extensions/ExtensionAPI.ts

@@ -1586,8 +1586,10 @@ globalThis.injectedExtensionAPI = function(
     const targetDocument = targetWindowForTest?.document ?? document;
     const focused = targetDocument.activeElement;
     if (focused) {
-      const isInput =
-          focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' || (focused as HTMLElement).isContentEditable;
+      // Elements made editable through the EditContext API are not reported as contentEditable.
+      const hasEditContext = 'editContext' in focused && Boolean(focused.editContext);
+      const isInput = focused.nodeName === 'INPUT' || focused.nodeName === 'TEXTAREA' ||
+          (focused as HTMLElement).isContentEditable || hasEditContext;
       if (isInput && !(requestPayload.ctrlKey || requestPayload.altKey || requestPayload.metaKey)) {
         return;
       }

package/front_end/models/issues_manager/CookieIssue.ts

@@ -306,8 +306,6 @@ export function isCausedByThirdParty(
   //     site. Only cookies that have their domain also set to this third-party
   //     are included in the request. We assume that the cookie was set by the same
   //     third-party at some point, so we treat this as a third-party issue.
-  //
-  // TODO(crbug.com/1080589): Use "First-Party sets" instead of the sites registered domain.
   return !isSubdomainOf(parsedCookieUrl.domain(), outermostFrame.domainAndRegistry());
 }
 
@@ -403,11 +401,6 @@ const excludeDomainNonAscii: LazyMarkdownIssueDescription = {
   links: [],
 };
 
-const excludeBlockedWithinRelatedWebsiteSet: LazyMarkdownIssueDescription = {
-  file: 'cookieExcludeBlockedWithinRelatedWebsiteSet.md',
-  links: [],
-};
-
 const cookieCrossSiteRedirectDowngrade: LazyMarkdownIssueDescription = {
   file: 'cookieCrossSiteRedirectDowngrade.md',
   links: [{
@@ -451,14 +444,6 @@ const issueDescriptions = new Map<string, LazyMarkdownIssueDescription>([
   ['CookieIssue::WarnDomainNonASCII::SetCookie', warnDomainNonAscii],
   ['CookieIssue::ExcludeDomainNonASCII::ReadCookie', excludeDomainNonAscii],
   ['CookieIssue::ExcludeDomainNonASCII::SetCookie', excludeDomainNonAscii],
-  [
-    'CookieIssue::ExcludeThirdPartyCookieBlockedInRelatedWebsiteSet::ReadCookie',
-    excludeBlockedWithinRelatedWebsiteSet,
-  ],
-  [
-    'CookieIssue::ExcludeThirdPartyCookieBlockedInRelatedWebsiteSet::SetCookie',
-    excludeBlockedWithinRelatedWebsiteSet,
-  ],
   ['CookieIssue::WarnThirdPartyPhaseout::ReadCookie', placeholderDescriptionForInvisibleIssues],
   ['CookieIssue::WarnThirdPartyPhaseout::SetCookie', placeholderDescriptionForInvisibleIssues],
   ['CookieIssue::WarnDeprecationTrialMetadata::ReadCookie', placeholderDescriptionForInvisibleIssues],

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -9,6 +9,7 @@ import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Bindings from '../bindings/bindings.js';
 import * as Breakpoints from '../breakpoints/breakpoints.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -431,8 +432,32 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   isUISourceCodeOverridable(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return uiSourceCode.project().type() === Workspace.Workspace.projectTypes.Network &&
-        !NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url());
+    if (uiSourceCode.project().type() !== Workspace.Workspace.projectTypes.Network) {
+      return false;
+    }
+    if (NetworkPersistenceManager.isForbiddenNetworkUrl(uiSourceCode.url())) {
+      return false;
+    }
+    // A `//# sourceURL=` annotation is fully controlled by the page and doesn't refer
+    // to an actual network resource, so there is nothing to override here. Persisting
+    // it would poison the overrides folder with a file that masquerades as a genuine
+    // resource (b/553931271).
+    if (Bindings.NetworkProject.NetworkProject.isSourceURLSynthesized(uiSourceCode)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Whether the contents of `uiSourceCode` may be written into the overrides folder.
+   *
+   * Sources that originate from a source map are overridable in the sense that the
+   * deployed resource they are mapped from can be overridden (see
+   * `PersistenceActions`), but their own URL and content are page controlled and
+   * must never be persisted themselves (b/553931271).
+   */
+  #canPersistUISourceCodeAsOverride(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return this.isUISourceCodeOverridable(uiSourceCode) && !uiSourceCode.contentType().isFromSourceMap();
   }
 
   #isUISourceCodeAlreadyOverridden(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
@@ -445,12 +470,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   #canSaveUISourceCodeForOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
-    return this.#active && this.isUISourceCodeOverridable(uiSourceCode) &&
+    return this.#active && this.#canPersistUISourceCodeAsOverride(uiSourceCode) &&
         !this.#isUISourceCodeAlreadyOverridden(uiSourceCode);
   }
 
   async setupAndStartLocalOverrides(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<boolean> {
-    if (!this.isUISourceCodeOverridable(uiSourceCode)) {
+    if (!this.#canPersistUISourceCodeAsOverride(uiSourceCode)) {
       return false;
     }
     // No overrides folder, set it up

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
 import * as Protocol from '../../generated/protocol.js';
@@ -380,9 +381,16 @@ export const resolveScopeChain =
             return scopeChain;
           }
 
-          // TODO(crbug.com/465968290): Re-enable creating the scope chain from the source map once:
-          //    1) We have a flag indicating whether the source map contained variable/binding information.
-          //    2) We have a chrome feature flag.
+          if (Root.Runtime.hostConfig.devToolsSourceMapScopesInSourcesPanel?.enabled) {
+            let sourceMap = callFrame.script.sourceMap();
+            if (!sourceMap && callFrame.debuggerModel?.sourceMapManager) {
+              sourceMap = await callFrame.debuggerModel.sourceMapManager().sourceMapForClientPromise(callFrame.script);
+            }
+            const mappedScopeChain = sourceMap?.resolveScopeChain(callFrame);
+            if (mappedScopeChain) {
+              return mappedScopeChain;
+            }
+          }
 
           if (callFrame.script.isWasm()) {
             return callFrame.scopeChain().filter(scope => !scope.empty());
@@ -537,6 +545,7 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   /** The resolved `this` of the current call frame */
   readonly #thisObject: SDK.RemoteObject.RemoteObject|null;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #object?: SDK.RemoteObject.RemoteObject;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry, thisObject: SDK.RemoteObject.RemoteObject|null,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -566,7 +575,10 @@ class ScopeWithSourceMappedVariables implements SDK.DebuggerModel.ScopeChainEntr
   }
 
   object(): SDK.RemoteObject.RemoteObject {
-    return resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    if (!this.#object) {
+      this.#object = resolveScopeInObject(this.#debuggerScope, this.#debuggerWorkspaceBinding);
+    }
+    return this.#object;
   }
 
   description(): string {
@@ -591,6 +603,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   private readonly scope: SDK.DebuggerModel.ScopeChainEntry;
   private readonly object: SDK.RemoteObject.RemoteObject;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #allPropertiesPromise?: Promise<SDK.RemoteObject.GetPropertiesResult>;
+  #cachedWithPreview = false;
 
   constructor(scope: SDK.DebuggerModel.ScopeChainEntry,
               debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
@@ -642,6 +656,18 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async getAllProperties(accessorPropertiesOnly: boolean, generatePreview: boolean):
       Promise<SDK.RemoteObject.GetPropertiesResult> {
+    if (accessorPropertiesOnly) {
+      return await this.#resolveAllProperties(true, generatePreview);
+    }
+    if (!this.#allPropertiesPromise || (generatePreview && !this.#cachedWithPreview)) {
+      this.#cachedWithPreview = generatePreview;
+      this.#allPropertiesPromise = this.#resolveAllProperties(false, generatePreview);
+    }
+    return await this.#allPropertiesPromise;
+  }
+
+  async #resolveAllProperties(accessorPropertiesOnly: boolean,
+                              generatePreview: boolean): Promise<SDK.RemoteObject.GetPropertiesResult> {
     const allProperties = await this.object.getAllProperties(accessorPropertiesOnly, generatePreview);
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
@@ -656,6 +682,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
 
   override async setPropertyValue(argumentName: string|Protocol.Runtime.CallArgument, value: string):
       Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     const {variableMapping} = await resolveDebuggerScope(this.scope, this.#debuggerWorkspaceBinding);
 
     let name;
@@ -676,6 +704,8 @@ export class RemoteObject extends SDK.RemoteObject.RemoteObject {
   }
 
   override async deleteProperty(name: Protocol.Runtime.CallArgument): Promise<string|undefined> {
+    this.#allPropertiesPromise = undefined;
+    this.#cachedWithPreview = false;
     return await this.object.deleteProperty(name);
   }