chrome-devtools-frontend 1.0.1541169 → 1.0.1542501

package/front_end/ui/components/text_editor/AiCodeCompletionProvider.ts

@@ -5,7 +5,7 @@
 import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import * as Root from '../../../core/root/root.js';
+import * as AiCodeCompletion from '../../../models/ai_code_completion/ai_code_completion.js';
 import * as PanelCommon from '../../../panels/common/common.js';
 import * as CodeMirror from '../../../third_party/codemirror.next/codemirror.next.js';
 import * as UI from '../../legacy/legacy.js';
@@ -13,9 +13,12 @@ import * as VisualLogging from '../../visual_logging/visual_logging.js';
 
 import {AiCodeCompletionTeaserPlaceholder} from './AiCodeCompletionTeaserPlaceholder.js';
 import {
+  acceptAiAutoCompleteSuggestion,
   aiAutoCompleteSuggestion,
   aiAutoCompleteSuggestionState,
+  hasActiveAiSuggestion,
   setAiAutoCompleteSuggestion,
+  showCompletionHint,
 } from './config.js';
 import type {TextEditor} from './TextEditor.js';
 
@@ -45,15 +48,18 @@ export interface AiCodeCompletionConfig {
   onFeatureDisabled: () => void;
   onSuggestionAccepted: () => void;
   onRequestTriggered: () => void;
+  // TODO(b/445394511): Move exposing citations to onSuggestionAccepted
   onResponseReceived: (citations: Host.AidaClient.Citation[]) => void;
+  panel: AiCodeCompletion.AiCodeCompletion.ContextFlavor;
 }
 
 export const DELAY_BEFORE_SHOWING_RESPONSE_MS = 500;
 export const AIDA_REQUEST_DEBOUNCE_TIMEOUT_MS = 200;
+const MAX_PREFIX_SUFFIX_LENGTH = 20_000;
 
