chrome-devtools-frontend 1.0.1543082 → 1.0.1544076

package/front_end/models/ai_code_generation/AiCodeGeneration.ts

@@ -73,6 +73,7 @@ export class AiCodeGeneration {
         inference_language: inferenceLanguage,
         temperature: validTemperature(this.#options.temperature),
         model_id: this.#options.modelId || undefined,
+        expect_code_output: true,
       },
       metadata: {
         disable_user_content_logging: !(this.#serverSideLoggingEnabled ?? false),
@@ -139,10 +140,11 @@ export class AiCodeGeneration {
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeGenerationSuggestionAccepted);
   }
 
-  async generateCode(prompt: string, preamble: string, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage):
-      Promise<Host.AidaClient.GenerateCodeResponse|null> {
+  async generateCode(
+      prompt: string, preamble: string, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
+      options?: {signal?: AbortSignal}): Promise<Host.AidaClient.GenerateCodeResponse|null> {
     const request = this.#buildRequest(prompt, preamble, inferenceLanguage);
-    const response = await this.#aidaClient.generateCode(request);
+    const response = await this.#aidaClient.generateCode(request, options);
 
     debugLog({request, response});
 

package/front_end/models/bindings/CSSWorkspaceBinding.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Workspace from '../workspace/workspace.js';
 
@@ -16,15 +17,14 @@ import type {ResourceMapping} from './ResourceMapping.js';
 import {SASSSourceMapping} from './SASSSourceMapping.js';
 import {StylesSourceMapping} from './StylesSourceMapping.js';
 
-let cssWorkspaceBindingInstance: CSSWorkspaceBinding|undefined;
-
 export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<SDK.CSSModel.CSSModel> {
   readonly #resourceMapping: ResourceMapping;
   readonly #modelToInfo: Map<SDK.CSSModel.CSSModel, ModelInfo>;
   readonly #liveLocationPromises: Set<Promise<unknown>>;
 
-  private constructor(resourceMapping: ResourceMapping, targetManager: SDK.TargetManager.TargetManager) {
+  constructor(resourceMapping: ResourceMapping, targetManager: SDK.TargetManager.TargetManager) {
     this.#resourceMapping = resourceMapping;
+    this.#resourceMapping.cssWorkspaceBinding = this;
     this.#modelToInfo = new Map();
     targetManager.observeModels(SDK.CSSModel.CSSModel, this);
 
@@ -37,20 +37,21 @@ export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<S
     targetManager: SDK.TargetManager.TargetManager|null,
   } = {forceNew: null, resourceMapping: null, targetManager: null}): CSSWorkspaceBinding {
     const {forceNew, resourceMapping, targetManager} = opts;
-    if (!cssWorkspaceBindingInstance || forceNew) {
+    if (forceNew) {
       if (!resourceMapping || !targetManager) {
         throw new Error(`Unable to create CSSWorkspaceBinding: resourceMapping and targetManager must be provided: ${
             new Error().stack}`);
       }
 
-      cssWorkspaceBindingInstance = new CSSWorkspaceBinding(resourceMapping, targetManager);
+      Root.DevToolsContext.globalInstance().set(
+          CSSWorkspaceBinding, new CSSWorkspaceBinding(resourceMapping, targetManager));
     }
 
-    return cssWorkspaceBindingInstance;
+    return Root.DevToolsContext.globalInstance().get(CSSWorkspaceBinding);
   }
 
   static removeInstance(): void {
-    cssWorkspaceBindingInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(CSSWorkspaceBinding);
   }
 
   get modelToInfo(): Map<SDK.CSSModel.CSSModel, ModelInfo> {

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import type * as StackTrace from '../stack_trace/stack_trace.js';
@@ -20,20 +21,21 @@ import {NetworkProject} from './NetworkProject.js';
 import type {ResourceMapping} from './ResourceMapping.js';
 import {type ResourceScriptFile, ResourceScriptMapping} from './ResourceScriptMapping.js';
 
-let debuggerWorkspaceBindingInstance: DebuggerWorkspaceBinding|undefined;
-
 export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
   readonly resourceMapping: ResourceMapping;
   readonly #debuggerModelToData: Map<SDK.DebuggerModel.DebuggerModel, ModelData>;
   readonly #liveLocationPromises: Set<Promise<void|Location|StackTraceTopFrameLocation|null>>;
   readonly pluginManager: DebuggerLanguagePluginManager;
   readonly ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager;
+  readonly workspace: Workspace.Workspace.WorkspaceImpl;
 
-  private constructor(
+  constructor(
       resourceMapping: ResourceMapping, targetManager: SDK.TargetManager.TargetManager,
-      ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager) {
+      ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager, workspace: Workspace.Workspace.WorkspaceImpl) {
     this.resourceMapping = resourceMapping;
+    this.resourceMapping.debuggerWorkspaceBinding = this;
     this.ignoreListManager = ignoreListManager;
+    this.workspace = workspace;
 
     this.#debuggerModelToData = new Map();
     targetManager.addModelListener(
@@ -62,24 +64,27 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     resourceMapping: ResourceMapping|null,
     targetManager: SDK.TargetManager.TargetManager|null,
     ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager|null,
-  } = {forceNew: null, resourceMapping: null, targetManager: null, ignoreListManager: null}): DebuggerWorkspaceBinding {
-    const {forceNew, resourceMapping, targetManager, ignoreListManager} = opts;
-    if (!debuggerWorkspaceBindingInstance || forceNew) {
-      if (!resourceMapping || !targetManager || !ignoreListManager) {
+    workspace: Workspace.Workspace.WorkspaceImpl|null,
+  } = {forceNew: null, resourceMapping: null, targetManager: null, ignoreListManager: null, workspace: null}):
+      DebuggerWorkspaceBinding {
+    const {forceNew, resourceMapping, targetManager, ignoreListManager, workspace} = opts;
+    if (forceNew) {
+      if (!resourceMapping || !targetManager || !ignoreListManager || !workspace) {
         throw new Error(
             `Unable to create DebuggerWorkspaceBinding: resourceMapping, targetManager and IgnoreLIstManager must be provided: ${
                 new Error().stack}`);
       }
 
-      debuggerWorkspaceBindingInstance =
-          new DebuggerWorkspaceBinding(resourceMapping, targetManager, ignoreListManager);
+      Root.DevToolsContext.globalInstance().set(
+          DebuggerWorkspaceBinding,
+          new DebuggerWorkspaceBinding(resourceMapping, targetManager, ignoreListManager, workspace));
     }
 
-    return debuggerWorkspaceBindingInstance;
+    return Root.DevToolsContext.globalInstance().get(DebuggerWorkspaceBinding);
   }
 
   static removeInstance(): void {
-    debuggerWorkspaceBindingInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(DebuggerWorkspaceBinding);
   }
 
   private async computeAutoStepRanges(mode: SDK.DebuggerModel.StepMode, callFrame: SDK.DebuggerModel.CallFrame):
@@ -271,11 +276,10 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
   waitForUISourceCodeAdded(url: Platform.DevToolsPath.UrlString, target: SDK.Target.Target):
       Promise<Workspace.UISourceCode.UISourceCode> {
     return new Promise(resolve => {
-      const workspace = Workspace.Workspace.WorkspaceImpl.instance();
-      const descriptor = workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, event => {
+      const descriptor = this.workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, event => {
         const uiSourceCode = event.data;
         if (uiSourceCode.url() === url && NetworkProject.targetForUISourceCode(uiSourceCode) === target) {
-          workspace.removeEventListener(Workspace.Workspace.Events.UISourceCodeAdded, descriptor.listener);
+          this.workspace.removeEventListener(Workspace.Workspace.Events.UISourceCodeAdded, descriptor.listener);
           resolve(uiSourceCode);
         }
       });

package/front_end/models/bindings/ResourceMapping.ts

@@ -9,8 +9,8 @@ import * as TextUtils from '../text_utils/text_utils.js';
 import * as Workspace from '../workspace/workspace.js';
 
 import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
-import {CSSWorkspaceBinding} from './CSSWorkspaceBinding.js';
-import {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
+import type {CSSWorkspaceBinding} from './CSSWorkspaceBinding.js';
+import type {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
 import {NetworkProject} from './NetworkProject.js';
 import {resourceMetadata} from './ResourceUtils.js';
 
@@ -30,13 +30,46 @@ export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.R
   readonly workspace: Workspace.Workspace.WorkspaceImpl;
   readonly #modelToInfo = new Map<SDK.ResourceTreeModel.ResourceTreeModel, ModelInfo>();
 
+  #debuggerWorkspaceBinding: DebuggerWorkspaceBinding|null = null;
+  #cssWorkspaceBinding: CSSWorkspaceBinding|null = null;
+
   constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) {
     this.workspace = workspace;
     targetManager.observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
   }
 
+  get debuggerWorkspaceBinding(): DebuggerWorkspaceBinding|null {
+    // TODO(crbug.com/458180550): Throw when this.#debuggerWorkspaceBinding is null and never return null.
+    //                            The only reason we don't throw and return an instance unconditionally
+    //                            is that unit tests often don't set-up both the *WorkspaceBindings.
+    return this.#debuggerWorkspaceBinding;
+  }
+
+  /* {@link DebuggerWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */
+  set debuggerWorkspaceBinding(debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
+    if (this.#debuggerWorkspaceBinding) {
+      throw new Error('DebuggerWorkspaceBinding already set');
+    }
+    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+  }
+
+  get cssWorkspaceBinding(): CSSWorkspaceBinding|null {
+    // TODO(crbug.com/458180550): Throw when this.#cssWorkspaceBinding is null and never return null.
+    //                            The only reason we don't throw and return an instance unconditionally
+    //                            is that unit tests often don't set-up both the *WorkspaceBindings.
+    return this.#cssWorkspaceBinding;
+  }
+
+  /* {@link CSSWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */
+  set cssWorkspaceBinding(cssWorkspaceBinding: CSSWorkspaceBinding) {
+    if (this.#cssWorkspaceBinding) {
+      throw new Error('CSSWorkspaceBinding already set');
+    }
+    this.#cssWorkspaceBinding = cssWorkspaceBinding;
+  }
+
   modelAdded(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
-    const info = new ModelInfo(this.workspace, resourceTreeModel);
+    const info = new ModelInfo(this, resourceTreeModel);
     this.#modelToInfo.set(resourceTreeModel, info);
   }
 
@@ -250,11 +283,13 @@ class ModelInfo {
   readonly #bindings = new Map<string, Binding>();
   readonly #cssModel: SDK.CSSModel.CSSModel;
   readonly #eventListeners: Common.EventTarget.EventDescriptor[];
-  constructor(
-      workspace: Workspace.Workspace.WorkspaceImpl, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) {
+  readonly resourceMapping: ResourceMapping;
+
+  constructor(resourceMapping: ResourceMapping, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) {
     const target = resourceTreeModel.target();
+    this.resourceMapping = resourceMapping;
     this.project = new ContentProviderBasedProject(
-        workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
+        resourceMapping.workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
         false /* isServiceProject */);
     NetworkProject.setTargetForProject(this.project, target);
 
@@ -332,7 +367,7 @@ class ModelInfo {
 
     let binding = this.#bindings.get(resource.url);
     if (!binding) {
-      binding = new Binding(this.project, resource);
+      binding = new Binding(this, resource);
       this.#bindings.set(resource.url, binding);
     } else {
       binding.addResource(resource);
@@ -396,9 +431,16 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
     stylesheet: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader,
     edit: SDK.CSSModel.Edit|null,
   }> = [];
-  constructor(project: ContentProviderBasedProject, resource: SDK.Resource.Resource) {
+
+  readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding|null;
+  readonly #cssWorkspaceBinding: CSSWorkspaceBinding|null;
+
+  constructor(modelInfo: ModelInfo, resource: SDK.Resource.Resource) {
     this.resources = new Set([resource]);
-    this.#project = project;
+    this.#project = modelInfo.project;
+    this.#debuggerWorkspaceBinding = modelInfo.resourceMapping.debuggerWorkspaceBinding;
+    this.#cssWorkspaceBinding = modelInfo.resourceMapping.cssWorkspaceBinding;
+
     this.#uiSourceCode = this.#project.createUISourceCode(resource.url, resource.contentType());
     boundUISourceCodes.add(this.#uiSourceCode);
     if (resource.frameId) {
@@ -407,8 +449,8 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
     this.#project.addUISourceCodeWithProvider(this.#uiSourceCode, this, resourceMetadata(resource), resource.mimeType);
 
     void Promise.all([
-      ...this.inlineScripts().map(script => DebuggerWorkspaceBinding.instance().updateLocations(script)),
-      ...this.inlineStyles().map(style => CSSWorkspaceBinding.instance().updateLocations(style)),
+      ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)),
+      ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)),
     ]);
   }
 
@@ -478,7 +520,7 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
           continue;
         }
         scriptRangeMap.set(script, range.rebaseAfterTextEdit(oldRange, newRange));
-        updatePromises.push(DebuggerWorkspaceBinding.instance().updateLocations(script));
+        updatePromises.push(this.#debuggerWorkspaceBinding?.updateLocations(script));
       }
       for (const style of styles) {
         const range = styleSheetRangeMap.get(style) ?? computeStyleSheetRange(style);
@@ -486,7 +528,7 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
           continue;
         }
         styleSheetRangeMap.set(style, range.rebaseAfterTextEdit(oldRange, newRange));
-        updatePromises.push(CSSWorkspaceBinding.instance().updateLocations(style));
+        updatePromises.push(this.#cssWorkspaceBinding?.updateLocations(style));
       }
       await Promise.all(updatePromises);
     }
@@ -510,8 +552,8 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
   dispose(): void {
     this.#project.removeUISourceCode(this.#uiSourceCode.url());
     void Promise.all([
-      ...this.inlineScripts().map(script => DebuggerWorkspaceBinding.instance().updateLocations(script)),
-      ...this.inlineStyles().map(style => CSSWorkspaceBinding.instance().updateLocations(style)),
+      ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)),
+      ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)),
     ]);
   }
 

package/front_end/models/live-metrics/LiveMetrics.ts

@@ -163,7 +163,8 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
    * DOM nodes can't be sent over a runtime binding, so we have to retrieve
    * them separately.
    */
-  async #resolveNodeRef(index: number, executionContextId: Protocol.Runtime.ExecutionContextId): Promise<NodeRef|null> {
+  async #resolveNodeRef(index: number, executionContextId: Protocol.Runtime.ExecutionContextId):
+      Promise<SDK.DOMModel.DOMNode|null> {
     if (!this.#target) {
       return null;
     }
@@ -195,8 +196,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
         return null;
       }
 
-      const link = await Common.Linkifier.Linkifier.linkify(node);
-      return {node, link};
+      return node;
     } catch {
       return null;
     } finally {
@@ -236,26 +236,23 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       ...this.#layoutShifts.flatMap(shift => shift.affectedNodeRefs),
     ].filter(nodeRef => !!nodeRef);
 
-    const idsToRefresh = new Set(toRefresh.map(nodeRef => nodeRef.node.backendNodeId()));
+    const idsToRefresh = new Set(toRefresh.map(nodeRef => nodeRef.backendNodeId()));
     const nodes = await domModel.pushNodesByBackendIdsToFrontend(idsToRefresh);
     if (!nodes) {
       return;
     }
 
-    const allPromises = toRefresh.map(async nodeRef => {
-      const refreshedNode = nodes.get(nodeRef.node.backendNodeId());
+    for (let i = 0; i < toRefresh.length; i++) {
+      const refreshedNode = nodes.get(toRefresh[i].backendNodeId());
 
       // It is possible for the refreshed node to be undefined even though it was defined previously.
       // We should keep the affected nodes consistent from the user perspective, so we will just keep the stale node instead of removing it.
       if (!refreshedNode) {
-        return;
+        continue;
       }
 
-      nodeRef.node = refreshedNode;
-      nodeRef.link = await Common.Linkifier.Linkifier.linkify(refreshedNode);
-    });
-
-    await Promise.all(allPromises);
+      toRefresh[i] = refreshedNode;
+    }
 
     this.#sendStatusUpdate();
   }
@@ -599,14 +596,9 @@ export interface MetricValue {
   warnings?: string[];
 }
 
-export interface NodeRef {
-  node: SDK.DOMModel.DOMNode;
-  link: Node;
-}
-
 export interface LcpValue extends MetricValue {
   phases: Spec.LcpPhases;
-  nodeRef?: NodeRef;
+  nodeRef?: SDK.DOMModel.DOMNode;
 }
 
 export interface InpValue extends MetricValue {
@@ -621,7 +613,7 @@ export interface ClsValue extends MetricValue {
 export interface LayoutShift {
   score: number;
   uniqueLayoutShiftId: Spec.UniqueLayoutShiftId;
-  affectedNodeRefs: NodeRef[];
+  affectedNodeRefs: SDK.DOMModel.DOMNode[];
 }
 
 export interface Interaction {
@@ -633,7 +625,7 @@ export interface Interaction {
   nextPaintTime: number;
   phases: Spec.InpPhases;
   longAnimationFrameTimings: Spec.PerformanceLongAnimationFrameTimingJSON[];
-  nodeRef?: NodeRef;
+  nodeRef?: SDK.DOMModel.DOMNode;
 }
 
 export interface StatusEvent {

package/front_end/models/trace/handlers/SamplesHandler.ts

@@ -22,25 +22,73 @@ let entryToNode = new Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNode
 // events matched by thread id.
 let preprocessedData = new Map<Types.Events.ProcessID, Map<Types.Events.ProfileID, PreprocessedData>>();
 
+/**
+ * Profile source selection priority when multiple profiles exist for the same thread.
+ *
+ * Profile sources and their typical scenarios:
+ * - 'Internal': Browser-initiated profiling performance panel traces.
+ *   This is the profiling mechanism when users click "Record" in the Devtools UI.
+ * - 'Inspector': User-initiated via console.profile()/profileEnd() calls.
+ *   Represents explicit developer intent to profile specific code.
+ * - 'SelfProfiling': Page-initiated via JS Self-Profiling API.
+ *    Lower signal vs the two above; treated as fallback.
+ *
+ * Selection strategy:
+ * - CPU Profile mode: Prefer 'Inspector' (explicit user request).
+ * - Performance trace: Prefer 'Internal' (integrated timeline context), then 'Inspector'.
+ * - Sources not in the priority list (including 'SelfProfiling') act as fallbacks.
+ *   When no priority source matches, the first candidate profile is selected.
+ */
+const PROFILE_SOURCES_BY_PRIORITY = {
+  cpuProfile: ['Inspector'] as Types.Events.ProfileSource[],
+  performanceTrace: ['Internal', 'Inspector'] as Types.Events.ProfileSource[],
+};
+
 function parseCPUProfileData(parseOptions: Types.Configuration.ParseOptions): void {
+  const priorityList =
+      parseOptions.isCPUProfile ? PROFILE_SOURCES_BY_PRIORITY.cpuProfile : PROFILE_SOURCES_BY_PRIORITY.performanceTrace;
+
   for (const [processId, profiles] of preprocessedData) {
+    const profilesByThread =
+        new Map<Types.Events.ThreadID, Array<{id: Types.Events.ProfileID, data: PreprocessedData}>>();
     for (const [profileId, preProcessedData] of profiles) {
       const threadId = preProcessedData.threadId;
-      if (!preProcessedData.rawProfile.nodes.length || threadId === undefined) {
+      if (threadId === undefined) {
+        continue;
+      }
+      const listForThread = Platform.MapUtilities.getWithDefault(profilesByThread, threadId, () => []);
+      listForThread.push({id: profileId, data: preProcessedData});
+    }
+
+    for (const [threadId, candidates] of profilesByThread) {
+      if (!candidates.length) {
+        continue;
+      }
+      let chosen = candidates[0];
+      for (const source of priorityList) {
+        const match = candidates.find(p => p.data.source === source);
+        if (match) {
+          chosen = match;
+          break;
+        }
+      }
+      const chosenData = chosen.data;
+      if (!chosenData.rawProfile.nodes.length) {
         continue;
       }
       const indexStack: number[] = [];
 
-      const profileModel = new CPUProfile.CPUProfileDataModel.CPUProfileDataModel(preProcessedData.rawProfile);
+      const profileModel = new CPUProfile.CPUProfileDataModel.CPUProfileDataModel(chosenData.rawProfile);
       const profileTree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
       profileTree.maxDepth = profileModel.maxDepth;
 
+      const selectedProfileId = chosen.id;
       const finalizedData: ProfileData = {
-        rawProfile: preProcessedData.rawProfile,
+        rawProfile: chosenData.rawProfile,
         parsedProfile: profileModel,
         profileCalls: [],
         profileTree,
-        profileId,
+        profileId: selectedProfileId,
       };
       const dataByThread = Platform.MapUtilities.getWithDefault(profilesInProcess, processId, () => new Map());
       dataByThread.set(threadId, finalizedData);
@@ -62,7 +110,8 @@ function parseCPUProfileData(parseOptions: Types.Configuration.ParseOptions): vo
           const ts = Helpers.Timing.milliToMicro(Types.Timing.Milli(timeStampMilliseconds));
           const nodeId = node.id as Helpers.TreeHelpers.TraceEntryNodeId;
 
-          const profileCall = Helpers.Trace.makeProfileCall(node, profileId, sampleIndex, ts, processId, threadId);
+          const profileCall =
+              Helpers.Trace.makeProfileCall(node, selectedProfileId, sampleIndex, ts, processId, threadId);
           finalizedData.profileCalls.push(profileCall);
           indexStack.push(finalizedData.profileCalls.length - 1);
           const traceEntryNode = Helpers.TreeHelpers.makeEmptyTraceEntryNode(profileCall, nodeId);
@@ -83,7 +132,7 @@ function parseCPUProfileData(parseOptions: Types.Configuration.ParseOptions): vo
           }
           const {callFrame, ts, pid, tid} = profileCall;
           const traceEntryNode = entryToNode.get(profileCall);
-          if (callFrame === undefined || ts === undefined || pid === undefined || profileId === undefined ||
+          if (callFrame === undefined || ts === undefined || pid === undefined || selectedProfileId === undefined ||
               tid === undefined || traceEntryNode === undefined) {
             return;
           }
@@ -138,6 +187,7 @@ export function handleEvent(event: Types.Events.Event): void {
     const profileData = getOrCreatePreProcessedData(event.pid, event.id);
     profileData.rawProfile.startTime = event.ts;
     profileData.threadId = event.tid;
+    assignProfileSourceIfKnown(profileData, event.args?.data?.source);
     return;
   }
   if (Types.Events.isProfileChunk(event)) {
@@ -186,6 +236,7 @@ export function handleEvent(event: Types.Events.Event): void {
       const timeDeltas: number[] = cdpProfile.timeDeltas;
       cdpProfile.endTime = timeDeltas.reduce((x, y) => x + y, cdpProfile.startTime);
     }
+    assignProfileSourceIfKnown(profileData, event.args?.data?.source);
     return;
   }
 }
@@ -194,6 +245,12 @@ export async function finalize(parseOptions: Types.Configuration.ParseOptions =
   parseCPUProfileData(parseOptions);
 }
 
+function assignProfileSourceIfKnown(profileData: PreprocessedData, source: unknown): void {
+  if (Types.Events.VALID_PROFILE_SOURCES.includes(source as Types.Events.ProfileSource)) {
+    profileData.source = source as Types.Events.ProfileSource;
+  }
+}
+
 export function data(): SamplesHandlerData {
   return {
     profilesInProcess,
@@ -251,6 +308,7 @@ interface PreprocessedData {
   rawProfile: CPUProfile.CPUProfileDataModel.ExtendedProfile;
   profileId: Types.Events.ProfileID;
   threadId?: Types.Events.ThreadID;
+  source?: Types.Events.ProfileSource;
 }
 
 /**

package/front_end/models/trace/types/TraceEvents.ts

@@ -161,6 +161,7 @@ export interface Profile extends Sample {
   args: Args&{
     data: ArgsData & {
       startTime: Micro,
+      source?: ProfileSource,
     },
   };
 }
@@ -174,6 +175,7 @@ export interface ProfileChunk extends Sample {
       cpuProfile?: PartialProfile,
       timeDeltas?: Micro[],
       lines?: Micro[],
+      source?: ProfileSource,
     },
   };
 }
@@ -191,6 +193,20 @@ export interface PartialProfile {
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 
+/**
+ * Source of profile data, used to select the most relevant profile when
+ * multiple profiles exist for the same thread.
+ *
+ * - 'Inspector': User-initiated via console.profile()/profileEnd().
+ * - 'Internal': Browser-initiated during performance traces.
+ * - 'SelfProfiling': Page-initiated via JS Self-Profiling API.
+ *
+ * Selection priority (see PROFILE_SOURCES_BY_PRIORITY in SamplesHandler.ts).
+ */
+export type ProfileSource = 'Inspector'|'SelfProfiling'|'Internal';
+
+export const VALID_PROFILE_SOURCES: readonly ProfileSource[] = ['Inspector', 'SelfProfiling', 'Internal'] as const;
+
 export interface PartialNode {
   callFrame: CallFrame;
   id: CallFrameID;

package/front_end/models/workspace/IgnoreListManager.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 
 import type {UISourceCode} from './UISourceCode.js';
@@ -40,8 +41,6 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/workspace/IgnoreListManager.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-let ignoreListManagerInstance: IgnoreListManager|undefined;
-
 export interface IgnoreListGeneralRules {
   isContentScript?: boolean;
   isKnownThirdParty?: boolean;
@@ -57,7 +56,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper<EventT
   readonly #isIgnoreListedURLCache = new Map<string, boolean>();
   readonly #contentScriptExecutionContexts = new Set<string>();
 
-  private constructor(settings: Common.Settings.Settings, targetManager: SDK.TargetManager.TargetManager) {
+  constructor(settings: Common.Settings.Settings, targetManager: SDK.TargetManager.TargetManager) {
     super();
     this.#settings = settings;
     this.#targetManager = targetManager;
@@ -89,17 +88,19 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper<EventT
     forceNew: null,
   }): IgnoreListManager {
     const {forceNew} = opts;
-    if (!ignoreListManagerInstance || forceNew) {
-      ignoreListManagerInstance = new IgnoreListManager(
-          opts.settings ?? Common.Settings.Settings.instance(),
-          opts.targetManager ?? SDK.TargetManager.TargetManager.instance());
+    if (forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          IgnoreListManager,
+          new IgnoreListManager(
+              opts.settings ?? Common.Settings.Settings.instance(),
+              opts.targetManager ?? SDK.TargetManager.TargetManager.instance()));
     }
 
-    return ignoreListManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(IgnoreListManager);
   }
 
   static removeInstance(): void {
-    ignoreListManagerInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(IgnoreListManager);
   }
 
   addChangeListener(listener: () => void): void {

package/front_end/models/workspace/WorkspaceImpl.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import type * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import type * as TextUtils from '../text_utils/text_utils.js';
 
 import type {SearchConfig} from './SearchConfig.js';
@@ -183,27 +184,21 @@ export abstract class ProjectStore implements Project {
       progress: Common.Progress.Progress): Promise<Map<UISourceCode, TextUtils.ContentProvider.SearchMatch[]|null>>;
 }
 
-let workspaceInstance: WorkspaceImpl|undefined;
-
 export class WorkspaceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #projects = new Map<string, Project>();
   #hasResourceContentTrackingExtensions = false;
 
-  private constructor() {
-    super();
-  }
-
   static instance(opts: {forceNew: boolean|null} = {forceNew: null}): WorkspaceImpl {
     const {forceNew} = opts;
-    if (!workspaceInstance || forceNew) {
-      workspaceInstance = new WorkspaceImpl();
+    if (!Root.DevToolsContext.globalInstance().has(WorkspaceImpl) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(WorkspaceImpl, new WorkspaceImpl());
     }
 
-    return workspaceInstance;
+    return Root.DevToolsContext.globalInstance().get(WorkspaceImpl);
   }
 
   static removeInstance(): void {
-    workspaceInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(WorkspaceImpl);
   }
 
   uiSourceCode(projectId: string, url: Platform.DevToolsPath.UrlString): UISourceCode|null {