chrome-devtools-frontend 1.0.1652307 → 1.0.1656291

package/front_end/models/heap_snapshot/HeapSnapshotModel.ts

@@ -316,4 +316,40 @@ export interface DuplicateStringGroup {
     distance: number,
   }>;
   truncated?: boolean;
+  length?: number;
+  hash?: number;
+}
+
+export interface NativeContextSize {
+  nodeId: number;
+  nodeIndex: number;
+  nodeName: string;
+  attributedSize: number;
+  retainedSize: number;
+  selfSize: number;
+}
+
+export interface NativeContextSizes {
+  nativeContexts: NativeContextSize[];
+  sharedSize: number;
+  noAttributionSize: number;
+}
+
+export const enum DOMLinkState {
+  UNKNOWN = 0,
+  ATTACHED = 1,
+  DETACHED = 2,
+}
+
+export interface ObjectInfo {
+  id: number;
+  name: string;
+  type: string;
+  nodeIndex: number;
+  detachedness: DOMLinkState;
+  selfSize: number;
+  retainedSize: number;
+  distance: number;
+  edgeCount: number;
+  retainerCount: number;
 }

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -267,6 +267,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('interfaceDefinitions');
   }
 
+  getNativeContextSizes(): Promise<HeapSnapshotModel.NativeContextSizes> {
+    return this.callMethodPromise('getNativeContextSizes');
+  }
+
   aggregatesWithFilter(filter: HeapSnapshotModel.NodeFilter):
       Promise<Record<string, HeapSnapshotModel.AggregatedInfo>> {
     return this.callMethodPromise('aggregatesWithFilter', filter);
@@ -295,6 +299,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('nodeIndexForId', nodeId);
   }
 
+  getObjectInfo(nodeIndex: number): Promise<HeapSnapshotModel.ObjectInfo> {
+    return this.callMethodPromise('getObjectInfo', nodeIndex);
+  }
+
   createEdgesProvider(nodeIndex: number): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
   }

package/front_end/models/issues_manager/IssuesManager.ts