-// TODO(samiyac): Add code relevant to AiCodeCompletion and for triggering requests
 export class AiCodeCompletionProvider {
   #aidaClient?: Host.AidaClient.AidaClient;
+  #aiCodeCompletion?: AiCodeCompletion.AiCodeCompletion.AiCodeCompletion;
   #aiCodeCompletionSetting = Common.Settings.Settings.instance().createSetting('ai-code-completion-enabled', false);
   #aiCodeCompletionTeaserDismissedSetting =
       Common.Settings.Settings.instance().createSetting('ai-code-completion-teaser-dismissed', false);
@@ -66,7 +72,8 @@ export class AiCodeCompletionProvider {
   #boundOnUpdateAiCodeCompletionState = this.#updateAiCodeCompletionState.bind(this);
 
   constructor(aiCodeCompletionConfig: AiCodeCompletionConfig) {
-    if (!this.#isAiCodeCompletionEnabled()) {
+    const devtoolsLocale = i18n.DevToolsLocale.DevToolsLocale.instance();
+    if (!AiCodeCompletion.AiCodeCompletion.AiCodeCompletion.isAiCodeCompletionEnabled(devtoolsLocale.locale)) {
       throw new Error('AI code completion feature is not enabled.');
     }
     this.#aiCodeCompletionConfig = aiCodeCompletionConfig;
@@ -74,10 +81,12 @@ export class AiCodeCompletionProvider {
 
   extension(): CodeMirror.Extension[] {
     return [
+      CodeMirror.EditorView.updateListener.of(update => this.#triggerAiCodeCompletion(update)),
       this.#teaserCompartment.of([]),
       aiAutoCompleteSuggestion,
       aiCodeCompletionTeaserModeState,
       aiAutoCompleteSuggestionState,
+      CodeMirror.Prec.highest(CodeMirror.keymap.of(this.#editorKeymap())),
     ];
   }
 
@@ -105,6 +114,10 @@ export class AiCodeCompletionProvider {
     void this.#updateAiCodeCompletionState();
   }
 
+  clearCache(): void {
+    this.#aiCodeCompletion?.clearCachedRequest();
+  }
+
   #setupAiCodeCompletion(): void {
     if (!this.#editor || !this.#aiCodeCompletionConfig) {
       return;
@@ -112,6 +125,11 @@ export class AiCodeCompletionProvider {
     if (!this.#aidaClient) {
       this.#aidaClient = new Host.AidaClient.AidaClient();
     }
+    if (!this.#aiCodeCompletion) {
+      this.#aiCodeCompletion = new AiCodeCompletion.AiCodeCompletion.AiCodeCompletion(
+          {aidaClient: this.#aidaClient}, this.#aiCodeCompletionConfig.panel, undefined,
+          this.#aiCodeCompletionConfig.completionContext.stopSequences);
+    }
     this.#aiCodeCompletionConfig.onFeatureEnabled();
   }
 
@@ -123,6 +141,7 @@ export class AiCodeCompletionProvider {
     this.#editor?.dispatch({
       effects: setAiAutoCompleteSuggestion.of(null),
     });
+    this.#aiCodeCompletion = undefined;
     this.#aiCodeCompletionConfig?.onFeatureDisabled();
   }
 
@@ -145,6 +164,40 @@ export class AiCodeCompletionProvider {
     }
   }
 
+  #editorKeymap(): readonly CodeMirror.KeyBinding[] {
+    return [
+      {
+        key: 'Escape',
+        run: (): boolean => {
+          if (!this.#aiCodeCompletion || !this.#editor || !hasActiveAiSuggestion(this.#editor.state)) {
+            return false;
+          }
+          this.#editor.dispatch({
+            effects: setAiAutoCompleteSuggestion.of(null),
+          });
+          return true;
+        },
+      },
+      {
+        key: 'Tab',
+        run: (): boolean => {
+          if (!this.#aiCodeCompletion || !this.#editor || !hasActiveAiSuggestion(this.#editor.state)) {
+            return false;
+          }
+          const {accepted, suggestion} = acceptAiAutoCompleteSuggestion(this.#editor.editor);
+          if (!accepted) {
+            return false;
+          }
+          if (suggestion?.rpcGlobalId) {
+            this.#aiCodeCompletion?.registerUserAcceptance(suggestion.rpcGlobalId, suggestion.sampleId);
+          }
+          this.#aiCodeCompletionConfig?.onSuggestionAccepted();
+          return true;
+        },
+      },
+    ];
+  }
+
   #detachTeaser(): void {
     if (!this.#teaser) {
       return;
@@ -152,18 +205,198 @@ export class AiCodeCompletionProvider {
     this.#editor?.editor.dispatch({effects: this.#teaserCompartment.reconfigure([])});
   }
 
-  // TODO(samiyac): Define static method in AiCodeCompletion and use that instead
-  #isAiCodeCompletionEnabled(): boolean {
-    const devtoolsLocale = i18n.DevToolsLocale.DevToolsLocale.instance();
-    const aidaAvailability = Root.Runtime.hostConfig.aidaAvailability;
-    if (!devtoolsLocale.locale.startsWith('en-')) {
-      return false;
+  #triggerAiCodeCompletion(update: CodeMirror.ViewUpdate): void {
+    if (!update.docChanged || !this.#editor || !this.#aiCodeCompletion) {
+      return;
+    }
+    const {doc, selection} = update.state;
+    const query = doc.toString();
+    const cursor = selection.main.head;
+
+    let prefix = query.substring(0, cursor);
+    if (prefix.trim().length === 0) {
+      return;
+    }
+    const completionContextPrefix = this.#aiCodeCompletionConfig?.completionContext.getPrefix?.();
+    if (completionContextPrefix) {
+      prefix = completionContextPrefix + prefix;
     }
-    if (!aidaAvailability || aidaAvailability.blockedByGeo || aidaAvailability.blockedByAge ||
-        aidaAvailability.blockedByEnterprisePolicy) {
-      return false;
+    if (prefix.length > MAX_PREFIX_SUFFIX_LENGTH) {
+      prefix = prefix.substring(prefix.length - MAX_PREFIX_SUFFIX_LENGTH);
+    }
+
+    const suffix = query.substring(cursor, cursor + MAX_PREFIX_SUFFIX_LENGTH);
+
+    this.#debouncedRequestAidaSuggestion(
+        prefix, suffix, cursor, this.#aiCodeCompletionConfig?.completionContext.inferenceLanguage,
+        this.#aiCodeCompletionConfig?.completionContext.additionalFiles);
+  }
+
+  #debouncedRequestAidaSuggestion = Common.Debouncer.debounce(
+      (prefix: string, suffix: string, cursorPositionAtRequest: number,
+       inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
+       additionalFiles?: Host.AidaClient.AdditionalFile[]) => {
+        void this.#requestAidaSuggestion(prefix, suffix, cursorPositionAtRequest, inferenceLanguage, additionalFiles);
+      },
+      AIDA_REQUEST_DEBOUNCE_TIMEOUT_MS);
+
+  async #requestAidaSuggestion(
+      prefix: string, suffix: string, cursorPositionAtRequest: number,
+      inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
+      additionalFiles?: Host.AidaClient.AdditionalFile[]): Promise<void> {
+    if (!this.#aiCodeCompletion) {
+      AiCodeCompletion.debugLog('Ai Code Completion is not initialized');
+      this.#aiCodeCompletionConfig?.onResponseReceived([]);
+      Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionError);
+      return;
+    }
+
+    const startTime = performance.now();
+    this.#aiCodeCompletionConfig?.onRequestTriggered();
+    // Registering AiCodeCompletionRequestTriggered metric even if the request is served from cache
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionRequestTriggered);
+
+    try {
+      const completionResponse = await this.#aiCodeCompletion.completeCode(
+          prefix, suffix, cursorPositionAtRequest, inferenceLanguage, additionalFiles);
+
+      if (!completionResponse) {
+        this.#aiCodeCompletionConfig?.onResponseReceived([]);
+        return;
+      }
+
+      const {response, fromCache} = completionResponse;
+
+      if (!response) {
+        this.#aiCodeCompletionConfig?.onResponseReceived([]);
+        return;
+      }
+
+      const sampleResponse = await this.#generateSampleForRequest(response, prefix, suffix);
+      if (!sampleResponse) {
+        this.#aiCodeCompletionConfig?.onResponseReceived([]);
+        return;
+      }
+
+      const {
+        suggestionText,
+        sampleId,
+        citations,
+        rpcGlobalId,
+      } = sampleResponse;
+      const remainingDelay = Math.max(
+          AiCodeCompletion.AiCodeCompletion.DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
+      this.#suggestionRenderingTimeout = window.setTimeout(() => {
+        const currentCursorPosition = this.#editor?.editor.state.selection.main.head;
+        if (currentCursorPosition !== cursorPositionAtRequest) {
+          this.#aiCodeCompletionConfig?.onResponseReceived([]);
+          return;
+        }
+        if (this.#aiCodeCompletion) {
+          this.#editor?.dispatch({
+            effects: setAiAutoCompleteSuggestion.of({
+              text: suggestionText,
+              from: cursorPositionAtRequest,
+              rpcGlobalId,
+              sampleId,
+              startTime,
+              clearCachedRequest: this.clearCache.bind(this),
+              onImpression: this.#aiCodeCompletion?.registerUserImpression.bind(this.#aiCodeCompletion),
+            })
+          });
+        }
+        if (fromCache) {
+          Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionResponseServedFromCache);
+        }
+
+        AiCodeCompletion.debugLog(
+            'Suggestion dispatched to the editor', suggestionText, 'at cursor position', cursorPositionAtRequest);
+        this.#aiCodeCompletionConfig?.onResponseReceived(citations);
+      }, remainingDelay);
+    } catch (e) {
+      AiCodeCompletion.debugLog('Error while fetching code completion suggestions from AIDA', e);
+      this.#aiCodeCompletionConfig?.onResponseReceived([]);
+      Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionError);
+    }
+  }
+
+  async #generateSampleForRequest(response: Host.AidaClient.CompletionResponse, prefix: string, suffix?: string):
+      Promise<{
+        suggestionText: string,
+        citations: Host.AidaClient.Citation[],
+        rpcGlobalId?: Host.AidaClient.RpcGlobalId,
+        sampleId?: number,
+      }|null> {
+    const suggestionSample = this.#pickSampleFromResponse(response);
+    if (!suggestionSample) {
+      return null;
+    }
+
+    const shouldBlock =
+        suggestionSample.attributionMetadata?.attributionAction === Host.AidaClient.RecitationAction.BLOCK;
+    if (shouldBlock) {
+      return null;
+    }
+
+    const isRepetitive = this.#checkIfSuggestionRepeatsExistingText(suggestionSample.generationString, prefix, suffix);
+    if (isRepetitive) {
+      return null;
+    }
+
+    const suggestionText = this.#trimSuggestionOverlap(suggestionSample.generationString, suffix);
+    if (suggestionText.length === 0) {
+      return null;
+    }
+
+    return {
+      suggestionText,
+      sampleId: suggestionSample.sampleId,
+      citations: suggestionSample.attributionMetadata?.citations ?? [],
+      rpcGlobalId: response.metadata.rpcGlobalId,
+    };
+  }
+
+  #pickSampleFromResponse(response: Host.AidaClient.CompletionResponse): Host.AidaClient.GenerationSample|null {
+    if (!response.generatedSamples.length) {
+      return null;
+    }
+
+    // `currentHint` is the portion of a standard autocomplete suggestion that the user has not yet typed.
+    // For example, if the user types `document.queryS` and the autocomplete suggests `document.querySelector`,
+    // the `currentHint` is `elector`.
+    const currentHintInMenu = this.#editor?.editor.plugin(showCompletionHint)?.currentHint;
+    if (!currentHintInMenu) {
+      return response.generatedSamples[0];
+    }
+
+    // TODO(ergunsh): This does not handle looking for `selectedCompletion`. The `currentHint` is `null`
+    // for the Sources panel case.
+    // Even though there is no match, we still return the first suggestion which will be displayed
+    // when the traditional autocomplete menu is closed.
+    return response.generatedSamples.find(sample => sample.generationString.startsWith(currentHintInMenu)) ??
+        response.generatedSamples[0];
+  }
+
+  #checkIfSuggestionRepeatsExistingText(generationString: string, prefix: string, suffix?: string): boolean {
+    return Boolean(prefix.includes(generationString.trim()) || suffix?.includes(generationString.trim()));
+  }
+
+  /**
+   * Removes the end of a suggestion if it overlaps with the start of the suffix.
+   */
+  #trimSuggestionOverlap(generationString: string, suffix?: string): string {
+    if (!suffix) {
+      return generationString;
+    }
+
+    // Iterate from the longest possible overlap down to the shortest
+    for (let i = Math.min(generationString.length, suffix.length); i > 0; i--) {
+      const overlapCandidate = suffix.substring(0, i);
+      if (generationString.endsWith(overlapCandidate)) {
+        return generationString.slice(0, -i);
+      }
     }
