chrome-devtools-frontend 1.0.1717196 → 1.0.1721762

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/CSSPropertyParser.ts

@@ -341,7 +341,7 @@ class ComputedTextChunk {
  * original and computed slices as required.
  **/
 export class ComputedText {
-  readonly #chunks: ComputedTextChunk[] = [];
+  #chunks: ComputedTextChunk[] = [];
   readonly text: string;
   readonly #topLevelValueCounts = new Map<string, number>();
 
@@ -356,6 +356,7 @@ export class ComputedText {
   }
 
   get chunkCount(): number {
+    this.#sortIfNecessary();
     return this.#chunks.length;
   }
 
@@ -363,6 +364,14 @@ export class ComputedText {
     if (this.#sorted) {
       return;
     }
+    // A match that was pushed more than once is superseded by its last push.
+    const lastPush = new Map<Match, ComputedTextChunk>();
+    for (const chunk of this.#chunks) {
+      lastPush.set(chunk.match, chunk);
+    }
+    if (lastPush.size < this.#chunks.length) {
+      this.#chunks = this.#chunks.filter(chunk => lastPush.get(chunk.match) === chunk);
+    }
     // Sort intervals by offset, with longer intervals first if the offset is identical.
     this.#chunks.sort((a, b) => {
       if (a.offset < b.offset) {
@@ -383,7 +392,7 @@ export class ComputedText {
   }
 
   // Add another substitutable match. The match will either be appended to the list of existing matches or it will
-  // be substituted for the last match(es) if it encompasses them.
+  // be substituted for the last match(es) if it encompasses them. Pushing a match again supersedes its earlier push.
   push(match: Match, offset: number): void {
     function hasComputedText(match: Match): match is MatchWithComputedText {
       return Boolean(match.computedText);

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/DOMModel.ts

@@ -1188,7 +1188,7 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
   }
 
   marker<T>(name: string): T|null {
-    return this.#markers.get(name) as T || null;
+    return (this.#markers.get(name) as T) ?? null;
   }
 
   getMarkerKeysForTest(): string[] {

package/front_end/core/sdk/DebuggerModel.ts

@@ -959,6 +959,9 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.#disableAsyncStackTracesSetting.removeChangeListener(this.asyncStackTracesStateChanged, this);
     this.#breakpointsActiveSetting.removeChangeListener(this.breakpointsActiveChanged, this);
     this.#jsSourceMapsEnabledSetting.removeChangeListener(this.jsSourceMapsStateChanged, this);
+    // Drop all scripts and their source maps, so they don't outlive the target in case something
+    // still holds on to this model (e.g. a console message with "Preserve log" enabled).
+    this.reset();
   }
 
   override async suspendModel(): Promise<void> {

package/front_end/core/sdk/EmulationModel.ts

@@ -4,7 +4,7 @@
 
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
-import type * as Common from '../common/common.js';
+import * as Common from '../common/common.js';
 
 import {CSSModel} from './CSSModel.js';
 import type {MultitargetNetworkManager} from './NetworkManager.js';
@@ -59,7 +59,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
   #screenOrientationLocked: boolean;
   #lockedOrientation: Protocol.Emulation.ScreenOrientation|null;
   readonly #dataSaverSetting: Common.Settings.Setting<DataSaverOverride>;
-  readonly #dataSaverChangeListener: () => void;
+  readonly #settingListeners: Common.EventTarget.EventDescriptor[] = [];
 
   constructor(target: Target) {
     super(target);
@@ -78,22 +78,22 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
 
     const settings = this.target().targetManager().settings;
     const disableJavascriptSetting = settings.resolve(javaScriptDisabledSettingDescriptor);
-    disableJavascriptSetting.addChangeListener(
+    this.#settingListeners.push(disableJavascriptSetting.addChangeListener(
         async () =>
-            await this.#emulationAgent.invoke_setScriptExecutionDisabled({value: disableJavascriptSetting.get()}));
+            await this.#emulationAgent.invoke_setScriptExecutionDisabled({value: disableJavascriptSetting.get()})));
     if (disableJavascriptSetting.get()) {
       void this.#emulationAgent.invoke_setScriptExecutionDisabled({value: true});
     }
 
     const touchSetting = settings.resolve(touchSettingDescriptor);
-    touchSetting.addChangeListener(() => {
+    this.#settingListeners.push(touchSetting.addChangeListener(() => {
       const settingValue = touchSetting.get();
 
       void this.overrideEmulateTouch(settingValue === 'force');
-    });
+    }));
 
     const idleDetectionSetting = settings.resolve(idleDetectionSettingDescriptor);
-    idleDetectionSetting.addChangeListener(async () => {
+    this.#settingListeners.push(idleDetectionSetting.addChangeListener(async () => {
       const settingValue = idleDetectionSetting.get();
       if (settingValue === 'none') {
         await this.clearIdleOverride();
@@ -105,10 +105,10 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
         isScreenUnlocked: boolean,
       });
       await this.setIdleOverride(emulationParams);
-    });
+    }));
 
     const cpuPressureDetectionSetting = settings.resolve(cpuPressureSettingDescriptor);
-    cpuPressureDetectionSetting.addChangeListener(async () => {
+    this.#settingListeners.push(cpuPressureDetectionSetting.addChangeListener(async () => {
       const settingValue = cpuPressureDetectionSetting.get();
 
       if (settingValue === 'none') {
@@ -123,7 +123,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       }
 
       await this.setPressureStateOverride(settingValue);
-    });
+    }));
 
     const mediaTypeSetting = settings.resolve(emulatedCSSMediaSettingDescriptor);
     const mediaFeatureColorGamutSetting = settings.resolve(emulatedCSSMediaFeatureColorGamutSettingDescriptor);
