chrome-devtools-frontend 1.0.1717709 → 1.0.1721762

package/front_end/core/sdk/CSSMatchedStyles.ts

@@ -27,6 +27,7 @@ import {
   EnvFunctionMatcher,
   FlexGridGridLanesMatcher,
   GridTemplateMatcher,
+  ImportantMatcher,
   LengthMatcher,
   LightDarkColorMatcher,
   LinearGradientMatcher,
@@ -140,6 +141,10 @@ function cleanUserAgentPayload(payload: Protocol.CSS.RuleMatch[]): Protocol.CSS.
   }
 }
 
+function parseCustomHighlightName(selectorText: string): string|null {
+  return selectorText.match(/::highlight\(([^)]+)\)/)?.[1] ?? null;
+}
+
 /**
  * Return a mapping of the highlight names in the specified RuleMatch to
  * the indices of selectors in that selector list with that highlight name.
@@ -164,15 +169,15 @@ function cleanUserAgentPayload(payload: Protocol.CSS.RuleMatch[]): Protocol.CSS.
  * list associated with ruleMatch. The indices correspond to the selectors in the rule
  * associated with the key's highlight name.
  */
-function customHighlightNamesToMatchingSelectorIndices(ruleMatch: Protocol.CSS.RuleMatch): Map<string, number[]> {
+function customHighlightNamesToMatchingSelectorIndices(ruleMatch: Protocol.CSS.RuleMatch,
+                                                       highlightNames: Set<string>): Map<string, number[]> {
   const highlightNamesToMatchingSelectors = new Map<string, number[]>();
 
   for (let i = 0; i < ruleMatch.matchingSelectors.length; i++) {
     const matchingSelectorIndex = ruleMatch.matchingSelectors[i];
     const selectorText = ruleMatch.rule.selectorList.selectors[matchingSelectorIndex].text;
-    const highlightNameMatch = selectorText.match(/::highlight\((.*)\)/);
-    if (highlightNameMatch) {
-      const highlightName = highlightNameMatch[1];
+    const highlightName = parseCustomHighlightName(selectorText);
+    if (highlightName) {
       const selectorsForName = highlightNamesToMatchingSelectors.get(highlightName);
       if (selectorsForName) {
         selectorsForName.push(matchingSelectorIndex);
@@ -181,9 +186,36 @@ function customHighlightNamesToMatchingSelectorIndices(ruleMatch: Protocol.CSS.R
       }
     }
   }
+
+  const universalSelectors = highlightNamesToMatchingSelectors.get('*');
+  if (universalSelectors) {
+    for (const highlightName of highlightNames) {
+      const selectorsForName = highlightNamesToMatchingSelectors.get(highlightName) ?? [];
+      highlightNamesToMatchingSelectors.set(highlightName, [...selectorsForName, ...universalSelectors]);
+    }
+  }
   return highlightNamesToMatchingSelectors;
 }
 
+function getCustomHighlightNames(pseudoPayload: Protocol.CSS.PseudoElementMatches[]): Set<string> {
+  const highlightNames = new Set<string>();
+  for (const entryPayload of pseudoPayload) {
+    if (entryPayload.pseudoType !== Protocol.DOM.PseudoType.Highlight || !entryPayload.matches) {
+      continue;
+    }
+    for (const ruleMatch of entryPayload.matches) {
+      for (const matchingSelectorIndex of ruleMatch.matchingSelectors) {
+        const selectorText = ruleMatch.rule.selectorList.selectors[matchingSelectorIndex].text;
+        const highlightName = parseCustomHighlightName(selectorText);
+        if (highlightName && highlightName !== '*') {
+          highlightNames.add(highlightName);
+        }
+      }
+    }
+  }
+  return highlightNames;
+}
+
 function queryMatches(style: CSSStyleDeclaration): boolean {
   if (!style.parentRule) {
     return true;
@@ -564,13 +596,14 @@ export class CSSMatchedStyles {
    * This helper function takes a list of rule matches and generates separate NodeCascades
    * for each custom highlight name that was matched.
    */
-  private buildSplitCustomHighlightCascades(
-      rules: Protocol.CSS.RuleMatch[], node: DOMNode, isInherited: boolean,
-      pseudoCascades: Map<string, NodeCascade[]>): void {
+  private buildSplitCustomHighlightCascades(rules: Protocol.CSS.RuleMatch[], node: DOMNode, isInherited: boolean,
+                                            highlightNames: Set<string>,
+                                            pseudoCascades: Map<string, NodeCascade[]>): void {
     const splitHighlightRules = new Map<string, CSSStyleDeclaration[]>();
 
     for (let j = rules.length - 1; j >= 0; --j) {
-      const highlightNamesToMatchingSelectorIndices = customHighlightNamesToMatchingSelectorIndices(rules[j]);
+      const highlightNamesToMatchingSelectorIndices =
+          customHighlightNamesToMatchingSelectorIndices(rules[j], highlightNames);
 
       for (const [highlightName, matchingSelectors] of highlightNamesToMatchingSelectorIndices) {
         const pseudoRule = new CSSStyleRule(this.#cssModel, rules[j].rule);
@@ -613,6 +646,8 @@ export class CSSMatchedStyles {
 
     const pseudoCascades = new Map<Protocol.DOM.PseudoType, NodeCascade[]>();
     const customHighlightPseudoCascades = new Map<string, NodeCascade[]>();
+    const highlightNames = getCustomHighlightNames(
+        [...pseudoPayload, ...(inheritedPseudoPayload || []).flatMap(entry => entry.pseudoElements)]);
     for (let i = 0; i < pseudoPayload.length; ++i) {
       const entryPayload = pseudoPayload[i];
       // PseudoElement nodes are not created unless "content" css property is set.
@@ -621,8 +656,8 @@ export class CSSMatchedStyles {
       const rules = entryPayload.matches || [];
 
       if (entryPayload.pseudoType === Protocol.DOM.PseudoType.Highlight) {
-        this.buildSplitCustomHighlightCascades(
-            rules, this.#node, false /* #isInherited */, customHighlightPseudoCascades);
+        this.buildSplitCustomHighlightCascades(rules, this.#node, false /* #isInherited */, highlightNames,
+                                               customHighlightPseudoCascades);
       } else {
         for (let j = rules.length - 1; j >= 0; --j) {
           const pseudoRule = new CSSStyleRule(this.#cssModel, rules[j].rule);
@@ -651,8 +686,8 @@ export class CSSMatchedStyles {
           const rules = inheritedEntryPayload.matches || [];
 
           if (inheritedEntryPayload.pseudoType === Protocol.DOM.PseudoType.Highlight) {
-            this.buildSplitCustomHighlightCascades(
-                rules, parentNode, true /* #isInherited */, customHighlightPseudoCascades);
+            this.buildSplitCustomHighlightCascades(rules, parentNode, true /* #isInherited */, highlightNames,
+                                                   customHighlightPseudoCascades);
           } else {
             const pseudoStyles = [];
             for (let k = rules.length - 1; k >= 0; --k) {
@@ -1490,19 +1525,23 @@ class DOMInheritanceCascade {
       return null;
     }
 
-    if (definedValue.declaration.declaration instanceof CSSProperty && definedValue.declaration.value &&
-        CSSMetadata.isCSSWideKeyword(definedValue.declaration.value)) {
-      const resolvedProperty =
-          this.resolveGlobalKeyword(definedValue.declaration.declaration, definedValue.declaration.value);
+    while (definedValue.declaration.declaration instanceof CSSProperty && definedValue.declaration.value) {
+      const value = PropertyParser
+                        .matchDeclaration(`--${variableName}`, definedValue.declaration.value, [new ImportantMatcher()])
+                        ?.getComputedPropertyValueText()
+                        .trim();
+      if (!value || !CSSMetadata.isCSSWideKeyword(value)) {
+        break;
+      }
+      const resolvedProperty = this.resolveGlobalKeyword(definedValue.declaration.declaration, value);
       if (!resolvedProperty) {
         return definedValue;
       }
       const declaration = new CSSValueSource(resolvedProperty);
-      const {value} = declaration;
-      if (!value) {
+      if (!declaration.value) {
         return definedValue;
       }
-      definedValue = {declaration, value};
+      definedValue = {declaration, value: declaration.value};
     }
 
     const ast = PropertyParser.tokenizeDeclaration(`--${variableName}`, definedValue.value);
@@ -1623,9 +1662,10 @@ class DOMInheritanceCascade {
             }
             return evaluateFallback(match.fallback, match.matching);
           }),
+      ...(declaration ? [new ImportantMatcher()] : []),
     ]);
     const decl = PropertyParser.ASTUtils.siblings(PropertyParser.ASTUtils.declValue(matching.ast.tree));
-    const declText = decl.length > 0 ? matching.getComputedTextRange(decl[0], decl[decl.length - 1]) : '';
+    const declText = decl.length > 0 ? matching.getComputedTextRange(decl[0], decl[decl.length - 1]).trim() : '';
     const hasUnresolvedSubstitutions =
         decl.length > 0 && matching.hasUnresolvedSubstitutionsRange(decl[0], decl[decl.length - 1]);
     const computedText = hasUnresolvedSubstitutions ? null : declText;

package/front_end/core/sdk/CSSProperty.ts

@@ -18,7 +18,7 @@ import {
   type Matcher,
   stripComments,
 } from './CSSPropertyParser.js';
-import {CSSWideKeywordMatcher} from './CSSPropertyParserMatchers.js';
+import {CSSWideKeywordMatcher, ImportantMatcher} from './CSSPropertyParserMatchers.js';
 import type {CSSStyleDeclaration} from './CSSStyleDeclaration.js';
 import {textEditorIndentSettingDescriptor} from './SDKSettings.js';
 
@@ -114,7 +114,7 @@ export class CSSProperty extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   #matchers(matchedStyles: CSSMatchedStyles, computedStyles: Map<string, string>|null): Array<Matcher<Match>> {
     const matchers = matchedStyles.propertyMatchers(this.ownerStyle, computedStyles);
 
-    matchers.push(new CSSWideKeywordMatcher(this, matchedStyles));
+    matchers.push(new CSSWideKeywordMatcher(this, matchedStyles), new ImportantMatcher());
     return matchers;
   }
 

package/front_end/core/sdk/CSSPropertyParserMatchers.ts

@@ -360,6 +360,19 @@ export class TextMatcher extends TextMatcherBase {
   }
 }
 
+export class ImportantMatch extends TextMatch {
+  override computedText = (): string => '';
+}
+
+const ImportantMatcherBase: MatcherClass<ImportantMatch> = matcherBase(ImportantMatch);
+// clang-format off
+export class ImportantMatcher extends ImportantMatcherBase {
+  // clang-format on
+  override matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): ImportantMatch|null {
+    return node.name === 'Important' ? new ImportantMatch(matching.ast.text(node), node) : null;
+  }
+}
+
 export class AngleMatch implements Match {
   constructor(readonly text: string, readonly node: CodeMirror.SyntaxNode) {
   }
@@ -1167,14 +1180,15 @@ export class FlexGridGridLanesMatcher extends FlexGridGridLanesMatcherBase {
                        .map(node => matching.getComputedText(node).trim())
                        .filter(value => value);
     const text = values.join(' ');
+    const valueText = matching.ast.textRange(valueNodes[0], valueNodes[valueNodes.length - 1]);
     if (FlexGridGridLanesMatcher.FLEX.includes(text)) {
-      return new FlexGridGridLanesMatch(matching.ast.text(node), node, LayoutType.FLEX);
+      return new FlexGridGridLanesMatch(valueText, node, LayoutType.FLEX);
     }
     if (FlexGridGridLanesMatcher.GRID.includes(text)) {
-      return new FlexGridGridLanesMatch(matching.ast.text(node), node, LayoutType.GRID);
+      return new FlexGridGridLanesMatch(valueText, node, LayoutType.GRID);
     }
     if (FlexGridGridLanesMatcher.GRID_LANES.includes(text)) {
-      return new FlexGridGridLanesMatch(matching.ast.text(node), node, LayoutType.GRID_LANES);
+      return new FlexGridGridLanesMatch(valueText, node, LayoutType.GRID_LANES);
     }
     return null;
   }
@@ -1360,7 +1374,11 @@ export class CSSWideKeywordMatch implements Match {
     return this.matchedStyles.resolveGlobalKeyword(this.property, this.text);
   }
   computedText?(): string|null {
-    return this.resolveProperty()?.value ?? null;
+    return this.resolveProperty()
+               ?.declaration.parseValue(this.matchedStyles, null)
+               ?.getComputedPropertyValueText()
+               .trim() ??
+        null;
   }
 }
 
@@ -1379,6 +1397,7 @@ export class CSSWideKeywordMatcher extends CSSWideKeywordMatcherBase {
     }
 
     if (Array.from(ASTUtils.stripComments(ASTUtils.siblings(ASTUtils.declValue(parentNode))))
+            .filter(child => child.name !== 'Important')
             .some(child => !ASTUtils.equals(child, node))) {
       return null;
     }
@@ -1416,18 +1435,17 @@ export class PositionTryMatcher extends PositionTryMatcherBase {
     let preamble: CodeMirror.SyntaxNode[] = [];
     const valueNodes = ASTUtils.siblings(ASTUtils.declValue(node));
     const fallbacks = ASTUtils.split(valueNodes);
-    if (matching.ast.propertyName === LinkableNameProperties.POSITION_TRY) {
       for (const [i, n] of fallbacks[0].entries()) {
         const computedText = matching.getComputedText(n);
         if (CSSMetadata.isCSSWideKeyword(computedText)) {
           return null;
         }
-        if (CSSMetadata.isPositionTryOrderKeyword(computedText)) {
+        if (matching.ast.propertyName === LinkableNameProperties.POSITION_TRY &&
+            CSSMetadata.isPositionTryOrderKeyword(computedText)) {
           preamble = fallbacks[0].splice(0, i + 1);
           break;
         }
       }
-    }
 
     const valueText = matching.ast.textRange(valueNodes[0], valueNodes[valueNodes.length - 1]);
     return new PositionTryMatch(valueText, node, preamble, fallbacks);
@@ -1493,10 +1511,11 @@ export class PositionAreaMatcher extends PositionAreaMatcherBase {
     if (valueNodes.length === 0) {
       return null;
     }
-    const valueText = matching.getComputedTextRange(valueNodes[0], valueNodes[valueNodes.length - 1]);
-    if (CSSMetadata.isCSSWideKeyword(valueText)) {
+    const computedText = matching.getComputedTextRange(valueNodes[0], valueNodes[valueNodes.length - 1]).trim();
+    if (CSSMetadata.isCSSWideKeyword(computedText)) {
       return null;
     }
+    const valueText = matching.ast.textRange(valueNodes[0], valueNodes[valueNodes.length - 1]);
     return new PositionAreaMatch(valueText, node);
   }
 }

package/front_end/core/sdk/NetworkManager.ts

@@ -763,6 +763,11 @@ export class FetchDispatcher implements ProtocolProxyApi.FetchDispatcher {
   }
 }
 
+function multicastMembership(event: Pick<Protocol.Network.DirectUDPSocketJoinedMulticastGroupEvent, 'IPAddress'>&
+                             {sourceAddress?: string}): string {
+  return event.sourceAddress ? `${event.IPAddress}@${event.sourceAddress}` : event.IPAddress;
+}
+
 export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   readonly #manager: NetworkManager;
   readonly #multitargetNetworkManager: MultitargetNetworkManager;
@@ -1743,8 +1748,9 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
     if (!networkRequest.directSocketInfo.joinedMulticastGroups) {
       networkRequest.directSocketInfo.joinedMulticastGroups = new Set();
     }
-    if (!networkRequest.directSocketInfo.joinedMulticastGroups.has(event.IPAddress)) {
-      networkRequest.directSocketInfo.joinedMulticastGroups.add(event.IPAddress);
+    const membership = multicastMembership(event);
+    if (!networkRequest.directSocketInfo.joinedMulticastGroups.has(membership)) {
+      networkRequest.directSocketInfo.joinedMulticastGroups.add(membership);
       this.updateNetworkRequest(networkRequest);
     }
   }
@@ -1754,7 +1760,7 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
     if (!networkRequest?.directSocketInfo?.joinedMulticastGroups) {
       return;
     }
-    if (networkRequest.directSocketInfo.joinedMulticastGroups.delete(event.IPAddress)) {
+    if (networkRequest.directSocketInfo.joinedMulticastGroups.delete(multicastMembership(event))) {
       this.updateNetworkRequest(networkRequest);
     }
   }

package/front_end/core/sdk/OverlayModel.ts

@@ -887,12 +887,10 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
     return await this.#windowControls.initializeStyleSheetText(url);
   }
 
-  inspectPanelShowRequested({backendNodeId}: Protocol.Overlay.InspectPanelShowRequestedEvent): void {
-    this.dispatchEventToListeners(Events.INSPECT_PANEL_SHOW_REQUESTED, backendNodeId);
+  inspectPanelShowRequested(_event: Protocol.Overlay.InspectPanelShowRequestedEvent): void {
   }
 
-  inspectedElementWindowRestored({backendNodeId}: Protocol.Overlay.InspectedElementWindowRestoredEvent): void {
-    this.dispatchEventToListeners(Events.INSPECTED_ELEMENT_WINDOW_RESTORED, backendNodeId);
+  inspectedElementWindowRestored(_event: Protocol.Overlay.InspectedElementWindowRestoredEvent): void {
   }
 }
 
@@ -1028,8 +1026,6 @@ export const enum Events {
   PERSISTENT_FLEX_CONTAINER_OVERLAY_STATE_CHANGED = 'PersistentFlexContainerOverlayStateChanged',
   PERSISTENT_SCROLL_SNAP_OVERLAY_STATE_CHANGED = 'PersistentScrollSnapOverlayStateChanged',
   PERSISTENT_CONTAINER_QUERY_OVERLAY_STATE_CHANGED = 'PersistentContainerQueryOverlayStateChanged',
-  INSPECT_PANEL_SHOW_REQUESTED = 'InspectPanelShowRequested',
-  INSPECTED_ELEMENT_WINDOW_RESTORED = 'InspectedElementWindowRestored',
 }
 
 export interface ChangedNodeId {
@@ -1046,8 +1042,6 @@ export interface EventTypes {
   [Events.PERSISTENT_FLEX_CONTAINER_OVERLAY_STATE_CHANGED]: ChangedNodeId;
   [Events.PERSISTENT_SCROLL_SNAP_OVERLAY_STATE_CHANGED]: ChangedNodeId;
   [Events.PERSISTENT_CONTAINER_QUERY_OVERLAY_STATE_CHANGED]: ChangedNodeId;
-  [Events.INSPECT_PANEL_SHOW_REQUESTED]: number;
-  [Events.INSPECTED_ELEMENT_WINDOW_RESTORED]: number;
 }
 
 export interface Highlighter {

package/front_end/core/sdk/PrivateVerificationTokensModel.ts

@@ -0,0 +1,79 @@
+// 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 ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+export class PrivateVerificationTokensModel extends SDKModel<EventTypes> implements ProtocolProxyApi.StorageDispatcher {
+  readonly #storageAgent: ProtocolProxyApi.StorageApi;
+
+  constructor(target: Target) {
+    super(target);
+    target.registerStorageDispatcher(this);
+    this.#storageAgent = target.storageAgent();
+  }
+
+  setTracking(enable: boolean): void {
+    void this.#storageAgent.invoke_setPrivateVerificationTokensTracking({enable});
+  }
+
+  async getTokens(): Promise<Protocol.Storage.PrivateVerificationToken[]> {
+    const response = await this.#storageAgent.invoke_getPrivateVerificationTokens();
+    if (response.getError()) {
+      return [];
+    }
+    return response.tokens ?? [];
+  }
+
+  async getIssuerConfigs(): Promise<Protocol.Storage.PrivateVerificationTokensIssuerConfig[]> {
+    const response = await this.#storageAgent.invoke_getPrivateVerificationTokensIssuerConfigs();
+    if (response.getError()) {
+      return [];
+    }
+    return response.configs ?? [];
+  }
+
+  async clearTokens(issuerOrigin: string): Promise<void> {
+    await this.#storageAgent.invoke_clearPrivateVerificationTokens({issuerOrigin});
+  }
+
+  async deleteToken(tokenId: string): Promise<void> {
+    await this.#storageAgent.invoke_deletePrivateVerificationToken({tokenId});
+  }
+
+  privateVerificationTokensUpdated(): void {
+    this.dispatchEventToListeners(Events.TOKENS_UPDATED);
+  }
+
+  cacheStorageContentUpdated(_event: Protocol.Storage.CacheStorageContentUpdatedEvent): void {
+  }
+
+  cacheStorageListUpdated(_event: Protocol.Storage.CacheStorageListUpdatedEvent): void {
+  }
+
+  indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void {
+  }
+
+  indexedDBListUpdated(_event: Protocol.Storage.IndexedDBListUpdatedEvent): void {
+  }
+
+  storageBucketCreatedOrUpdated(_event: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void {
+  }
+
+  storageBucketDeleted(_event: Protocol.Storage.StorageBucketDeletedEvent): void {
+  }
+}
+
+SDKModel.register(PrivateVerificationTokensModel, {capabilities: Capability.STORAGE, autostart: false});
+
+export const enum Events {
+  TOKENS_UPDATED = 'TokensUpdated',
+}
+
+export interface EventTypes {
+  [Events.TOKENS_UPDATED]: void;
+}

package/front_end/core/sdk/SecurityOrigin.ts

@@ -113,7 +113,7 @@ export class SecurityOrigin {
 
     if (rawUrl.toLowerCase().startsWith('file://')) {
       const parsed = Common.ParsedURL.ParsedURL.fromString(rawUrl as Platform.DevToolsPath.UrlString);
-      if (!parsed) {
+      if (!parsed || parsed.path === '/') {
         return SecurityOrigin.createUniqueOpaque();
       }
       const authority = parsed.host + (parsed.port ? ':' + parsed.port : '');

package/front_end/core/sdk/SourceMapCache.ts

@@ -4,6 +4,7 @@
 
 import * as Platform from '../platform/platform.js';
 
+import type {SecurityOrigin} from './SecurityOrigin.js';
 import type {DebugId, SourceMapV3} from './SourceMap.js';
 
 /** A thin wrapper around the Cache API to store source map JSONs keyed on Debug IDs */
@@ -27,20 +28,22 @@ export class SourceMapCache {
     this.#name = name;
   }
 
-  async set(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString, sourceMap: SourceMapV3): Promise<void> {
-    if (!securityOrigin || securityOrigin === 'file://') {
+  async set(debugId: DebugId, scriptOrigin: SecurityOrigin, loaderOrigin: SecurityOrigin,
+            sourceMap: SourceMapV3): Promise<void> {
+    if (scriptOrigin.isOpaque() || loaderOrigin.isOpaque()) {
       return;
     }
     const cache = await this.#cache();
-    await cache?.put(SourceMapCache.#urlForDebugId(debugId, securityOrigin), new Response(JSON.stringify(sourceMap)));
+    await cache?.put(SourceMapCache.#urlForDebugId(debugId, scriptOrigin, loaderOrigin),
+                     new Response(JSON.stringify(sourceMap)));
   }
 
-  async get(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString): Promise<SourceMapV3|null> {
-    if (!securityOrigin || securityOrigin === 'file://') {
+  async get(debugId: DebugId, scriptOrigin: SecurityOrigin, loaderOrigin: SecurityOrigin): Promise<SourceMapV3|null> {
+    if (scriptOrigin.isOpaque() || loaderOrigin.isOpaque()) {
       return null;
     }
     const cache = await this.#cache();
-    const response = await cache?.match(SourceMapCache.#urlForDebugId(debugId, securityOrigin));
+    const response = await cache?.match(SourceMapCache.#urlForDebugId(debugId, scriptOrigin, loaderOrigin));
     return (await response?.json() as SourceMapV3 | undefined) ?? null;
   }
 
@@ -58,8 +61,9 @@ export class SourceMapCache {
   }
 
   /** The Cache API only allows URL as keys, so we construct a simple one. Given that we have our own cache, we have no risk of conflicting URLs */
-  static #urlForDebugId(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString): string {
-    return `http://debug.id/${encodeURIComponent(debugId)}?origin=${encodeURIComponent(securityOrigin)}`;
+  static #urlForDebugId(debugId: DebugId, scriptOrigin: SecurityOrigin, loaderOrigin: SecurityOrigin): string {
+    return `http://debug.id/${encodeURIComponent(debugId)}?origin=${encodeURIComponent(scriptOrigin.siteId())}&loader=${
+        encodeURIComponent(loaderOrigin.siteId())}`;
   }
 
   async disposeForTest(): Promise<void> {
@@ -70,21 +74,22 @@ export class SourceMapCache {
 const IN_MEMORY_INSTANCE = new (class implements Pick<SourceMapCache, 'get'|'set'|'disposeForTest'> {
   readonly #cache = new Map<string, SourceMapV3>();
 
-  async set(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString, sourceMap: SourceMapV3): Promise<void> {
-    if (!securityOrigin || securityOrigin === 'file://') {
+  async set(debugId: DebugId, scriptOrigin: SecurityOrigin, loaderOrigin: SecurityOrigin,
+            sourceMap: SourceMapV3): Promise<void> {
+    if (scriptOrigin.isOpaque() || loaderOrigin.isOpaque()) {
       return;
     }
-    this.#cache.set(`${debugId}|${securityOrigin}`, sourceMap);
+    this.#cache.set(`${debugId}|${scriptOrigin.siteId()}|${loaderOrigin.siteId()}`, sourceMap);
   }
 
-  async get(debugId: DebugId, securityOrigin: Platform.DevToolsPath.UrlString): Promise<SourceMapV3|null> {
-    if (!securityOrigin || securityOrigin === 'file://') {
+  async get(debugId: DebugId, scriptOrigin: SecurityOrigin, loaderOrigin: SecurityOrigin): Promise<SourceMapV3|null> {
+    if (scriptOrigin.isOpaque() || loaderOrigin.isOpaque()) {
       return null;
     }
-    return this.#cache.get(`${debugId}|${securityOrigin}`) ?? null;
+    return this.#cache.get(`${debugId}|${scriptOrigin.siteId()}|${loaderOrigin.siteId()}`) ?? null;
   }
 
   async disposeForTest(): Promise<void> {
-    // Do nothing.
+    this.#cache.clear();
   }
 })();

package/front_end/core/sdk/SourceMapManager.ts

@@ -7,6 +7,7 @@ import * as Platform from '../platform/platform.js';
 
 import type {FrameAssociated} from './FrameAssociated.js';
 import {PageResourceLoader, type PageResourceLoadInitiator, type ResourceLoader} from './PageResourceLoader.js';
+import {ResourceTreeModel} from './ResourceTreeModel.js';
 import {SecurityOrigin} from './SecurityOrigin.js';
 import {type DebugId, parseSourceMap, SourceMap, type SourceMapProvenance, type SourceMapV3} from './SourceMap.js';
 import {SourceMapCache} from './SourceMapCache.js';
@@ -216,24 +217,42 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
   }
 }
 
-function getCacheOrigin(initiator: PageResourceLoadInitiator): Platform.DevToolsPath.UrlString|null {
+function getScriptOrigin(initiator: PageResourceLoadInitiator): SecurityOrigin|null {
   if (!initiator.initiatorUrl) {
     return null;
   }
-  const securityOrigin = SecurityOrigin.create(initiator.initiatorUrl);
-  if (securityOrigin.isOpaque() || (securityOrigin.isFile() && securityOrigin.siteId() === 'file:///')) {
+  const origin = SecurityOrigin.create(initiator.initiatorUrl);
+  return origin.isOpaque() ? null : origin;
+}
+
+function getLoaderOrigin(initiator: PageResourceLoadInitiator): SecurityOrigin|null {
+  if (!initiator.target) {
+    return null;
+  }
+  const resourceTreeModel = initiator.target.model(ResourceTreeModel);
+  if (resourceTreeModel) {
+    if (!initiator.frameId) {
+      return null;
+    }
+    const origin = resourceTreeModel.frameForId(initiator.frameId)?.securityOrigin() ?? null;
+    return origin && !origin.isOpaque() ? origin : null;
+  }
+  const targetUrl = initiator.target.inspectedURL() || initiator.target.targetInfo()?.url;
+  if (!targetUrl) {
     return null;
   }
-  return securityOrigin.siteId() as Platform.DevToolsPath.UrlString;
+  const origin = SecurityOrigin.create(targetUrl);
+  return origin.isOpaque() ? null : origin;
 }
 
 async function loadSourceMap(resourceLoader: ResourceLoader, sourceMapCache: SourceMapCache,
                              url: Platform.DevToolsPath.UrlString, debugId: DebugId|null,
                              initiator: PageResourceLoadInitiator): Promise<SourceMapV3> {
   try {
-    const cacheOrigin = debugId ? getCacheOrigin(initiator) : null;
-    if (debugId && cacheOrigin) {
-      const cachedSourceMap = await sourceMapCache.get(debugId, cacheOrigin);
+    const scriptOrigin = debugId ? getScriptOrigin(initiator) : null;
+    const loaderOrigin = debugId ? getLoaderOrigin(initiator) : null;
+    if (debugId && scriptOrigin && loaderOrigin) {
+      const cachedSourceMap = await sourceMapCache.get(debugId, scriptOrigin, loaderOrigin);
       if (cachedSourceMap) {
         return cachedSourceMap;
       }
@@ -241,9 +260,9 @@ async function loadSourceMap(resourceLoader: ResourceLoader, sourceMapCache: Sou
 
     const {content} = await resourceLoader.loadResource(url, initiator);
     const sourceMap = parseSourceMap(content);
-    if (debugId && cacheOrigin && 'debugId' in sourceMap && sourceMap.debugId === debugId) {
+    if (debugId && scriptOrigin && loaderOrigin && 'debugId' in sourceMap && sourceMap.debugId === debugId) {
       // In case something goes wrong with updating the cache, we still want to use the source map.
-      await sourceMapCache.set(sourceMap.debugId as DebugId, cacheOrigin, sourceMap).catch();
+      await sourceMapCache.set(sourceMap.debugId as DebugId, scriptOrigin, loaderOrigin, sourceMap).catch(() => {});
     }
     return sourceMap;
   } catch (cause) {

package/front_end/core/sdk/TargetManager.ts

@@ -264,15 +264,18 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     if (!this.#modelListeners.has(eventType)) {
       return;
     }
-    let wrappedListener = null;
+    const wrappedListeners: Array<Common.EventTarget.EventListener<Events, T>> = [];
     for (const info of this.#modelListeners.get(eventType)) {
       if (info.modelClass === modelClass && info.listener === listener && info.thisObject === thisObject) {
-        wrappedListener = info.wrappedListener;
+        wrappedListeners.push(info.wrappedListener);
         this.#modelListeners.delete(eventType, info);
       }
     }
-    if (wrappedListener) {
-      for (const model of this.models(modelClass)) {
+    if (wrappedListeners.length === 0) {
+      return;
+    }
+    for (const model of this.models(modelClass)) {
+      for (const wrappedListener of wrappedListeners) {
         model.removeEventListener(eventType, wrappedListener);
       }
     }

package/front_end/core/sdk/WebAuthnModel.ts

@@ -30,9 +30,9 @@ export class WebAuthnModel extends SDKModel<EventTypes> {
     target.registerWebAuthnDispatcher(new WebAuthnDispatcher(this));
   }
 
-  setVirtualAuthEnvEnabled(enable: boolean): Promise<Object> {
+  setVirtualAuthEnvEnabled(enable: boolean, enableUI = true): Promise<Object> {
     if (enable) {
-      return this.#agent.invoke_enable({enableUI: true});
+      return this.#agent.invoke_enable({enableUI});
     }
     return this.#agent.invoke_disable();
   }
@@ -52,6 +52,15 @@ export class WebAuthnModel extends SDKModel<EventTypes> {
     await this.#agent.invoke_setAutomaticPresenceSimulation({authenticatorId, enabled});
   }
 
+  async setUserVerified(authenticatorId: Protocol.WebAuthn.AuthenticatorId, isUserVerified: boolean): Promise<void> {
+    await this.#agent.invoke_setUserVerified({authenticatorId, isUserVerified});
+  }
+
+  async addCredential(authenticatorId: Protocol.WebAuthn.AuthenticatorId,
+                      credential: Protocol.WebAuthn.Credential): Promise<void> {
+    await this.#agent.invoke_addCredential({authenticatorId, credential});
+  }
+
   async getCredentials(authenticatorId: Protocol.WebAuthn.AuthenticatorId): Promise<Protocol.WebAuthn.Credential[]> {
     const response = await this.#agent.invoke_getCredentials({authenticatorId});
     return response.credentials;

package/front_end/core/sdk/sdk.ts

@@ -68,6 +68,7 @@ import * as PageResourceLoader from './PageResourceLoader.js';
 import * as PaintProfiler from './PaintProfiler.js';
 import * as PerformanceMetricsModel from './PerformanceMetricsModel.js';
 import * as PreloadingModel from './PreloadingModel.js';
+import * as PrivateVerificationTokensModel from './PrivateVerificationTokensModel.js';
 import * as RehydratingConnection from './RehydratingConnection.js';
 import * as RehydratingObject from './RehydratingObject.js';
 import * as RemoteObject from './RemoteObject.js';
@@ -159,6 +160,7 @@ export {
   PaintProfiler,
   PerformanceMetricsModel,
   PreloadingModel,
+  PrivateVerificationTokensModel,
   RehydratingConnection,  // TODO(crbug.com/444191656): Exported for tests.
   RehydratingObject,
   RemoteObject,