chrome-devtools-frontend 1.0.1697998 → 1.0.1698733

package/front_end/models/comment_manager/CommentThread.ts

@@ -0,0 +1,145 @@
+// 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 * as Common from '../../core/common/common.js';
+
+export interface EditorAnchorSignature {
+  /** 1-based line number for CodeMirror text editor anchors */
+  lineNumber: number;
+  /** File path associated with the editor */
+  filePath?: string;
+}
+
+export interface DOMNodeAnchorSignature {
+  /** Backend NodeId for DOM nodes (`data-backend-node-id`) */
+  backendNodeId: number;
+  /** Target ID associated with the DOM node (`data-target-id`) */
+  targetId: string;
+}
+
+export interface TimelineAnchorSignature {
+  /** Identifier of the trace to scope comments to a specific recording */
+  traceId: string;
+  /** Serializable key from Trace.EventsSerializer (e.g. 'r-123', 'p-1-2-3-4', 's-5') */
+  traceEventKey: string;
+  /** Primary event title or category name */
+  entryName: string;
+  /** Event start timestamp in microseconds */
+  startTimeMicro: number;
+  /** Chart location */
+  chartLocation: 'main'|'network';
+  /** Event duration in microseconds (omitted for instant markers) */
+  durationMicro?: number;
+}
+
+export interface CommentAnchorSignature {
+  /** Visual logging tree path, e.g. "Panel: elements > Pane: styles > TreeOutline > TreeItem: color" */
+  vePath: string;
+  /** Normalized text content of the target node */
+  textSignature: string;
+  /** Text content of the parent container VE node for sibling disambiguation */
+  parentTextSignature?: string;
+  /** 0-indexed position among siblings sharing the same visual logging path */
+  siblingIndex?: number;
+  /** Optional backend RequestId for Network panel elements (`data-network-request-id`) */
+  networkRequestId?: string;
+  /** Optional DOM node identifiers (`data-backend-node-id`, `data-target-id`) */
+  node?: DOMNodeAnchorSignature;
+  /** Optional editor anchor coordinates for CodeMirror text editors */
+  editor?: EditorAnchorSignature;
+  /** Optional timeline flamechart anchor coordinates for Performance panel trace entries */
+  timeline?: TimelineAnchorSignature;
+}
+
+export interface Comment {
+  author: 'DEVELOPER'|'AGENT';
+  text: string;
+  timestamp: number;
+}
+
+export interface ChangeRecord {
+  id: string;
+  description: string;
+  timestamp: number;
+}
+
+export type CommentThreadStatus = 'DRAFT'|'ACTIVE'|'RESOLVED';
+
+export const enum Events {
+  CHANGED = 'Changed',
+}
+
+export interface EventTypes {
+  [Events.CHANGED]: void;
+}
+
+export interface CommentThreadOptions {
+  anchor: CommentAnchorSignature;
+  comments?: Comment[];
+  changes?: ChangeRecord[];
+}
+
+export class CommentThread extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  static #nextIndex = 1;
+
+  static resetIndex(): void {
+    CommentThread.#nextIndex = 1;
+  }
+
+  readonly id: string = crypto.randomUUID();
+  readonly anchor: CommentAnchorSignature;
+  #savedIndex?: number;
+  comments: Comment[];
+  status: CommentThreadStatus = 'DRAFT';
+  transmitted: boolean = false;
+  changes?: ChangeRecord[];
+
+  constructor(options: CommentThreadOptions) {
+    super();
+    this.anchor = options.anchor;
+    this.comments = options.comments ?? [];
+    this.changes = options.changes;
+  }
+
+  get index(): number {
+    return this.#savedIndex ?? CommentThread.#nextIndex;
+  }
+
+  save(text?: string, author: 'DEVELOPER'|'AGENT' = 'DEVELOPER'): void {
+    let changed = false;
+    if (text && text.trim().length > 0) {
+      this.comments.push({
+        author,
+        text: text.trim(),
+        timestamp: Date.now(),
+      });
+      changed = true;
+    }
+    if (this.status === 'DRAFT') {
+      if (this.#savedIndex === undefined) {
+        this.#savedIndex = CommentThread.#nextIndex++;
+      }
+      this.status = 'ACTIVE';
+      changed = true;
+    }
+    if (changed) {
+      this.dispatchEventToListeners(Events.CHANGED);
+    }
+  }
+
+  resolve(replyText?: string): void {
+    if (replyText && replyText.trim().length > 0) {
+      this.comments.push({
+        author: 'AGENT',
+        text: replyText.trim(),
+        timestamp: Date.now(),
+      });
+    }
+    if (this.#savedIndex === undefined) {
+      this.#savedIndex = CommentThread.#nextIndex++;
+    }
+    this.status = 'RESOLVED';
+    this.dispatchEventToListeners(Events.CHANGED);
+  }
+}