@@ -152,67 +152,69 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       ['prefers-reduced-motion', mediaFeaturePrefersReducedMotionSetting.get()],
       ['prefers-reduced-transparency', mediaFeaturePrefersReducedTransparencySetting.get()],
     ]);
-    mediaTypeSetting.addChangeListener(() => {
+    this.#settingListeners.push(mediaTypeSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('type', mediaTypeSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeatureColorGamutSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeatureColorGamutSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('color-gamut', mediaFeatureColorGamutSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeaturePrefersColorSchemeSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeaturePrefersColorSchemeSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('prefers-color-scheme', mediaFeaturePrefersColorSchemeSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeatureForcedColorsSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeatureForcedColorsSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('forced-colors', mediaFeatureForcedColorsSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeaturePrefersContrastSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeaturePrefersContrastSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('prefers-contrast', mediaFeaturePrefersContrastSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeaturePrefersReducedDataSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeaturePrefersReducedDataSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('prefers-reduced-data', mediaFeaturePrefersReducedDataSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeaturePrefersReducedMotionSetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeaturePrefersReducedMotionSetting.addChangeListener(() => {
       this.#mediaConfiguration.set('prefers-reduced-motion', mediaFeaturePrefersReducedMotionSetting.get());
       void this.updateCssMedia();
-    });
-    mediaFeaturePrefersReducedTransparencySetting.addChangeListener(() => {
+    }));
+    this.#settingListeners.push(mediaFeaturePrefersReducedTransparencySetting.addChangeListener(() => {
       this.#mediaConfiguration.set('prefers-reduced-transparency', mediaFeaturePrefersReducedTransparencySetting.get());
       void this.updateCssMedia();
-    });
+    }));
     void this.updateCssMedia();
 
     const autoDarkModeSetting = settings.resolve(emulateAutoDarkModeSettingDescriptor);
-    autoDarkModeSetting.addChangeListener(() => {
+    this.#settingListeners.push(autoDarkModeSetting.addChangeListener(() => {
       const enabled = autoDarkModeSetting.get();
       mediaFeaturePrefersColorSchemeSetting.set(enabled ? 'dark' : '');
       void this.emulateAutoDarkMode(enabled);
-    });
+    }));
     if (autoDarkModeSetting.get()) {
       mediaFeaturePrefersColorSchemeSetting.set('dark');
       void this.emulateAutoDarkMode(true);
     }
 
     const visionDeficiencySetting = settings.resolve(emulatedVisionDeficiencySettingDescriptor);
-    visionDeficiencySetting.addChangeListener(() => this.emulateVisionDeficiency(visionDeficiencySetting.get()));
+    this.#settingListeners.push(
+        visionDeficiencySetting.addChangeListener(() => this.emulateVisionDeficiency(visionDeficiencySetting.get())));
     if (visionDeficiencySetting.get()) {
       void this.emulateVisionDeficiency(visionDeficiencySetting.get());
     }
 
     const osTextScaleSetting = settings.resolve(emulatedOSTextScaleSettingDescriptor);
-    osTextScaleSetting.addChangeListener(() => {
+    this.#settingListeners.push(osTextScaleSetting.addChangeListener(() => {
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
-    });
+    }));
     if (osTextScaleSetting.get()) {
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
     }
 
     const localFontsDisabledSetting = settings.resolve(localFontsDisabledSettingDescriptor);
-    localFontsDisabledSetting.addChangeListener(() => this.setLocalFontsDisabled(localFontsDisabledSetting.get()));
+    this.#settingListeners.push(
+        localFontsDisabledSetting.addChangeListener(() => this.setLocalFontsDisabled(localFontsDisabledSetting.get())));
     if (localFontsDisabledSetting.get()) {
       this.setLocalFontsDisabled(localFontsDisabledSetting.get());
     }
@@ -235,19 +237,18 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       this.setDisabledImageTypes(types);
     };
 
