chrome-devtools-frontend 1.0.1606789 → 1.0.1608453

package/front_end/generated/protocol.ts

@@ -16932,6 +16932,7 @@ export namespace Preload {
     loaderId: Network.LoaderId;
     action: SpeculationAction;
     url: string;
+    formSubmission?: boolean;
     targetHint?: SpeculationTargetHint;
   }
 
@@ -17037,6 +17038,7 @@ export namespace Preload {
     PrerenderFailedDuringPrefetch = 'PrerenderFailedDuringPrefetch',
     BrowsingDataRemoved = 'BrowsingDataRemoved',
     PrerenderHostReused = 'PrerenderHostReused',
+    FormSubmitWhenPrerendering = 'FormSubmitWhenPrerendering',
   }
 
   /**
@@ -18282,253 +18284,6 @@ export namespace Storage {
     durability: StorageBucketsDurability;
   }
 
-  export const enum AttributionReportingSourceType {
-    Navigation = 'navigation',
-    Event = 'event',
-  }
-
-  export type UnsignedInt64AsBase10 = string;
-
-  export type UnsignedInt128AsBase16 = string;
-
-  export type SignedInt64AsBase10 = string;
-
-  export interface AttributionReportingFilterDataEntry {
-    key: string;
-    values: string[];
-  }
-
-  export interface AttributionReportingFilterConfig {
-    filterValues: AttributionReportingFilterDataEntry[];
-    /**
-     * duration in seconds
-     */
-    lookbackWindow?: integer;
-  }
-
-  export interface AttributionReportingFilterPair {
-    filters: AttributionReportingFilterConfig[];
-    notFilters: AttributionReportingFilterConfig[];
-  }
-
-  export interface AttributionReportingAggregationKeysEntry {
-    key: string;
-    value: UnsignedInt128AsBase16;
-  }
-
-  export interface AttributionReportingEventReportWindows {
-    /**
-     * duration in seconds
-     */
-    start: integer;
-    /**
-     * duration in seconds
-     */
-    ends: integer[];
-  }
-
-  export const enum AttributionReportingTriggerDataMatching {
-    Exact = 'exact',
-    Modulus = 'modulus',
-  }
-
-  export interface AttributionReportingAggregatableDebugReportingData {
-    keyPiece: UnsignedInt128AsBase16;
-    /**
-     * number instead of integer because not all uint32 can be represented by
-     * int
-     */
-    value: number;
-    types: string[];
-  }
-
-  export interface AttributionReportingAggregatableDebugReportingConfig {
-    /**
-     * number instead of integer because not all uint32 can be represented by
-     * int, only present for source registrations
-     */
-    budget?: number;
-    keyPiece: UnsignedInt128AsBase16;
-    debugData: AttributionReportingAggregatableDebugReportingData[];
-    aggregationCoordinatorOrigin?: string;
-  }
-
-  export interface AttributionScopesData {
-    values: string[];
-    /**
-     * number instead of integer because not all uint32 can be represented by
-     * int
-     */
-    limit: number;
-    maxEventStates: number;
-  }
-
-  export interface AttributionReportingNamedBudgetDef {
-    name: string;
-    budget: integer;
-  }
-
-  export interface AttributionReportingSourceRegistration {
-    time: Network.TimeSinceEpoch;
-    /**
-     * duration in seconds
-     */
-    expiry: integer;
-    /**
-     * number instead of integer because not all uint32 can be represented by
-     * int
-     */
-    triggerData: number[];
-    eventReportWindows: AttributionReportingEventReportWindows;
-    /**
-     * duration in seconds
-     */
-    aggregatableReportWindow: integer;
-    type: AttributionReportingSourceType;
-    sourceOrigin: string;
-    reportingOrigin: string;
-    destinationSites: string[];
-    eventId: UnsignedInt64AsBase10;
-    priority: SignedInt64AsBase10;
-    filterData: AttributionReportingFilterDataEntry[];
-    aggregationKeys: AttributionReportingAggregationKeysEntry[];
-    debugKey?: UnsignedInt64AsBase10;
-    triggerDataMatching: AttributionReportingTriggerDataMatching;
-    destinationLimitPriority: SignedInt64AsBase10;
-    aggregatableDebugReportingConfig: AttributionReportingAggregatableDebugReportingConfig;
-    scopesData?: AttributionScopesData;
-    maxEventLevelReports: integer;
-    namedBudgets: AttributionReportingNamedBudgetDef[];
-    debugReporting: boolean;
-    eventLevelEpsilon: number;
-  }
-
-  export const enum AttributionReportingSourceRegistrationResult {
-    Success = 'success',
-    InternalError = 'internalError',
-    InsufficientSourceCapacity = 'insufficientSourceCapacity',
-    InsufficientUniqueDestinationCapacity = 'insufficientUniqueDestinationCapacity',
-    ExcessiveReportingOrigins = 'excessiveReportingOrigins',
-    ProhibitedByBrowserPolicy = 'prohibitedByBrowserPolicy',
-    SuccessNoised = 'successNoised',
-    DestinationReportingLimitReached = 'destinationReportingLimitReached',
-    DestinationGlobalLimitReached = 'destinationGlobalLimitReached',
-    DestinationBothLimitsReached = 'destinationBothLimitsReached',
-    ReportingOriginsPerSiteLimitReached = 'reportingOriginsPerSiteLimitReached',
-    ExceedsMaxChannelCapacity = 'exceedsMaxChannelCapacity',
-    ExceedsMaxScopesChannelCapacity = 'exceedsMaxScopesChannelCapacity',
-    ExceedsMaxTriggerStateCardinality = 'exceedsMaxTriggerStateCardinality',
-    ExceedsMaxEventStatesLimit = 'exceedsMaxEventStatesLimit',
-    DestinationPerDayReportingLimitReached = 'destinationPerDayReportingLimitReached',
-  }
-
-  export const enum AttributionReportingSourceRegistrationTimeConfig {
-    Include = 'include',
-    Exclude = 'exclude',
-  }
-
-  export interface AttributionReportingAggregatableValueDictEntry {
-    key: string;
-    /**
-     * number instead of integer because not all uint32 can be represented by
-     * int
-     */
-    value: number;
-    filteringId: UnsignedInt64AsBase10;
-  }
-
-  export interface AttributionReportingAggregatableValueEntry {
-    values: AttributionReportingAggregatableValueDictEntry[];
-    filters: AttributionReportingFilterPair;
-  }
-
-  export interface AttributionReportingEventTriggerData {
-    data: UnsignedInt64AsBase10;
-    priority: SignedInt64AsBase10;
-    dedupKey?: UnsignedInt64AsBase10;
-    filters: AttributionReportingFilterPair;
-  }
-
-  export interface AttributionReportingAggregatableTriggerData {
-    keyPiece: UnsignedInt128AsBase16;
-    sourceKeys: string[];
-    filters: AttributionReportingFilterPair;
-  }
-
-  export interface AttributionReportingAggregatableDedupKey {
-    dedupKey?: UnsignedInt64AsBase10;
-    filters: AttributionReportingFilterPair;
-  }
-
-  export interface AttributionReportingNamedBudgetCandidate {
-    name?: string;
-    filters: AttributionReportingFilterPair;
-  }
-
-  export interface AttributionReportingTriggerRegistration {
-    filters: AttributionReportingFilterPair;
-    debugKey?: UnsignedInt64AsBase10;
-    aggregatableDedupKeys: AttributionReportingAggregatableDedupKey[];
-    eventTriggerData: AttributionReportingEventTriggerData[];
-    aggregatableTriggerData: AttributionReportingAggregatableTriggerData[];
-    aggregatableValues: AttributionReportingAggregatableValueEntry[];
-    aggregatableFilteringIdMaxBytes: integer;
-    debugReporting: boolean;
-    aggregationCoordinatorOrigin?: string;
-    sourceRegistrationTimeConfig: AttributionReportingSourceRegistrationTimeConfig;
-    triggerContextId?: string;
-    aggregatableDebugReportingConfig: AttributionReportingAggregatableDebugReportingConfig;
-    scopes: string[];
-    namedBudgets: AttributionReportingNamedBudgetCandidate[];
-  }
-
-  export const enum AttributionReportingEventLevelResult {
-    Success = 'success',
-    SuccessDroppedLowerPriority = 'successDroppedLowerPriority',
-    InternalError = 'internalError',
-    NoCapacityForAttributionDestination = 'noCapacityForAttributionDestination',
-    NoMatchingSources = 'noMatchingSources',
-    Deduplicated = 'deduplicated',
-    ExcessiveAttributions = 'excessiveAttributions',
-    PriorityTooLow = 'priorityTooLow',
-    NeverAttributedSource = 'neverAttributedSource',
-    ExcessiveReportingOrigins = 'excessiveReportingOrigins',
-    NoMatchingSourceFilterData = 'noMatchingSourceFilterData',
-    ProhibitedByBrowserPolicy = 'prohibitedByBrowserPolicy',
-    NoMatchingConfigurations = 'noMatchingConfigurations',
-    ExcessiveReports = 'excessiveReports',
-    FalselyAttributedSource = 'falselyAttributedSource',
-    ReportWindowPassed = 'reportWindowPassed',
-    NotRegistered = 'notRegistered',
-    ReportWindowNotStarted = 'reportWindowNotStarted',
-    NoMatchingTriggerData = 'noMatchingTriggerData',
-  }
-
-  export const enum AttributionReportingAggregatableResult {
-    Success = 'success',
-    InternalError = 'internalError',
-    NoCapacityForAttributionDestination = 'noCapacityForAttributionDestination',
-    NoMatchingSources = 'noMatchingSources',
-    ExcessiveAttributions = 'excessiveAttributions',
-    ExcessiveReportingOrigins = 'excessiveReportingOrigins',
-    NoHistograms = 'noHistograms',
-    InsufficientBudget = 'insufficientBudget',
-    InsufficientNamedBudget = 'insufficientNamedBudget',
-    NoMatchingSourceFilterData = 'noMatchingSourceFilterData',
-    NotRegistered = 'notRegistered',
-    ProhibitedByBrowserPolicy = 'prohibitedByBrowserPolicy',
-    Deduplicated = 'deduplicated',
-    ReportWindowPassed = 'reportWindowPassed',
-    ExcessiveReports = 'excessiveReports',
-  }
-
-  export const enum AttributionReportingReportResult {
-    Sent = 'sent',
-    Prohibited = 'prohibited',
-    FailedToAssemble = 'failedToAssemble',
-    Expired = 'expired',
-  }
-
   /**
    * A single Related Website Set object.
    */