@@ -180,6 +180,7 @@ export function createIssuesFromProtocolIssue(
 
 export interface IssuesManagerCreationOptions {
   forceNew: boolean;
+  frameManager?: SDK.FrameManager.FrameManager;
   /** Throw an error if this is not the first instance created */
   ensureFirst: boolean;
   showThirdPartyIssuesSetting?: Common.Settings.Setting<boolean>;
@@ -224,18 +225,20 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   #thirdPartyCookiePhaseoutIssueCount = new Map<IssueKind, number>();
   #issuesById = new Map<string, Issue>();
   #issuesByOutermostTarget: WeakMap<SDK.Target.Target, Set<Issue>> = new Map();
+  #frameManager: SDK.FrameManager.FrameManager;
 
-  constructor(
-      private readonly showThirdPartyIssuesSetting?: Common.Settings.Setting<boolean>,
-      private readonly hideIssueSetting?: Common.Settings.Setting<HideIssueMenuSetting>) {
+  constructor(private readonly showThirdPartyIssuesSetting?: Common.Settings.Setting<boolean>,
+              private readonly hideIssueSetting?: Common.Settings.Setting<HideIssueMenuSetting>,
+              frameManager: SDK.FrameManager.FrameManager = SDK.FrameManager.FrameManager.instance()) {
     super();
+    this.#frameManager = frameManager;
     new SourceFrameIssuesManager(this);
     SDK.TargetManager.TargetManager.instance().observeModels(SDK.IssuesModel.IssuesModel, this);
     SDK.TargetManager.TargetManager.instance().addModelListener(
         SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.PrimaryPageChanged,
         this.#onPrimaryPageChanged, this);
-    SDK.FrameManager.FrameManager.instance().addEventListener(
-        SDK.FrameManager.Events.FRAME_ADDED_TO_TARGET, this.#onFrameAddedToTarget, this);
+    this.#frameManager.addEventListener(SDK.FrameManager.Events.FRAME_ADDED_TO_TARGET, this.#onFrameAddedToTarget,
+                                        this);
 
     // issueFilter uses the 'show-third-party-issues' setting. Clients of IssuesManager need
     // a full update when the setting changes to get an up-to-date issues list.
@@ -263,7 +266,8 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     }
 
     if (!issuesManagerInstance || opts.forceNew) {
-      issuesManagerInstance = new IssuesManager(opts.showThirdPartyIssuesSetting, opts.hideIssueSetting);
+      issuesManagerInstance =
+          new IssuesManager(opts.showThirdPartyIssuesSetting, opts.hideIssueSetting, opts.frameManager);
     }
 
     return issuesManagerInstance;

package/front_end/models/javascript_metadata/JavaScriptMetadata.ts

@@ -3,11 +3,10 @@
 // found in the LICENSE file.
 
 import type * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
 
 import {NativeFunctions} from './NativeFunctions.js';
 
-let javaScriptMetadataInstance: JavaScriptMetadataImpl;
-
 export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScriptMetaData {
   private readonly uniqueFunctions: Map<string, string[][]>;
   private readonly receiverMethods: Map<string, Map<string, string[][]>>;
@@ -15,11 +14,11 @@ export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScr
     forceNew: boolean|null,
   } = {forceNew: null}): JavaScriptMetadataImpl {
     const {forceNew} = opts;
-    if (!javaScriptMetadataInstance || forceNew) {
-      javaScriptMetadataInstance = new JavaScriptMetadataImpl();
+    if (!Root.DevToolsContext.globalInstance().has(JavaScriptMetadataImpl) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(JavaScriptMetadataImpl, new JavaScriptMetadataImpl());
     }
 
-    return javaScriptMetadataInstance;
+    return Root.DevToolsContext.globalInstance().get(JavaScriptMetadataImpl);
   }
   constructor() {
     this.uniqueFunctions = new Map();

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -7255,7 +7255,7 @@ export const NativeFunctions = [
   },
   {
     name: "RTCEncodedAudioFrame",
-    signatures: [["originalFrame","?options"]]
+    signatures: [["init"],["originalFrame","?options"]]
   },
   {
     name: "setMetadata",

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

@@ -291,7 +291,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
         const warnings: string[] = [];
         const lcpEvent: LcpValue = {
           value: webVitalsEvent.value,
-          phases: webVitalsEvent.phases,
+          subparts: webVitalsEvent.subparts,
           warnings,
         };
         if (webVitalsEvent.nodeIndex !== undefined) {
@@ -323,7 +323,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       case 'INP': {
         const inpEvent: InpValue = {
           value: webVitalsEvent.value,
-          phases: webVitalsEvent.phases,
+          subparts: webVitalsEvent.subparts,
           interactionId: `interaction-${webVitalsEvent.entryGroupId}-${webVitalsEvent.startTime}`,
         };
         this.#inpValue = inpEvent;
@@ -345,7 +345,7 @@ export class LiveMetrics extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
             interactionType: webVitalsEvent.interactionType,
             duration: webVitalsEvent.duration,
             eventNames: [],
-            phases: webVitalsEvent.phases,
+            subparts: webVitalsEvent.subparts,
             startTime: webVitalsEvent.startTime,
             nextPaintTime: webVitalsEvent.nextPaintTime,
             longAnimationFrameTimings: webVitalsEvent.longAnimationFrameEntries,
@@ -610,12 +610,12 @@ export interface MetricValue {
 }
 
 export interface LcpValue extends MetricValue {
-  phases: Spec.LcpPhases;
+  subparts: Spec.LcpSubparts;
   nodeRef?: SDK.DOMModel.DOMNode;
 }
 
 export interface InpValue extends MetricValue {
-  phases: Spec.InpPhases;
+  subparts: Spec.InpSubparts;
   interactionId: InteractionId;
 }
 
@@ -636,7 +636,7 @@ export interface Interaction {
   duration: number;
   startTime: number;
   nextPaintTime: number;
-  phases: Spec.InpPhases;
+  subparts: Spec.InpSubparts;
   longAnimationFrameTimings: Spec.PerformanceLongAnimationFrameTimingJSON[];
   nodeRef?: SDK.DOMModel.DOMNode;
 }

package/front_end/models/live-metrics/web-vitals-injected/spec/spec.ts

@@ -18,14 +18,14 @@ export function getUniqueLayoutShiftId(entry: LayoutShift): UniqueLayoutShiftId
   return `layout-shift-${entry.value}-${entry.startTime}`;
 }
 
-export interface LcpPhases {
+export interface LcpSubparts {
   timeToFirstByte: Trace.Types.Timing.Milli;
   resourceLoadDelay: Trace.Types.Timing.Milli;
   resourceLoadTime: Trace.Types.Timing.Milli;
   elementRenderDelay: Trace.Types.Timing.Milli;
 }
 
-export interface InpPhases {
+export interface InpSubparts {
   inputDelay: Trace.Types.Timing.Milli;
   processingDuration: Trace.Types.Timing.Milli;
   presentationDelay: Trace.Types.Timing.Milli;
@@ -34,7 +34,7 @@ export interface InpPhases {
 export interface LcpChangeEvent {
   name: 'LCP';
   value: Trace.Types.Timing.Milli;
-  phases: LcpPhases;
+  subparts: LcpSubparts;
   startedHidden: boolean;
   nodeIndex?: number;
 }
@@ -49,7 +49,7 @@ export interface InpChangeEvent {
   name: 'INP';
   value: Trace.Types.Timing.Milli;
   interactionType: INPAttribution['interactionType'];
-  phases: InpPhases;
+  subparts: InpSubparts;
   startTime: number;
   entryGroupId: InteractionEntryGroupId;
 }
@@ -95,7 +95,7 @@ export interface InteractionEntryEvent {
   startTime: number;
   nextPaintTime: number;
   duration: Trace.Types.Timing.Milli;
-  phases: InpPhases;
+  subparts: InpSubparts;
   nodeIndex?: number;
   longAnimationFrameEntries: PerformanceLongAnimationFrameTimingJSON[];
 }

package/front_end/models/live-metrics/web-vitals-injected/web-vitals-injected.ts

@@ -182,7 +182,7 @@ function initialize(): void {
       name: 'LCP',
       value: metric.value as Trace.Types.Timing.Milli,
       startedHidden: Boolean(startedHidden),
-      phases: {
+      subparts: {
         timeToFirstByte: metric.attribution.timeToFirstByte as Trace.Types.Timing.Milli,
         resourceLoadDelay: metric.attribution.resourceLoadDelay as Trace.Types.Timing.Milli,
         resourceLoadTime: metric.attribution.resourceLoadDuration as Trace.Types.Timing.Milli,
@@ -213,7 +213,7 @@ function initialize(): void {
     const event: Spec.InteractionEntryEvent = {
       name: 'InteractionEntry',
       duration: interaction.value as Trace.Types.Timing.Milli,
-      phases: {
+      subparts: {
         inputDelay: interaction.attribution.inputDelay as Trace.Types.Timing.Milli,
         processingDuration: interaction.attribution.processingDuration as Trace.Types.Timing.Milli,
         presentationDelay: interaction.attribution.presentationDelay as Trace.Types.Timing.Milli,
@@ -238,7 +238,7 @@ function initialize(): void {
     const event: Spec.InpChangeEvent = {
       name: 'INP',
       value: metric.value as Trace.Types.Timing.Milli,
-      phases: {
+      subparts: {
         inputDelay: metric.attribution.inputDelay as Trace.Types.Timing.Milli,
         processingDuration: metric.attribution.processingDuration as Trace.Types.Timing.Milli,
         presentationDelay: metric.attribution.presentationDelay as Trace.Types.Timing.Milli,

package/front_end/models/logs/LogManager.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 * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
@@ -11,19 +12,33 @@ import {NetworkLog} from './NetworkLog.js';
 
 const modelToEventListeners = new WeakMap<SDK.LogModel.LogModel, Common.EventTarget.EventDescriptor[]>();
 
-let instance: LogManager|null = null;
-
 export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogModel.LogModel> {
-  private constructor() {
-    SDK.TargetManager.TargetManager.instance().observeModels(SDK.LogModel.LogModel, this);
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #networkLog: NetworkLog;
+
+  constructor(
+      targetManager: SDK.TargetManager.TargetManager,
+      networkLog: NetworkLog,
+  ) {
+    this.#targetManager = targetManager;
+    this.#networkLog = networkLog;
+    this.#targetManager.observeModels(SDK.LogModel.LogModel, this);
   }
 
   static instance({forceNew}: {forceNew: boolean} = {forceNew: false}): LogManager {
-    if (!instance || forceNew) {
-      instance = new LogManager();
+    if (!Root.DevToolsContext.globalInstance().has(LogManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(LogManager,
+                                                new LogManager(
+                                                    SDK.TargetManager.TargetManager.instance(),
+                                                    NetworkLog.instance(),
+                                                    ));
     }
 
-    return instance;
+    return Root.DevToolsContext.globalInstance().get(LogManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(LogManager);
   }
 
   modelAdded(logModel: SDK.LogModel.LogModel): void {
@@ -56,7 +71,7 @@ export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogMod
         target.model(SDK.RuntimeModel.RuntimeModel), entry.source, entry.level, entry.text, details);
 
     if (entry.networkRequestId) {
-      NetworkLog.instance().associateConsoleMessageWithRequest(consoleMessage, entry.networkRequestId);
+      this.#networkLog.associateConsoleMessageWithRequest(consoleMessage, entry.networkRequestId);
     }
 
     const consoleModel = target.model(SDK.ConsoleModel.ConsoleModel);
@@ -66,11 +81,11 @@ export class LogManager implements SDK.TargetManager.SDKModelObserver<SDK.LogMod
       // user can see messages from the worker which has been already destroyed.
       // When opening DevTools, give us some time to connect to the worker and
       // not report the message twice if the worker is still alive.
-      if (SDK.TargetManager.TargetManager.instance().targetById(workerId)) {
+      if (this.#targetManager.targetById(workerId)) {
         return;
       }
       window.setTimeout(() => {
-        if (!SDK.TargetManager.TargetManager.instance().targetById(workerId)) {
+        if (!this.#targetManager.targetById(workerId)) {
           consoleModel?.addMessage(consoleMessage);
         }
       }, 1000);

package/front_end/models/logs/NetworkLog.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 * as Protocol from '../../generated/protocol.js';
 
@@ -18,8 +19,6 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/logs/NetworkLog.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-let networkLogInstance: NetworkLog|undefined;
-
 export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDK.TargetManager.SDKModelObserver<SDK.NetworkManager.NetworkManager> {
   #requests: SDK.NetworkRequest.NetworkRequest[] = [];
@@ -32,15 +31,21 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   readonly #modelListeners = new WeakMap<SDK.NetworkManager.NetworkManager, Common.EventTarget.EventDescriptor[]>();
   readonly #initiatorData = new WeakMap<SDK.NetworkRequest.NetworkRequest, InitiatorData>();
   #isRecording = true;
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #settings: Common.Settings.Settings;
 
-  constructor() {
+  constructor(
+      targetManager: SDK.TargetManager.TargetManager = SDK.TargetManager.TargetManager.instance(),
+      settings: Common.Settings.Settings = Common.Settings.Settings.instance(),
+  ) {
     super();
+    this.#targetManager = targetManager;
+    this.#settings = settings;
 
-    SDK.TargetManager.TargetManager.instance().observeModels(SDK.NetworkManager.NetworkManager, this);
-    const recordLogSetting: Common.Settings.Setting<boolean> =
-        Common.Settings.Settings.instance().moduleSetting('network-log.record-log');
+    this.#targetManager.observeModels(SDK.NetworkManager.NetworkManager, this);
+    const recordLogSetting: Common.Settings.Setting<boolean> = this.#settings.moduleSetting('network-log.record-log');
     recordLogSetting.addChangeListener(() => {
-      const preserveLogSetting = Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log');
+      const preserveLogSetting = this.#settings.moduleSetting('network-log.preserve-log');
       if (!preserveLogSetting.get() && recordLogSetting.get()) {
         this.reset(true);
       }
@@ -49,14 +54,15 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   }
 
   static instance(): NetworkLog {
-    if (!networkLogInstance) {
-      networkLogInstance = new NetworkLog();
+    if (!Root.DevToolsContext.globalInstance().has(NetworkLog)) {
+      Root.DevToolsContext.globalInstance().set(NetworkLog, new NetworkLog());
     }
-    return networkLogInstance;
+
+    return Root.DevToolsContext.globalInstance().get(NetworkLog);
   }
 
   static removeInstance(): void {
-    networkLogInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(NetworkLog);
   }
 
   modelAdded(networkManager: SDK.NetworkManager.NetworkManager): void {
@@ -102,11 +108,10 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
     }
     this.#isRecording = enabled;
     if (enabled) {
-      SDK.TargetManager.TargetManager.instance().observeModels(SDK.NetworkManager.NetworkManager, this);
+      this.#targetManager.observeModels(SDK.NetworkManager.NetworkManager, this);
     } else {
-      SDK.TargetManager.TargetManager.instance().unobserveModels(SDK.NetworkManager.NetworkManager, this);
-      SDK.TargetManager.TargetManager.instance()
-          .models(SDK.NetworkManager.NetworkManager)
+      this.#targetManager.unobserveModels(SDK.NetworkManager.NetworkManager, this);
+      this.#targetManager.models(SDK.NetworkManager.NetworkManager)
           .forEach(this.removeNetworkManagerListeners.bind(this));
     }
   }
@@ -289,7 +294,7 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
   }
 
   private willReloadPage(): void {
-    if (!Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log').get()) {
+    if (!this.#settings.moduleSetting('network-log.preserve-log').get()) {
       this.reset(true);
     }
   }
@@ -310,7 +315,7 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
       return;
     }
 
-    const preserveLog = Common.Settings.Settings.instance().moduleSetting('network-log.preserve-log').get();
+    const preserveLog = this.#settings.moduleSetting('network-log.preserve-log').get();
 
     const oldRequests = this.#requests;
     const oldManagerRequests =
@@ -501,8 +506,8 @@ export class NetworkLog extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
     this.#requestsSet.clear();
     this.#requestsMap.clear();
     this.#unresolvedPreflightRequests.clear();
-    const managers = new Set<SDK.NetworkManager.NetworkManager>(
-        SDK.TargetManager.TargetManager.instance().models(SDK.NetworkManager.NetworkManager));
+    const managers =
+        new Set<SDK.NetworkManager.NetworkManager>(this.#targetManager.models(SDK.NetworkManager.NetworkManager));
     for (const manager of this.#pageLoadForManager.keys()) {
       if (!managers.has(manager)) {
         this.#pageLoadForManager.delete(manager);

package/front_end/models/persistence/AutomaticFileSystemManager.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import type * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as ProjectSettings from '../project_settings/project_settings.js';
 
 /**
@@ -26,8 +27,6 @@ export interface AutomaticFileSystem {
  */
 export type AutomaticFileSystemAvailability = 'available'|'unavailable';
 
-let automaticFileSystemManagerInstance: AutomaticFileSystemManager|undefined;
-
 /**
  * Automatically connects and disconnects workspace folders.
  *
@@ -66,9 +65,8 @@ export class AutomaticFileSystemManager extends Common.ObjectWrapper.ObjectWrapp
   /**
    * @internal
    */
-  private constructor(
-      inspectorFrontendHost: Host.InspectorFrontendHostAPI.InspectorFrontendHostAPI,
-      projectSettingsModel: ProjectSettings.ProjectSettingsModel.ProjectSettingsModel) {
+  constructor(inspectorFrontendHost: Host.InspectorFrontendHostAPI.InspectorFrontendHostAPI,
+              projectSettingsModel: ProjectSettings.ProjectSettingsModel.ProjectSettingsModel) {
     super();
     this.#automaticFileSystem = null;
     this.#inspectorFrontendHost = inspectorFrontendHost;
@@ -93,27 +91,30 @@ export class AutomaticFileSystemManager extends Common.ObjectWrapper.ObjectWrapp
     inspectorFrontendHost: Host.InspectorFrontendHostAPI.InspectorFrontendHostAPI|null,
     projectSettingsModel: ProjectSettings.ProjectSettingsModel.ProjectSettingsModel|null,
   } = {forceNew: false, inspectorFrontendHost: null, projectSettingsModel: null}): AutomaticFileSystemManager {
-    if (!automaticFileSystemManagerInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(AutomaticFileSystemManager) || forceNew) {
       if (!inspectorFrontendHost || !projectSettingsModel) {
         throw new Error(
             'Unable to create AutomaticFileSystemManager: ' +
             'inspectorFrontendHost, and projectSettingsModel must be provided');
       }
-      automaticFileSystemManagerInstance = new AutomaticFileSystemManager(
-          inspectorFrontendHost,
-          projectSettingsModel,
+      Root.DevToolsContext.globalInstance().set(
+          AutomaticFileSystemManager,
+          new AutomaticFileSystemManager(
+              inspectorFrontendHost,
+              projectSettingsModel,
+              ),
       );
     }
-    return automaticFileSystemManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(AutomaticFileSystemManager);
   }
 
   /**
    * Clears the `AutomaticFileSystemManager` singleton (if any);
    */
   static removeInstance(): void {
-    if (automaticFileSystemManagerInstance) {
-      automaticFileSystemManagerInstance.#dispose();
-      automaticFileSystemManagerInstance = undefined;
+    if (Root.DevToolsContext.globalInstance().has(AutomaticFileSystemManager)) {
+      Root.DevToolsContext.globalInstance().get(AutomaticFileSystemManager).#dispose();
+      Root.DevToolsContext.globalInstance().delete(AutomaticFileSystemManager);
     }
   }
 

package/front_end/models/persistence/AutomaticFileSystemWorkspaceBinding.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import type * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import type {ContentDataOrError} from '../text_utils/ContentData.js';
 import type {SearchMatch} from '../text_utils/ContentProvider.js';
 import * as Workspace from '../workspace/workspace.js';
@@ -141,14 +142,23 @@ export class FileSystem implements Workspace.Workspace.Project {
     return [];
   }
 
-  async findFilesMatchingSearchRequest(
-      _searchConfig: Workspace.SearchConfig.SearchConfig,
-      _filesMatchingFileQuery: Workspace.UISourceCode.UISourceCode[],
-      _progress: Common.Progress.Progress): Promise<Map<Workspace.UISourceCode.UISourceCode, SearchMatch[]|null>> {
+  async findFilesMatchingSearchRequest(_searchConfig: Workspace.SearchConfig.SearchConfig,
+                                       _filesMatchingFileQuery: Workspace.UISourceCode.UISourceCode[],
+                                       progress: Common.Progress.Progress):
+      Promise<Map<Workspace.UISourceCode.UISourceCode, SearchMatch[]|null>> {
+    // Defer completion to the next microtask to avoid triggering premature
+    // completion events in CompositeProgress setup loops.
+    await Promise.resolve();
+    progress.done = true;
     return new Map();
   }
 
-  indexContent(_progress: Common.Progress.Progress): void {
+  indexContent(progress: Common.Progress.Progress): void {
+    // Defer completion to the next microtask to avoid triggering premature
+    // completion events in CompositeProgress setup loops.
+    queueMicrotask(() => {
+      progress.done = true;
+    });
   }
 
   uiSourceCodeForURL(_url: Platform.DevToolsPath.UrlString): Workspace.UISourceCode.UISourceCode|null {
@@ -160,8 +170,6 @@ export class FileSystem implements Workspace.Workspace.Project {
   }
 }
 
-let automaticFileSystemWorkspaceBindingInstance: AutomaticFileSystemWorkspaceBinding|undefined;
-
 /**
  * Provides a transient workspace `Project` that doesn't contain any `UISourceCode`s,
  * and only acts as a placeholder for the automatic file system, while it's not
@@ -177,7 +185,7 @@ export class AutomaticFileSystemWorkspaceBinding {
   /**
    * @internal
    */
-  private constructor(
+  constructor(
       automaticFileSystemManager: AutomaticFileSystemManager,
       isolatedFileSystemManager: IsolatedFileSystemManager,
       workspace: Workspace.Workspace.WorkspaceImpl,
@@ -210,29 +218,33 @@ export class AutomaticFileSystemWorkspaceBinding {
     isolatedFileSystemManager: null,
     workspace: null,
   }): AutomaticFileSystemWorkspaceBinding {
-    if (!automaticFileSystemWorkspaceBindingInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(AutomaticFileSystemWorkspaceBinding) || forceNew) {
       if (!automaticFileSystemManager || !isolatedFileSystemManager || !workspace) {
         throw new Error(
             'Unable to create AutomaticFileSystemWorkspaceBinding: ' +
             'automaticFileSystemManager, isolatedFileSystemManager, ' +
             'and workspace must be provided');
       }
-      automaticFileSystemWorkspaceBindingInstance = new AutomaticFileSystemWorkspaceBinding(
+      const automaticFileSystemWorkspaceBinding = new AutomaticFileSystemWorkspaceBinding(
           automaticFileSystemManager,
           isolatedFileSystemManager,
           workspace,
       );
+      Root.DevToolsContext.globalInstance().set(AutomaticFileSystemWorkspaceBinding,
+                                                automaticFileSystemWorkspaceBinding);
     }
-    return automaticFileSystemWorkspaceBindingInstance;
+    return Root.DevToolsContext.globalInstance().get(AutomaticFileSystemWorkspaceBinding);
   }
 
   /**
    * Clears the `AutomaticFileSystemWorkspaceBinding` singleton (if any);
    */
   static removeInstance(): void {
-    if (automaticFileSystemWorkspaceBindingInstance) {
-      automaticFileSystemWorkspaceBindingInstance.#dispose();
-      automaticFileSystemWorkspaceBindingInstance = undefined;
+    if (Root.DevToolsContext.globalInstance().has(AutomaticFileSystemWorkspaceBinding)) {
+      const automaticFileSystemWorkspaceBinding =
+          Root.DevToolsContext.globalInstance().get(AutomaticFileSystemWorkspaceBinding);
+      automaticFileSystemWorkspaceBinding.#dispose();
+      Root.DevToolsContext.globalInstance().delete(AutomaticFileSystemWorkspaceBinding);
     }
   }
 

package/front_end/models/persistence/IsolatedFileSystem.ts

@@ -58,29 +58,27 @@ export class IsolatedFileSystem extends PlatformFileSystem {
   readonly #initialGitFolders = new Set<Platform.DevToolsPath.EncodedPathString>();
   private readonly fileLocks = new Map<Platform.DevToolsPath.EncodedPathString, Promise<unknown>>();
 
-  constructor(
-      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
-      embedderPath: Platform.DevToolsPath.RawPathString, domFileSystem: FileSystem, type: PlatformFileSystemType,
-      automatic: boolean) {
+  constructor(manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+              embedderPath: Platform.DevToolsPath.RawPathString, domFileSystem: FileSystem,
+              type: PlatformFileSystemType, automatic: boolean, settings: Common.Settings.Settings) {
     super(path, type, automatic);
     this.manager = manager;
     this.#embedderPath = embedderPath;
     this.domFileSystem = domFileSystem;
-    this.excludedFoldersSetting =
-        Common.Settings.Settings.instance().createLocalSetting('workspace-excluded-folders', {});
+    this.excludedFoldersSetting = settings.createLocalSetting('workspace-excluded-folders', {});
     this.#excludedFolders = new Set(this.excludedFoldersSetting.get()[path] || []);
   }
 
-  static async create(
-      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
-      embedderPath: Platform.DevToolsPath.RawPathString, type: PlatformFileSystemType, name: string, rootURL: string,
-      automatic: boolean): Promise<IsolatedFileSystem|null> {
+  static async create(manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+                      embedderPath: Platform.DevToolsPath.RawPathString, type: PlatformFileSystemType, name: string,
+                      rootURL: string, automatic: boolean,
+                      settings: Common.Settings.Settings): Promise<IsolatedFileSystem|null> {
     const domFileSystem = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isolatedFileSystem(name, rootURL);
     if (!domFileSystem) {
       return null;
     }
 
-    const fileSystem = new IsolatedFileSystem(manager, path, embedderPath, domFileSystem, type, automatic);
+    const fileSystem = new IsolatedFileSystem(manager, path, embedderPath, domFileSystem, type, automatic, settings);
     return await fileSystem.initializeFilePaths().then(() => fileSystem).catch(error => {
       console.error(error);
       return null;