-    return Boolean(aidaAvailability.enabled && Root.Runtime.hostConfig.devToolsAiCodeCompletion?.enabled);
+    return generationString;
   }
 }
 

package/front_end/ui/components/text_editor/config.ts

@@ -483,7 +483,7 @@ export function contentIncludingHint(view: CM.EditorView): string {
 
 export const setAiAutoCompleteSuggestion = CM.StateEffect.define<ActiveSuggestion|null>();
 
-interface ActiveSuggestion {
+export interface ActiveSuggestion {
   text: string;
   from: number;
   sampleId?: number;

package/front_end/ui/legacy/Widget.ts

@@ -113,8 +113,10 @@ function cancelUpdate(widget: Widget): void {
 
 function runNextUpdate(): void {
   pendingAnimationFrame = null;
-  currentUpdateQueue = nextUpdateQueue;
-  nextUpdateQueue = new Map();
+  if (!currentUpdateQueue) {
+    currentUpdateQueue = nextUpdateQueue;
+    nextUpdateQueue = new Map();
+  }
   for (const [widget, {resolve}] of currentUpdateQueue) {
     currentlyProcessed.add(widget);
     void (async () => {
@@ -122,8 +124,15 @@ function runNextUpdate(): void {
       resolve();
     })();
   }
-  currentUpdateQueue = null;
-  currentlyProcessed.clear();
+  currentUpdateQueue.clear();
+  queueMicrotask(() => {
+    if (currentUpdateQueue && currentUpdateQueue.size > 0) {
+      runNextUpdate();
+    } else {
+      currentUpdateQueue = null;
+      currentlyProcessed.clear();
+    }
+  });
 }
 
 export class WidgetElement<WidgetT extends Widget> extends HTMLElement {

package/front_end/ui/legacy/components/object_ui/ObjectPropertiesSection.ts

@@ -320,6 +320,7 @@ class ArrayGroupTreeNode extends ObjectTreeNodeBase {
 }
 
 export class ObjectTreeNode extends ObjectTreeNodeBase {
+  #path?: string;
   constructor(
       readonly property: SDK.RemoteObject.RemoteObjectProperty,
       propertiesMode: ObjectPropertiesMode = ObjectPropertiesMode.OWN_AND_INTERNAL_AND_INHERITED,
@@ -336,6 +337,31 @@ export class ObjectTreeNode extends ObjectTreeNodeBase {
     return this.property.name;
   }
 
+  get path(): string {
+    if (!this.#path) {
+      if (this.property.synthetic) {
+        this.#path = this.name;
+        return this.name;
+      }
+
+      // https://tc39.es/ecma262/#prod-IdentifierName
+      const useDotNotation = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
+      const isInteger = /^(?:0|[1-9]\d*)$/;
+
+      const parentPath =
+          (this.parent instanceof ObjectTreeNode && !this.parent.property.synthetic) ? this.parent.path : '';
+
+      if (this.property.private || useDotNotation.test(this.name)) {
+        this.#path = parentPath ? `${parentPath}.${this.name}` : this.name;
+      } else if (isInteger.test(this.name)) {
+        this.#path = `${parentPath}[${this.name}]`;
+      } else {
+        this.#path = `${parentPath}[${JSON.stringify(this.name)}]`;
+      }
+    }
+    return this.#path;
+  }
+
   override selfOrParentIfInternal(): ObjectTreeNodeBase {
     return this.name === '[[Prototype]]' ? (this.parent ?? this) : this;
   }
@@ -830,6 +856,11 @@ export class RootElement extends UI.TreeOutline.TreeElement {
     this.listItemElement.addEventListener('contextmenu', this.onContextMenu.bind(this), false);
   }
 
+  override invalidateChildren(): void {
+    super.invalidateChildren();
+    this.object.removeChildren();
+  }
+
   override onexpand(): void {
     if (this.treeOutline) {
       this.treeOutline.element.classList.add('expanded');
@@ -1189,8 +1220,7 @@ export class ObjectPropertyTreeElement extends UI.TreeOutline.TreeElement {
     if (this.property.property.synthetic) {
       this.nameElement.classList.add('synthetic-property');
     }
-
-    this.updatePropertyPath();
+    this.nameElement.title = this.property.path;
 
     const isInternalEntries = this.property.property.synthetic && this.property.name === '[[Entries]]';
     if (isInternalEntries) {
@@ -1200,7 +1230,7 @@ export class ObjectPropertyTreeElement extends UI.TreeOutline.TreeElement {
       const showPreview = this.property.name !== '[[Prototype]]';
       this.propertyValue = ObjectPropertiesSection.createPropertyValueWithCustomSupport(
           this.property.object, this.property.property.wasThrown, showPreview, this.linkifier,
-          this.property.property.synthetic, this.path() /* variableName */);
+          this.property.property.synthetic, this.property.path /* variableName */);
       this.valueElement = this.propertyValue;
     } else if (this.property.property.getter) {
       this.valueElement = document.createElement('span');
@@ -1254,36 +1284,6 @@ export class ObjectPropertyTreeElement extends UI.TreeOutline.TreeElement {
     this.listItemElement.appendChild(this.rowContainer);
   }
 
-  private updatePropertyPath(): void {
-    if (this.nameElement.title) {
-      return;
-    }
-
-    const name = this.property.name;
-
-    if (this.property.property.synthetic) {
-      UI.Tooltip.Tooltip.install(this.nameElement, name);
-      return;
-    }
-
-    // https://tc39.es/ecma262/#prod-IdentifierName
-    const useDotNotation = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
-    const isInteger = /^(?:0|[1-9]\d*)$/;
-
-    const parentPath = (this.parent instanceof ObjectPropertyTreeElement && this.parent.nameElement &&
-                        !this.parent.property.property.synthetic) ?
-        this.parent.nameElement.title :
-        '';
-
-    if (this.property.property.private || useDotNotation.test(name)) {
-      UI.Tooltip.Tooltip.install(this.nameElement, parentPath ? `${parentPath}.${name}` : name);
-    } else if (isInteger.test(name)) {
-      UI.Tooltip.Tooltip.install(this.nameElement, `${parentPath}[${name}]`);
-    } else {
-      UI.Tooltip.Tooltip.install(this.nameElement, `${parentPath}[${JSON.stringify(name)}]`);
-    }
-  }
-
   getContextMenu(event: Event): UI.ContextMenu.ContextMenu {
     const contextMenu = new UI.ContextMenu.ContextMenu(event);
     contextMenu.appendApplicableItems(this);
@@ -1449,6 +1449,11 @@ export class ObjectPropertyTreeElement extends UI.TreeOutline.TreeElement {
     }
   }
 
+  override invalidateChildren(): void {
+    super.invalidateChildren();
+    this.property.removeChildren();
+  }
+
   private onInvokeGetterClick(result: SDK.RemoteObject.CallFunctionResult): void {
     if (!result.object) {
       return;
@@ -1642,6 +1647,11 @@ export class ArrayGroupingTreeElement extends UI.TreeOutline.TreeElement {
     ObjectPropertyTreeElement.populateWithProperties(treeNode, children, false, false, linkifier);
   }
 
+  override invalidateChildren(): void {
+    super.invalidateChildren();
+    this.#child.removeChildren();
+  }
+
   override async onpopulate(): Promise<void> {
     this.removeChildren();
     this.#child.removeChildren();

package/front_end/ui/visual_logging/KnownContextValues.ts

@@ -809,9 +809,14 @@ export const knownContextValues = new Set([
   'column-rule',
   'column-rule-break',
   'column-rule-color',
+  'column-rule-edge-end-inset',
   'column-rule-edge-end-outset',
+  'column-rule-edge-start-inset',
   'column-rule-edge-start-outset',
+  'column-rule-inset',
+  'column-rule-interior-end-inset',
   'column-rule-interior-end-outset',
+  'column-rule-interior-start-inset',
   'column-rule-interior-start-outset',
   'column-rule-outset',
   'column-rule-style',
@@ -3167,9 +3172,14 @@ export const knownContextValues = new Set([
   'row-rule',
   'row-rule-break',
   'row-rule-color',
+  'row-rule-edge-end-inset',
   'row-rule-edge-end-outset',
+  'row-rule-edge-start-inset',
   'row-rule-edge-start-outset',
+  'row-rule-inset',
+  'row-rule-interior-end-inset',
   'row-rule-interior-end-outset',
+  'row-rule-interior-start-inset',
   'row-rule-interior-start-outset',
   'row-rule-outset',
   'row-rule-style',
@@ -3184,6 +3194,7 @@ export const knownContextValues = new Set([
   'rule',
   'rule-break',
   'rule-color',
+  'rule-inset',
   'rule-outset',
   'rule-set',
   'rule-set-details',
@@ -3831,6 +3842,7 @@ export const knownContextValues = new Set([
   'timeline.annotation-sidebar.delete',
   'timeline.annotations-tab',
   'timeline.annotations.',
+  'timeline.annotations.ai-generate-label',
   'timeline.annotations.create-entries-link',
   'timeline.annotations.create-entry-label',
   'timeline.annotations.create-entry-link',

package/mcp/mcp.ts

@@ -10,6 +10,7 @@
 export * as Common from '../front_end/core/common/common.js';
 export * as I18n from '../front_end/core/i18n/i18n.js';
 export {ConnectionTransport} from '../front_end/core/protocol_client/ConnectionTransport.js';
+export * as Foundation from '../front_end/foundation/foundation.js';
 export {
   PerformanceInsightFormatter
 } from '../front_end/models/ai_assistance/data_formatters/PerformanceInsightFormatter.js';
@@ -30,4 +31,5 @@ export {
   IssuesManager
 } from '../front_end/models/issues_manager/IssuesManager.js';
 export {findTitleFromMarkdownAst} from '../front_end/models/issues_manager/MarkdownIssueDescription.js';
+export * as TraceEngine from '../front_end/models/trace/trace.js';
 export * as Marked from '../front_end/third_party/marked/marked.js';

package/package.json

@@ -103,5 +103,5 @@
       "flat-cache": "6.1.12"
     }
   },
-  "version": "1.0.1541169"
+  "version": "1.0.1542501"
 }

package/front_end/models/issues_manager/UserReidentificationIssue.ts

@@ -1,72 +0,0 @@
-// Copyright 2025 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 SDK from '../../core/sdk/sdk.js';
-import type * as Protocol from '../../generated/protocol.js';
-
-import {Issue, IssueCategory, IssueKind} from './Issue.js';
-import {
-  type LazyMarkdownIssueDescription,
-  type MarkdownIssueDescription,
-  resolveLazyDescription,
-} from './MarkdownIssueDescription.js';
-
-export class UserReidentificationIssue extends Issue {
-  #issueDetails: Protocol.Audits.UserReidentificationIssueDetails;
-
-  constructor(
-      issueDetails: Protocol.Audits.UserReidentificationIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel|null) {
-    super('UserReidentificationIssue', issuesModel);
-    this.#issueDetails = issueDetails;
-  }
-
-  primaryKey(): string {
-    const requestId = this.#issueDetails.request ? this.#issueDetails.request.requestId : 'no-request';
-    return `${this.code()}-(${requestId})`;
-  }
-
-  override requests(): Iterable<Protocol.Audits.AffectedRequest> {
-    return this.#issueDetails.request ? [this.#issueDetails.request] : [];
-  }
-
-  getCategory(): IssueCategory {
-    return IssueCategory.OTHER;
-  }
-
-  getDescription(): MarkdownIssueDescription|null {
-    const description = issueDescriptions.get(this.code());
-    if (!description) {
-      return null;
-    }
-    return resolveLazyDescription(description);
-  }
-
-  getKind(): IssueKind {
-    return IssueKind.IMPROVEMENT;
-  }
-
-  static fromInspectorIssue(
-      issuesModel: SDK.IssuesModel.IssuesModel|null,
-      inspectorIssue: Protocol.Audits.InspectorIssue): UserReidentificationIssue[] {
-    const userReidentificationIssueDetails = inspectorIssue.details.userReidentificationIssueDetails;
-    if (!userReidentificationIssueDetails) {
-      console.warn('User Reidentification issue without details received.');
-      return [];
-    }
-    return [new UserReidentificationIssue(userReidentificationIssueDetails, issuesModel)];
-  }
-}
-
-// Add new issue types to this map (with a unique code per type).
-const issueDescriptions = new Map<string, LazyMarkdownIssueDescription>([
-  [
-    'UserReidentificationIssue',
-    {
-      file: 'userReidentificationBlocked.md',
-      // TODO(https://g-issues.chromium.org/issues/409596758): Add
-      // internationalized learn more link text.
-      links: [],
-    },
-  ],
-]);

package/front_end/models/issues_manager/descriptions/userReidentificationBlocked.md

@@ -1,5 +0,0 @@
-# Resources suspected of tracking users are blocked
-
-This is currently an experimental feature. In case of site breakage, you can disable it for this page via the eye icon in the URL bar or completely disable it via chrome://settings/incognito. You may also report bugs [here](userReidentificationBugReports).
-
-Chrome identifies domains known to serve content which misuses web platform APIs to re-identify users across sites. Resources from these domains are blocked when users express a preference for additional privacy. Consider removing the following resources from your site:

package/front_end/ui/components/docs/markdown_image/basic.html

@@ -1,19 +0,0 @@
-<!--
-  Copyright 2021 The Chromium Authors
-  Use of this source code is governed by a BSD-style license that can be
-  found in the LICENSE file.
--->
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width" />
-    <title>Basic Markdown Image example</title>
-  </head>
-  <body>
-    <div id="icon"></div>
-    <div id="image"></div>
-
-    <script type="module" src="./basic.js"></script>
-  </body>
-</html>