@@ -18811,24 +18566,6 @@ export namespace Storage {
     deletedSites: string[];
   }
 
-  export interface SetAttributionReportingLocalTestingModeRequest {
-    /**
-     * If enabled, noise is suppressed and reports are sent immediately.
-     */
-    enabled: boolean;
-  }
-
-  export interface SetAttributionReportingTrackingRequest {
-    enable: boolean;
-  }
-
-  export interface SendPendingAttributionReportsResponse extends ProtocolResponseWithError {
-    /**
-     * The number of reports that were sent.
-     */
-    numSent: integer;
-  }
-
   export interface GetRelatedWebsiteSetsResponse extends ProtocolResponseWithError {
     sets: RelatedWebsiteSet[];
   }
@@ -19082,37 +18819,6 @@ export namespace Storage {
   export interface StorageBucketDeletedEvent {
     bucketId: string;
   }
-
-  export interface AttributionReportingSourceRegisteredEvent {
-    registration: AttributionReportingSourceRegistration;
-    result: AttributionReportingSourceRegistrationResult;
-  }
-
-  export interface AttributionReportingTriggerRegisteredEvent {
-    registration: AttributionReportingTriggerRegistration;
-    eventLevel: AttributionReportingEventLevelResult;
-    aggregatable: AttributionReportingAggregatableResult;
-  }
-
-  export interface AttributionReportingReportSentEvent {
-    url: string;
-    body: any;
-    result: AttributionReportingReportResult;
-    /**
-     * If result is `sent`, populated with net/HTTP status.
-     */
-    netError?: integer;
-    netErrorName?: string;
-    httpStatusCode?: integer;
-  }
-
-  export interface AttributionReportingVerboseDebugReportSentEvent {
-    url: string;
-    body?: any[];
-    netError?: integer;
-    netErrorName?: string;
-    httpStatusCode?: integer;
-  }
 }
 
 /**

package/front_end/models/ai_assistance/agents/PerformanceAgent.ts

@@ -28,6 +28,7 @@ import {
   type AiWidget,
   type ContextResponse,
   ConversationContext,
+  type ConversationSuggestion,
   type ConversationSuggestions,
   type FunctionCallHandlerResult,
   type ParsedResponse,
@@ -173,7 +174,7 @@ const extraPreambleWhenNotExternal = `Additional notes:
 When referring to a trace event that has a corresponding \`eventKey\`, annotate your output using markdown link syntax. For example:
 - When referring to an event that is a long task: [Long task](#r-123)
 - When referring to a URL for which you know the eventKey of: [https://www.example.com](#s-1827)
-- Never show the eventKey (like "eventKey: s-1852"); instead, use a markdown link as described above.
+- Never show the eventKey (like "eventKey: s-1852") in your running text. When using markdown links, the URL must be only the hash (e.g., \`#s-1852\`), never \`eventKey: s-1852\`.
 
 When asking the user to make a choice between options, output a list of choices at the end of your text response. The format is \`SUGGESTIONS: ["suggestion1", "suggestion2", "suggestion3"]\`. This MUST start on a newline, and be a single line.
 `;
@@ -299,31 +300,44 @@ export class PerformanceTraceContext extends ConversationContext<AgentFocus> {
 
     const insightSet = focus.primaryInsightSet;
     if (insightSet) {
-      const lcp = insightSet ? Trace.Insights.Common.getLCP(insightSet) : null;
-      const cls = insightSet ? Trace.Insights.Common.getCLS(insightSet) : null;
-      const inp = insightSet ? Trace.Insights.Common.getINP(insightSet) : null;
+      const lcp = Trace.Insights.Common.getLCP(insightSet);
+      const cls = Trace.Insights.Common.getCLS(insightSet);
+      const inp = Trace.Insights.Common.getINP(insightSet);
 
       const ModelHandlers = Trace.Handlers.ModelHandlers;
       const GOOD = Trace.Handlers.ModelHandlers.PageLoadMetrics.ScoreClassification.GOOD;
 
+      const poorMetrics = new Set<Trace.Insights.Types.InsightKeys>();
+
       if (lcp && ModelHandlers.PageLoadMetrics.scoreClassificationForLargestContentfulPaint(lcp.value) !== GOOD) {
         suggestions.push({title: 'How can I improve LCP?', jslogContext: 'performance-default'});
+        poorMetrics.add(Trace.Insights.Types.InsightKeys.LCP_BREAKDOWN);
+        poorMetrics.add(Trace.Insights.Types.InsightKeys.LCP_DISCOVERY);
       }
       if (inp && ModelHandlers.UserInteractions.scoreClassificationForInteractionToNextPaint(inp.value) !== GOOD) {
         suggestions.push({title: 'How can I improve INP?', jslogContext: 'performance-default'});
+        poorMetrics.add(Trace.Insights.Types.InsightKeys.INP_BREAKDOWN);
       }
       if (cls && ModelHandlers.LayoutShifts.scoreClassificationForLayoutShift(cls.value) !== GOOD) {
         suggestions.push({title: 'How can I improve CLS?', jslogContext: 'performance-default'});
+        poorMetrics.add(Trace.Insights.Types.InsightKeys.CLS_CULPRITS);
       }
 
-      // Add up to 3 suggestions from the top failing insights.
-      const top3FailingInsightSuggestions =
-          Object.values(insightSet.model)
-              .filter(model => model.state !== 'pass')
-              .map(model => new PerformanceInsightFormatter(focus, model).getSuggestions().at(-1))
-              .filter(suggestion => !!suggestion)
-              .slice(0, 3);
-      suggestions.push(...top3FailingInsightSuggestions);
+      // Add up to 4 suggestions total (including those already added) from the top failing insights
+      // that aren't already covered by CWV suggestions.
+      const additionalSuggestionsRequired = Math.max(0, 4 - suggestions.length);
+      if (additionalSuggestionsRequired > 0) {
+        const failingInsightSuggestions =
+            Object.values(insightSet.model)
+                .filter(model => {
+                  return model.state !== 'pass' &&
+                      !poorMetrics.has(model.insightKey as Trace.Insights.Types.InsightKeys);
+                })
+                .map(model => new PerformanceInsightFormatter(focus, model).getSuggestions().at(-1))
+                .filter((suggestion): suggestion is ConversationSuggestion => !!suggestion)
+                .slice(0, additionalSuggestionsRequired);
+        suggestions.push(...failingInsightSuggestions);
+      }
     }
 
     return suggestions;
@@ -491,13 +505,24 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
     //    - Group 3: The link destination, e.g., "url"
     // 2. (https?:\/\/[^\s<>()]+): Captures a standalone URL.
     //    - Group 4: The standalone URL, e.g., "https://google.com"
-    const urlRegex = /(\[(.*?)\]\((.*?)\))|(https?:\/\/[^\s<>()]+)/g;
+    const urlRegex = /(\[(.*?)\][ \t]*\((.*?)\))|(https?:\/\/[^\s<>()]+)/g;
 
     return response.replace(urlRegex, (match, markdownLink, linkText, linkDest, standaloneUrlText) => {
       if (markdownLink) {
         if (linkDest.startsWith('#')) {
           return match;
         }
+
+        const eventKeyMatch = linkDest.match(/eventKey:\s*([^\s,)]+)/);
+        if (eventKeyMatch) {
+          const eventKey = eventKeyMatch[1];
+          return `[${linkText}](#${eventKey})`;
+        }
+
+        const event = focus.lookupEvent(linkDest as Trace.Types.File.SerializableKey);
+        if (event) {
+          return `[${linkText}](#${linkDest})`;
+        }
       }
 
       const urlText = linkDest ?? standaloneUrlText;

package/front_end/{panels/profiler → models/heap_snapshot_model}/ChildrenProvider.ts

@@ -2,13 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
+import type {ComparatorConfig, ItemsRange} from './HeapSnapshotModel.js';
 
 export interface ChildrenProvider {
   dispose(): void;
   nodePosition(snapshotObjectId: number): Promise<number>;
   isEmpty(): Promise<boolean>;
-  serializeItemsRange(startPosition: number, endPosition: number):
-      Promise<HeapSnapshotModel.HeapSnapshotModel.ItemsRange>;
-  sortAndRewind(comparator: HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig): Promise<void>;
+  serializeItemsRange(startPosition: number, endPosition: number): Promise<ItemsRange>;
+  sortAndRewind(comparator: ComparatorConfig): Promise<void>;
 }

package/front_end/{panels/profiler → models/heap_snapshot_model}/HeapSnapshotProxy.ts

@@ -3,22 +3,12 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
-import * as i18n from '../../core/i18n/i18n.js';
 import type * as PlatformApi from '../../core/platform/api/api.js';
 import * as Platform from '../../core/platform/platform.js';
-import type * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
 
 import type {ChildrenProvider} from './ChildrenProvider.js';
+import type * as HeapSnapshotModel from './HeapSnapshotModel.js';
 
-const UIStrings = {
-  /**
-   * @description Text in Heap Snapshot Proxy of a profiler tool
-   * @example {functionName} PH1
-   */
-  anErrorOccurredWhenACallToMethod: 'An error occurred when a call to method \'\'{PH1}\'\' was requested',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('panels/profiler/HeapSnapshotProxy.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<HeapSnapshotWorkerProxy.EventTypes> {
   readonly eventHandler: (arg0: string, arg1: string) => void;
   nextObjectId = 1;
@@ -167,10 +157,8 @@ export class HeapSnapshotWorkerProxy extends Common.ObjectWrapper.ObjectWrapper<
       return;
     }
     if (data.error) {
-      if (data.errorMethodName) {
-        Common.Console.Console.instance().error(
-            i18nString(UIStrings.anErrorOccurredWhenACallToMethod, {PH1: data.errorMethodName}));
-      }
+      Common.Console.Console.instance().error(
+          `An error occurred when a call to method '${data.errorMethodName}' was requested`);
       Common.Console.Console.instance().error(data['errorCallStack']);
       this.callbacks.delete(data.callId);
       return;
@@ -263,7 +251,7 @@ export class HeapSnapshotLoaderProxy extends HeapSnapshotProxyObject implements
 }
 
 export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