package/front_end/models/comment_manager/comment_manager.ts

@@ -4,8 +4,10 @@
 
 import * as CD4ABridge from './CD4ABridge.js';
 import * as CommentManager from './CommentManager.js';
+import * as CommentThread from './CommentThread.js';
 
 export {
   CD4ABridge,
   CommentManager,
+  CommentThread,
 };

package/front_end/models/emulation/DeviceModeModel.ts

@@ -107,6 +107,8 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   #appliedUserAgentType: UA;
   readonly #scaleSetting: Common.Settings.Setting<number>;
   #scale: number;
+  readonly #autoAdjustScaleSetting: Common.Settings.Setting<boolean>;
+  readonly #deviceScaleMapSetting: Common.Settings.Setting<Record<string, {scale: number, autoAdjust: boolean}>>;
   #widthSetting: Common.Settings.Setting<number>;
   #heightSetting: Common.Settings.Setting<number>;
   #uaSetting: Common.Settings.Setting<UA>;
@@ -153,6 +155,9 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.#scaleSetting.addChangeListener(this.scaleSettingChanged, this);
     this.#scale = 1;
 
+    this.#autoAdjustScaleSetting = this.#settings.createSetting('emulation.auto-adjust-scale', true);
+    this.#deviceScaleMapSetting = this.#settings.createSetting('emulation.device-scale-map', {});
+
     this.#widthSetting = this.#settings.createSetting('emulation.device-width', 400);
     if (this.#widthSetting.get() < MinDeviceSize) {
       this.#widthSetting.set(MinDeviceSize);
@@ -327,12 +332,44 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
 
   emulate(type: Type, device: EmulatedDevice|null, mode: Mode|null, scale?: number): void {
     const resetPageScaleFactor = this.#type !== type || this.#device !== device || this.#mode !== mode;
+    const deviceChanged = this.#type !== type || this.#device !== device;
+
+    if (deviceChanged) {
+      if (this.#type === Type.Device && this.#device) {
+        const map = this.#deviceScaleMapSetting.get();
+        map[this.#device.title] = {
+          scale: this.#scaleSetting.get(),
+          autoAdjust: this.#autoAdjustScaleSetting.get(),
+        };
+        this.#deviceScaleMapSetting.set(map);
+      } else if (this.#type === Type.Responsive) {
+        const map = this.#deviceScaleMapSetting.get();
+        map['Responsive'] = {
+          scale: this.#scaleSetting.get(),
+          autoAdjust: this.#autoAdjustScaleSetting.get(),
+        };
+        this.#deviceScaleMapSetting.set(map);
+      }
+    }
+
     this.#type = type;
 
     if (type === Type.Device && device && mode) {
       console.assert(Boolean(device) && Boolean(mode), 'Must pass device and mode for device emulation');
       this.#mode = mode;
       this.#device = device;
+
+      if (deviceChanged) {
+        const map = this.#deviceScaleMapSetting.get();
+        const savedDevice = map[device.title];
+        if (savedDevice) {
+          this.#autoAdjustScaleSetting.set(savedDevice.autoAdjust);
+          scale = savedDevice.autoAdjust ? undefined : savedDevice.scale;
+        } else {
+          this.#autoAdjustScaleSetting.set(scale === undefined);
+        }
+      }
+
       if (scale !== undefined) {
         this.#autoFitScaleOnInitialize = false;
         this.#scaleSetting.set(scale);
@@ -346,6 +383,22 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       this.#device = null;
       this.#mode = null;
       this.#autoFitScaleOnInitialize = false;
+
+      if (deviceChanged && type === Type.Responsive) {
+        const map = this.#deviceScaleMapSetting.get();
+        const savedDevice = map['Responsive'];
+        if (savedDevice) {
+          this.#autoAdjustScaleSetting.set(savedDevice.autoAdjust);
+          if (!savedDevice.autoAdjust) {
+            this.#scaleSetting.set(savedDevice.scale);
+          } else {
+            this.#scaleSetting.set(this.calculateFitScale(this.#widthSetting.get(), this.#heightSetting.get()));
+          }
+        } else {
+          this.#autoAdjustScaleSetting.set(true);
+          this.#scaleSetting.set(1);
+        }
+      }
     }
 
     if (type !== Type.None) {

package/front_end/models/extensions/ExtensionAPI.ts

@@ -404,6 +404,8 @@ declare global {
     chrome: PublicAPI.Chrome.DevTools.Chrome;
     webInspector?: APIImpl.InspectorExtensionAPI;
   }
+  var injectedExtensionAPI: Window['injectedExtensionAPI'];
+  var buildExtensionAPIInjectedScript: Window['buildExtensionAPIInjectedScript'];
 }
 
 export interface ExtensionDescriptor {
@@ -511,7 +513,7 @@ namespace APIImpl {
   }
 }
 
-self.injectedExtensionAPI = function(
+globalThis.injectedExtensionAPI = function(
     extensionInfo: ExtensionDescriptor, inspectedTabId: string, themeName: string, keysToForward: number[],
     testHook: (extensionServer: APIImpl.ExtensionServerClient, extensionAPI: APIImpl.InspectorExtensionAPI) => unknown,
     injectedScriptId: number, targetWindowForTest?: Window): void {
@@ -1763,22 +1765,22 @@ self.injectedExtensionAPI = function(
   testHook(extensionServer, coreAPI);
 };
 
-self.buildExtensionAPIInjectedScript = function(
+globalThis.buildExtensionAPIInjectedScript = function(
     extensionInfo: {
       startPage: string,
       name: string,
       exposeExperimentalAPIs: boolean,
     },
     inspectedTabId: string, themeName: string, keysToForward: number[],
-    testHook:
-        ((extensionServer: APIImpl.ExtensionServerClient, extensionAPI: APIImpl.InspectorExtensionAPI) => unknown)|
-    undefined): string {
+    testHook: ((extensionServer: APIImpl.ExtensionServerClient, extensionAPI: APIImpl.InspectorExtensionAPI) =>
+                   unknown)|undefined): string {
   const argumentsJSON =
       [extensionInfo, inspectedTabId || null, themeName, keysToForward].map(_ => JSON.stringify(_)).join(',');
   if (!testHook) {
     testHook = (): void => {};
   }
   return '(function(injectedScriptId){ ' +
-      '(' + self.injectedExtensionAPI.toString() + ')(' + argumentsJSON + ',' + testHook + ', injectedScriptId);' +
+      '(' + globalThis.injectedExtensionAPI.toString() + ')(' + argumentsJSON + ',' + testHook +
+      ', injectedScriptId);' +
       '})';
 };

package/front_end/models/extensions/ExtensionEndpoint.ts

@@ -2,29 +2,31 @@
 // 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 '../../core/platform/platform.js';
+
 interface Response {
   requestId: number;
   result: unknown;
   error: Error|null;
 }
 
-interface Event {
+interface EventMessage {
   event: string;
 }
 
-type Message = MessageEvent<Response|Event>;
-
 export class ExtensionEndpoint {
-  private readonly port: MessagePort;
+  private readonly port: Platform.HostRuntime.WorkerMessagePort;
   private nextRequestId = 0;
   private pendingRequests: Map<number, {
     resolve: (arg: unknown) => void,
     reject: (error: Error) => void,
   }>;
 
-  constructor(port: MessagePort) {
+  constructor(port: Platform.HostRuntime.WorkerMessagePort) {
     this.port = port;
-    this.port.onmessage = this.onResponse.bind(this);
+    this.port.addEventListener('message', (event: unknown) => this.onResponse(event as MessageEvent));
+    (this.port as {start?: () => void}).start?.();
+    (this.port as {unref?: () => void}).unref?.();
     this.pendingRequests = new Map();
   }
 
@@ -44,7 +46,8 @@ export class ExtensionEndpoint {
     this.port.close();
   }
 
-  private onResponse({data}: Message): void {
+  private onResponse(event: MessageEvent): void {
+    const data = event.data as Response | EventMessage;
     if ('event' in data) {
       this.handleEvent(data);
       return;
@@ -63,7 +66,7 @@ export class ExtensionEndpoint {
     }
   }
 
-  protected handleEvent(_event: Event): void {
+  protected handleEvent(_event: EventMessage): void {
     throw new Error('handleEvent is not implemented');
   }
 }

package/front_end/models/extensions/HostUrlPattern.ts

@@ -77,8 +77,9 @@ function parseHostAndPort(pattern: string, scheme: string): {host: string, port:
     asUrl.hostname = asUrl.hostname.substr(0, asUrl.hostname.length - 1);
   }
 
-  // The URL constructor is happy to accept '*', but it gets replaced with %2A
-  if (asUrl.hostname !== '%2A' && asUrl.hostname.includes('%2A')) {
+  // The URL constructor in Chrome replaces '*' with '%2A', whereas Node preserves '*'.
+  const isWildcardHost = asUrl.hostname === '%2A' || asUrl.hostname === '*';
+  if (!isWildcardHost && (asUrl.hostname.includes('%2A') || asUrl.hostname.includes('*'))) {
     return undefined;
   }
 
@@ -93,7 +94,7 @@ function parseHostAndPort(pattern: string, scheme: string): {host: string, port:
     return undefined;
   }
 
-  const host = asUrl.hostname !== '%2A' ? (pattern.startsWith('*.') ? `*.${asUrl.hostname}` : asUrl.hostname) : '*';
+  const host = !isWildcardHost ? (pattern.startsWith('*.') ? `*.${asUrl.hostname}` : asUrl.hostname) : '*';
   return {
     host,
     port,

package/front_end/models/extensions/LanguageExtensionEndpoint.ts

@@ -13,7 +13,7 @@ import {ExtensionEndpoint} from './ExtensionEndpoint.js';
 class LanguageExtensionEndpointImpl extends ExtensionEndpoint {
   private plugin: LanguageExtensionEndpoint;
   #pluginManager: Bindings.DebuggerLanguagePlugins.DebuggerLanguagePluginManager;
-  constructor(plugin: LanguageExtensionEndpoint, port: MessagePort,
+  constructor(plugin: LanguageExtensionEndpoint, port: Platform.HostRuntime.WorkerMessagePort,
               pluginManager: Bindings.DebuggerLanguagePlugins.DebuggerLanguagePluginManager) {
     super(port);
     this.plugin = plugin;
@@ -46,7 +46,8 @@ export class LanguageExtensionEndpoint implements Bindings.DebuggerLanguagePlugi
     // eslint-disable-next-line @typescript-eslint/naming-convention
     symbol_types: string[],
   },
-              port: MessagePort, pluginManager: Bindings.DebuggerLanguagePlugins.DebuggerLanguagePluginManager) {
+              port: Platform.HostRuntime.WorkerMessagePort,
+              pluginManager: Bindings.DebuggerLanguagePlugins.DebuggerLanguagePluginManager) {
     this.name = name;
     this.extensionOrigin = extensionOrigin;
     this.supportedScriptTypes = supportedScriptTypes;

package/front_end/models/extensions/RecorderExtensionEndpoint.ts

@@ -15,7 +15,8 @@ export class RecorderExtensionEndpoint extends ExtensionEndpoint {
   readonly #extensionOrigin: Platform.DevToolsPath.UrlString;
   readonly #recorderPluginManager: RecorderPluginManager;
 
-  constructor(name: string, port: MessagePort, capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
+  constructor(name: string, port: Platform.HostRuntime.WorkerMessagePort,
+              capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
               extensionOrigin: Platform.DevToolsPath.UrlString, recorderPluginManager: RecorderPluginManager,
               mediaType?: string) {
     super(port);

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as PlatformApi from '../../core/platform/api/api.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as FormatterActions from '../../entrypoints/formatter_actions/formatter_actions.js';
 
@@ -12,7 +11,7 @@ let formatterWorkerPoolInstance: FormatterWorkerPool|undefined;
 
 export class FormatterWorkerPool {
   private taskQueue: Task[];
-  private workerTasks: Map<PlatformApi.HostRuntime.Worker, Task|null>;
+  private workerTasks: Map<Platform.HostRuntime.Worker, Task|null>;
   private entrypointURL: string;
 
   constructor(entrypointURL?: string) {
@@ -46,7 +45,7 @@ export class FormatterWorkerPool {
     formatterWorkerPoolInstance = undefined;
   }
 
-  private createWorker(): PlatformApi.HostRuntime.Worker {
+  private createWorker(): Platform.HostRuntime.Worker {
     const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(this.entrypointURL);
     worker.onmessage = this.onWorkerMessage.bind(this, worker);
     worker.onerror = this.onWorkerError.bind(this, worker);
@@ -75,8 +74,7 @@ export class FormatterWorkerPool {
     }
   }
 
-  private onWorkerMessage(worker: PlatformApi.HostRuntime.Worker, event: PlatformApi.HostRuntime.WorkerMessageEvent):
-      void {
+  private onWorkerMessage(worker: Platform.HostRuntime.Worker, event: Platform.HostRuntime.WorkerMessageEvent): void {
     const task = this.workerTasks.get(worker);
     if (!task) {
       return;
@@ -91,7 +89,7 @@ export class FormatterWorkerPool {
     task.callback(event.data ? event.data : null);
   }
 
-  private onWorkerError(worker: PlatformApi.HostRuntime.Worker, event: Event): void {
+  private onWorkerError(worker: Platform.HostRuntime.Worker, event: Event): void {
     console.error(event);
     const task = this.workerTasks.get(worker);
     worker.terminate();

package/front_end/models/heap_snapshot/HeapSnapshotModel.ts

@@ -363,6 +363,61 @@ export interface ObjectInfo {
   retainerCount: number;
 }
 
+export interface ContextAnalysisResult {
+  /** Scopes with dead fields, sorted by their highest-ranked context. */
+  scopes: ScopeAnalysis[];
+  /** Scripts with live contexts that could not be analyzed because they lack embedded scope metadata. */
+  scriptsWithoutScopes: ScriptWithoutScopes[];
+}
+
+export interface ScopeAnalysis {
+  scopeInfoNodeIndex: number;
+  scopeInfoNodeId: number;
+  scriptNodeIndex: number;
+  scriptNodeId: number;
+  scriptName: string;
+  /** Source name of the scope, when available. */
+  scopeName?: string;
+  scopeStart: number;
+  scopeEnd: number;
+  /** Number of context-typed fields in each context belonging to this scope. */
+  contextFieldCount: number;
+  /** Contexts with dead fields, sorted descending by deadFieldsRetainedSizeSum. */
+  contexts: ContextAnalysis[];
+}
+
+export interface ContextAnalysis {
+  contextNodeIndex: number;
+  contextNodeId: number;
+  retainedSize: number;
+  /**
+   * The sum of the retained sizes of values in fields classified as dead.
+   * This is a ranking heuristic, not the number of bytes that would be
+   * reclaimed by clearing the fields.
+   */
+  deadFieldsRetainedSizeSum: number;
+  /** Fields classified as dead in this context, sorted descending by retainedSize. */
+  deadFields: ContextField[];
+}
+
+export interface ContextField {
+  name: string;
+  valueNodeIndex: number;
+  valueNodeId: number;
+  valueName: string;
+  valueType: string;
+  selfSize: number;
+  retainedSize: number;
+}
+
+export interface ScriptWithoutScopes {
+  scriptNodeIndex: number;
+  scriptNodeId: number;
+  scriptName: string;
+  /** Number of live context instances belonging to this script. */
+  contextCount: number;
+}
+
 export interface HeapQueryOptions {
   className?: string;
   propertyName?: string;

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
-import type * as PlatformApi from '../../core/platform/api/api.js';
 import * as Platform from '../../core/platform/platform.js';
 
 import type {ChildrenProvider} from './ChildrenProvider.js';
@@ -17,7 +16,7 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
   callbacks: Map<number, (error?: string, result?: unknown) => void> =
       new Map<number, (error?: string, result?: unknown) => void>();
   readonly previousCallbacks: Set<number> = new Set<number>();
-  readonly worker: PlatformApi.HostRuntime.Worker;
+  readonly worker: Platform.HostRuntime.Worker;
   interval?: ReturnType<typeof setInterval>;
   readonly workerUrl?: string;
 
@@ -69,17 +68,18 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
     this.postMessage({callId, disposition: 'evaluateForTest', source: script});
   }
 
-  callFactoryMethod<T extends Object>(
-      callback: null, objectId: string, methodName: string, proxyConstructor: new(...arg1: any[]) => T,
-      transfer: PlatformApi.HostRuntime.WorkerTransferable[], ...methodArguments: any[]): T;
+  callFactoryMethod<T extends Object>(callback: null, objectId: string, methodName: string,
+                                      proxyConstructor: new(...arg1: any[]) => T,
+                                      transfer: Platform.HostRuntime.WorkerTransferable[],
+                                      ...methodArguments: any[]): T;
   callFactoryMethod<T extends Object>(callback: ((error?: string, result?: T) => void), objectId: string,
                                       methodName: string, proxyConstructor: new(...arg1: any[]) => T,
-                                      transfer: PlatformApi.HostRuntime.WorkerTransferable[],
+                                      transfer: Platform.HostRuntime.WorkerTransferable[],
                                       ...methodArguments: any[]): null;
   callFactoryMethod<T extends Object>(callback: ((error?: string, result?: T) => void)|null, objectId: string,
                                       methodName: string, proxyConstructor: new(...arg1: any[]) => T,
-                                      transfer: PlatformApi.HostRuntime.WorkerTransferable[],
-                                      ...methodArguments: any[]): T|null {
+                                      transfer: Platform.HostRuntime.WorkerTransferable[], ...methodArguments: any[]): T
+      |null {
     const callId = this.nextCallId++;
     const newObjectId = this.nextObjectId++;
 
@@ -154,7 +154,7 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
     }
   }
 
-  setupForSecondaryInit(port: PlatformApi.HostRuntime.WorkerMessagePort): Promise<void> {
+  setupForSecondaryInit(port: Platform.HostRuntime.WorkerMessagePort): Promise<void> {
     const callId = this.nextCallId++;
     const done = new Promise<void>((resolve, reject) => {
       this.callbacks.set(callId, error => {
@@ -175,7 +175,7 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
     return done;
   }
 
-  messageReceived(event: PlatformApi.HostRuntime.WorkerMessageEvent): void {
+  messageReceived(event: Platform.HostRuntime.WorkerMessageEvent): void {
     const data = event.data;
     if (data.eventName) {
       if (this.eventHandler) {
@@ -199,7 +199,7 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
     callback(undefined, data.result);
   }
 
-  postMessage(message: unknown, transfer?: PlatformApi.HostRuntime.WorkerTransferable[]): void {
+  postMessage(message: unknown, transfer?: Platform.HostRuntime.WorkerTransferable[]): void {
     this.worker.postMessage(message, transfer);
   }
 }
@@ -231,9 +231,9 @@ export class HeapSnapshotProxyObject {
     return this.worker.callFactoryMethod(null, String(this.objectId), methodName, proxyConstructor, [], ...args);
   }
 
-  callFactoryMethodPromise<T extends Object>(
-      methodName: string, proxyConstructor: new(...arg1: any[]) => T,
-      transfer: PlatformApi.HostRuntime.WorkerTransferable[], ...args: any[]): Promise<T> {
+  callFactoryMethodPromise<T extends Object>(methodName: string, proxyConstructor: new(...arg1: any[]) => T,
+                                             transfer: Platform.HostRuntime.WorkerTransferable[],
+                                             ...args: any[]): Promise<T> {
     return new Promise((resolve, reject) => this.worker.callFactoryMethod((error, result) => {
       if (error) {
         reject(new Error(error));
@@ -348,6 +348,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('getObjectInfo', nodeIndex);
   }
 
+  analyzeContexts(): Promise<HeapSnapshotModel.ContextAnalysisResult> {
+    return this.callMethodPromise('analyzeContexts');
+  }
+
   createEdgesProvider(nodeIndex: number, options?: HeapSnapshotModel.HeapEdgesQueryOptions): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex, options);
   }

package/front_end/models/issues_manager/IssuesManager.ts

@@ -38,6 +38,7 @@ import {SourceFrameIssuesManager} from './SourceFrameIssuesManager.js';
 import {SRIMessageSignatureIssue} from './SRIMessageSignatureIssue.js';
 import {StylesheetLoadingIssue} from './StylesheetLoadingIssue.js';
 import {UnencodedDigestIssue} from './UnencodedDigestIssue.js';
+import {WebInstallIssue} from './WebInstallIssue.js';
 
 export {Events} from './IssuesManagerEvents.js';
 
@@ -149,6 +150,10 @@ const issueCodeHandlers =
             Protocol.Audits.InspectorIssueCode.ConnectionAllowlistIssue,
             ConnectionAllowlistIssue.fromInspectorIssue,
           ],
+          [
+            Protocol.Audits.InspectorIssueCode.WebInstallIssue,
+            WebInstallIssue.fromInspectorIssue,
+          ],
           [
             Protocol.Audits.InspectorIssueCode.PermissionElementIssue,
             PermissionElementIssue.fromInspectorIssue,