-    avifFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
-    jpegXlFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
-    webpFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
+    this.#settingListeners.push(avifFormatDisabledSetting.addChangeListener(updateDisabledImageFormats));
+    this.#settingListeners.push(jpegXlFormatDisabledSetting.addChangeListener(updateDisabledImageFormats));
+    this.#settingListeners.push(webpFormatDisabledSetting.addChangeListener(updateDisabledImageFormats));
 
     if (avifFormatDisabledSetting.get() || jpegXlFormatDisabledSetting.get() || webpFormatDisabledSetting.get()) {
       updateDisabledImageFormats();
     }
 
     this.#dataSaverSetting = settings.resolve(dataSaverSettingDescriptor);
-    this.#dataSaverChangeListener = () => {
+    this.#settingListeners.push(this.#dataSaverSetting.addChangeListener(() => {
       void this.setDataSaverOverride(this.#dataSaverSetting.get());
-    };
-    this.#dataSaverSetting.addChangeListener(this.#dataSaverChangeListener, this);
+    }));
     if (this.#dataSaverSetting.get() !== DataSaverOverride.UNSET) {
       void this.setDataSaverOverride(this.#dataSaverSetting.get());
     }
@@ -266,7 +267,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
 
   override dispose(): void {
     super.dispose();
-    this.#dataSaverSetting.removeChangeListener(this.#dataSaverChangeListener, this);
+    Common.EventTarget.removeEventListeners(this.#settingListeners);
   }
 
   setTouchEmulationAllowed(touchEmulationAllowed: boolean): void {

package/front_end/core/sdk/NetworkManager.ts

@@ -563,6 +563,7 @@ export class NetworkManager extends SDKModel<EventTypes> {
     const settings = this.target().targetManager().settings;
     settings.resolve(cacheDisabledSettingDescriptor).removeChangeListener(this.cacheDisabledSettingChanged, this);
     settings.resolve(preserveNetworkLogSettingDescriptor).removeChangeListener(this.preserveLogChanged, this);
+    this.#bypassServiceWorkerSetting.removeChangeListener(this.bypassServiceWorkerChanged, this);
   }
 
   private bypassServiceWorkerChanged(): void {
@@ -762,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;
@@ -1742,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);
     }
   }
@@ -1753,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/NetworkRequest.ts

@@ -1506,6 +1506,27 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     return this.#contentData;
   }
 
+  /**
+   * Returns the response body without waiting for the request to finish loading.
+   *
+   * `requestContentData()` waits for `FINISHED_LOADING` when the request has no
+   * content data provider. Some requests never finish: Chrome does not send
+   * `loadingFinished` for a `Cache-Control: no-store` fetch() whose body the page
+   * never reads, and synthetic requests without a provider are never finished at all.
+   * Callers that must not block, such as AI context building, use this method instead.
+   *
+   * Requests with a content data provider (Local Overrides, Cache Storage, HAR
+   * imports) resolve even when they have not finished.
+   */
+  requestContentDataIfAvailable(): Promise<TextUtils.ContentData.ContentDataOrError> {
+    // A content data provider returns the body without waiting for the request
+    // to finish, so only requests without a content data provider can block.
+    if (!this.finished && !this.#contentDataProvider) {
+      return Promise.resolve({error: 'Request has not finished loading'});
+    }
+    return this.requestContentData();
+  }
+
   setContentDataProvider(
       dataProvider: () => Promise<TextUtils.ContentData.ContentDataOrError>,
       ): void {

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/RuntimeModel.ts

@@ -27,6 +27,7 @@ export class RuntimeModel extends SDKModel<EventTypes> {
   readonly agent: ProtocolProxyApi.RuntimeApi;
   readonly #executionContextById = new Map<number, ExecutionContext>();
   #executionContextComparator: (arg0: ExecutionContext, arg1: ExecutionContext) => number = ExecutionContext.comparator;
+  readonly #customFormattersSetting: Common.Settings.Setting<boolean>;
   constructor(target: Target) {
     super(target);
 
@@ -34,13 +35,17 @@ export class RuntimeModel extends SDKModel<EventTypes> {
     this.target().registerRuntimeDispatcher(new RuntimeDispatcher(this));
     void this.agent.invoke_enable();
 
-    const customFormattersSetting =
+    this.#customFormattersSetting =
         this.target().targetManager().context.get(Common.Settings.Settings).resolve(customFormattersSettingDescriptor);
-    if (customFormattersSetting.get()) {
+    if (this.#customFormattersSetting.get()) {
       void this.agent.invoke_setCustomObjectFormatterEnabled({enabled: true});
     }
 
-    customFormattersSetting.addChangeListener(this.customFormattersStateChanged.bind(this));
+    this.#customFormattersSetting.addChangeListener(this.customFormattersStateChanged, this);
+  }
+
+  override dispose(): void {
+    this.#customFormattersSetting.removeChangeListener(this.customFormattersStateChanged, this);
   }
 
   static isSideEffectFailure(response: Protocol.Runtime.EvaluateResponse|EvaluationResult): boolean {

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 : '');