-  staticData: HeapSnapshotModel.HeapSnapshotModel.StaticData|null;
+  staticData: HeapSnapshotModel.StaticData|null;
   profileUid?: string;
 
   constructor(worker: HeapSnapshotWorkerProxy, objectId: number) {
@@ -271,9 +259,7 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     this.staticData = null;
   }
 
-  search(
-      searchConfig: HeapSnapshotModel.HeapSnapshotModel.SearchConfig,
-      filter: HeapSnapshotModel.HeapSnapshotModel.NodeFilter): Promise<number[]> {
+  search(searchConfig: HeapSnapshotModel.SearchConfig, filter: HeapSnapshotModel.NodeFilter): Promise<number[]> {
     return this.callMethodPromise('search', searchConfig, filter);
   }
 
@@ -281,20 +267,19 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('interfaceDefinitions');
   }
 
-  aggregatesWithFilter(filter: HeapSnapshotModel.HeapSnapshotModel.NodeFilter):
-      Promise<Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>> {
+  aggregatesWithFilter(filter: HeapSnapshotModel.NodeFilter):
+      Promise<Record<string, HeapSnapshotModel.AggregatedInfo>> {
     return this.callMethodPromise('aggregatesWithFilter', filter);
   }
 
-  aggregatesForDiff(interfaceDefinitions: string):
-      Promise<Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregateForDiff>> {
+  aggregatesForDiff(interfaceDefinitions: string): Promise<Record<string, HeapSnapshotModel.AggregateForDiff>> {
     return this.callMethodPromise('aggregatesForDiff', interfaceDefinitions);
   }
 
   calculateSnapshotDiff(
       baseSnapshotId: string,
-      baseSnapshotAggregates: Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregateForDiff>,
-      ): Promise<Record<string, HeapSnapshotModel.HeapSnapshotModel.Diff>> {
+      baseSnapshotAggregates: Record<string, HeapSnapshotModel.AggregateForDiff>,
+      ): Promise<Record<string, HeapSnapshotModel.Diff>> {
     return this.callMethodPromise('calculateSnapshotDiff', baseSnapshotId, baseSnapshotAggregates);
   }
 
@@ -322,20 +307,19 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callFactoryMethod('createNodesProvider', HeapSnapshotProviderProxy, filter);
   }
 
-  createNodesProviderForClass(classKey: string, nodeFilter: HeapSnapshotModel.HeapSnapshotModel.NodeFilter):
-      HeapSnapshotProviderProxy {
+  createNodesProviderForClass(classKey: string, nodeFilter: HeapSnapshotModel.NodeFilter): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createNodesProviderForClass', HeapSnapshotProviderProxy, classKey, nodeFilter);
   }
 
-  allocationTracesTops(): Promise<HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[]> {
+  allocationTracesTops(): Promise<HeapSnapshotModel.SerializedAllocationNode[]> {
     return this.callMethodPromise('allocationTracesTops');
   }
 
-  allocationNodeCallers(nodeId: number): Promise<HeapSnapshotModel.HeapSnapshotModel.AllocationNodeCallers> {
+  allocationNodeCallers(nodeId: number): Promise<HeapSnapshotModel.AllocationNodeCallers> {
     return this.callMethodPromise('allocationNodeCallers', nodeId);
   }
 
-  allocationStack(nodeIndex: number): Promise<HeapSnapshotModel.HeapSnapshotModel.AllocationStackFrame[]|null> {
+  allocationStack(nodeIndex: number): Promise<HeapSnapshotModel.AllocationStackFrame[]|null> {
     return this.callMethodPromise('allocationStack', nodeIndex);
   }
 
@@ -361,15 +345,15 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     this.staticData = await this.callMethodPromise('updateStaticData');
   }
 
-  getStatistics(): Promise<HeapSnapshotModel.HeapSnapshotModel.Statistics> {
+  getStatistics(): Promise<HeapSnapshotModel.Statistics> {
     return this.callMethodPromise('getStatistics');
   }
 
-  getLocation(nodeIndex: number): Promise<HeapSnapshotModel.HeapSnapshotModel.Location|null> {
+  getLocation(nodeIndex: number): Promise<HeapSnapshotModel.Location|null> {
     return this.callMethodPromise('getLocation', nodeIndex);
   }
 
-  getSamples(): Promise<HeapSnapshotModel.HeapSnapshotModel.Samples|null> {
+  getSamples(): Promise<HeapSnapshotModel.Samples|null> {
     return this.callMethodPromise('getSamples');
   }
 
@@ -421,12 +405,11 @@ export class HeapSnapshotProviderProxy extends HeapSnapshotProxyObject implement
     return this.callMethodPromise('isEmpty');
   }
 
-  serializeItemsRange(startPosition: number, endPosition: number):
-      Promise<HeapSnapshotModel.HeapSnapshotModel.ItemsRange> {
+  serializeItemsRange(startPosition: number, endPosition: number): Promise<HeapSnapshotModel.ItemsRange> {
     return this.callMethodPromise('serializeItemsRange', startPosition, endPosition);
   }
 
-  async sortAndRewind(comparator: HeapSnapshotModel.HeapSnapshotModel.ComparatorConfig): Promise<void> {
+  async sortAndRewind(comparator: HeapSnapshotModel.ComparatorConfig): Promise<void> {
     await this.callMethodPromise('sortAndRewind', comparator);
   }
 }

package/front_end/models/heap_snapshot_model/heap_snapshot_model.ts

@@ -2,8 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as ChildrenProvider from './ChildrenProvider.js';
 import * as HeapSnapshotModel from './HeapSnapshotModel.js';
+import * as HeapSnapshotProxy from './HeapSnapshotProxy.js';
 
 export {
+  ChildrenProvider,
   HeapSnapshotModel,
+  HeapSnapshotProxy,
 };

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -6908,10 +6908,6 @@ export const NativeFunctions = [
     name: "MouseEvent",
     signatures: [["type","?eventInitDict"]]
   },
-  {
-    name: "PageHideEvent",
-    signatures: [["type","?eventInitDict"]]
-  },
   {
     name: "PageTransitionEvent",
     signatures: [["type","?eventInitDict"]]